PointNumero *DocRecord::ConvertDlistToArray(DListPeek *dlist, int *n) { DListPeek p, temp; int i, max = 0; PointNumero *ptr; p = *dlist; do { max++; //统计点数 p = Pred(p); } while(p != *dlist); ptr = new PointNumero[max + 1]; if(ptr == NULL) return NULL; p = *dlist; for(i = 0; i < max; i++) { ptr[i] = p->point_num; temp = p; p = Pred(p); delete temp; } ptr[max] = ptr[0]; *dlist = NULL; *n = max; return ptr; }
// This routine insert the point 'newPoint' in the list dlist, // respecting the clock-wise orientation、 //往dlist里插入newPoint int DocRecord::DListInsert(DListRecord **dlist, DPoint center, PointNumero newPoint) { DListRecord *p, *newp; double alpha1, alpha, beta, xx, yy; int first; newp = new DListRecord; newp->point_num = newPoint; if(*dlist == NULL) { //无结点 *dlist = newp; Pred(*dlist) = newp; Succ(*dlist) = newp; return 1; } if(Succ(*dlist) == *dlist) { //只有一个结点 Pred(*dlist) = newp; Succ(*dlist) = newp; Pred(newp) = *dlist; Succ(newp) = *dlist; return 1; } // If we are here, the double-linked circular list has 2 or more // elements, so we have to calculate where to put the new one p = *dlist; first = p->point_num; // first, compute polar coord. of the first point yy = (double)(points[first].where.v - center.v); xx = (double)(points[first].where.h - center.h); alpha1 = atan2(yy, xx); // compute polar coord of the point to insert yy = (double)(points[newPoint].where.v - center.v); xx = (double)(points[newPoint].where.h - center.h); beta = atan2(yy, xx) - alpha1; if(beta <= 0) beta += 2. * M_PI; do { yy = (double)(points[Succ(p)->point_num].where.v - center.v); xx = (double)(points[Succ(p)->point_num].where.h - center.h); alpha = atan2(yy, xx) - alpha1; if(alpha <= 1.e-15) alpha += 2. * M_PI; if(alpha >= beta) { //一直找到一个极角大于待插入点的极角的点 Succ(newp) = Succ(p); Succ(p) = newp; Pred(newp) = p; Pred(Succ(newp)) = newp; return 1; } p = Succ(p); } while(p != *dlist); // never here! return 0; }
int DocRecord::DListDelete(DListPeek *dlist, PointNumero oldPoint) { DListPeek p; if(*dlist == NULL) return 0; if(Succ(*dlist) == *dlist) { if((*dlist)->point_num == oldPoint) { delete *dlist; *dlist = NULL; return 1; } else return 0; } p = *dlist; do { if(p->point_num == oldPoint) { Succ(Pred(p)) = Succ(p); Pred(Succ(p)) = Pred(p); if(p == *dlist) { *dlist = Succ(p); } delete p; return 1; } p = Succ(p); } while(p != *dlist); return 0; }
// 通过a的之前邻居来找b的第一个邻居的num号 PointNumero DocRecord::Predecessor(PointNumero a, PointNumero b) { DListPeek p = points[a].adjacent; if(p == NULL) return -1; do { if(p->point_num == b) return Pred(p)->point_num; p = Pred(p); } while(p != points[a].adjacent); return -1; }
inline typename std::enable_if< execution::is_execution_policy<ExPolicy>::value, typename util::detail::algorithm_result<ExPolicy, bool>::type >::type lexicographical_compare(ExPolicy && policy, FwdIter1 first1, FwdIter1 last1, FwdIter2 first2, FwdIter2 last2, Pred && pred = Pred()) { #if defined(HPX_HAVE_ALGORITHM_INPUT_ITERATOR_SUPPORT) static_assert( (hpx::traits::is_input_iterator<FwdIter1>::value), "Requires at least input iterator."); static_assert( (hpx::traits::is_input_iterator<FwdIter2>::value), "Requires at least input iterator."); typedef std::integral_constant<bool, execution::is_sequenced_execution_policy<ExPolicy>::value || !hpx::traits::is_forward_iterator<FwdIter1>::value || !hpx::traits::is_forward_iterator<FwdIter2>::value > is_seq; #else static_assert( (hpx::traits::is_forward_iterator<FwdIter1>::value), "Requires at least forward iterator."); static_assert( (hpx::traits::is_forward_iterator<FwdIter2>::value), "Requires at least forward iterator."); typedef execution::is_sequenced_execution_policy<ExPolicy> is_seq; #endif return detail::lexicographical_compare().call( std::forward<ExPolicy>(policy), is_seq(), first1, last1, first2, last2, std::forward<Pred>(pred)); }
int main(){ TTableContext Context; // create scheme Schema AnimalS; AnimalS.Add(TPair<TStr,TAttrType>("Animal", atStr)); AnimalS.Add(TPair<TStr,TAttrType>("Size", atStr)); AnimalS.Add(TPair<TStr,TAttrType>("Location", atStr)); AnimalS.Add(TPair<TStr,TAttrType>("Number", atInt)); TIntV RelevantCols; RelevantCols.Add(0); RelevantCols.Add(1); RelevantCols.Add(2); // create table PTable T = TTable::LoadSS("Animals", AnimalS, "tests/animals.txt", Context, RelevantCols); //PTable T = TTable::LoadSS("Animals", AnimalS, "animals.txt"); T->Unique("Animal"); TTable Ts = *T; // did we fix problem with copy-c'tor ? //PTable Ts = TTable::LoadSS("Animals_s", AnimalS, "../../testfiles/animals.txt", RelevantCols); //Ts->Unique(AnimalUnique); // test Select // create predicate tree: find all animals that are big and african or medium and Australian TPredicate::TAtomicPredicate A1(atStr, true, EQ, "Location", "", 0, 0, "Africa"); TPredicate::TPredicateNode N1(A1); // Location == "Africa" TPredicate::TAtomicPredicate A2(atStr, true, EQ, "Size", "", 0, 0, "big"); TPredicate::TPredicateNode N2(A2); // Size == "big" TPredicate::TPredicateNode N3(AND); N3.AddLeftChild(&N1); N3.AddRightChild(&N2); TPredicate::TAtomicPredicate A4(atStr, true, EQ, "Location", "", 0, 0, "Australia"); TPredicate::TPredicateNode N4(A4); TPredicate::TAtomicPredicate A5(atStr, true, EQ, "Size", "", 0, 0, "medium"); TPredicate::TPredicateNode N5(A5); TPredicate::TPredicateNode N6(AND); N6.AddLeftChild(&N4); N6.AddRightChild(&N5); TPredicate::TPredicateNode N7(OR); N7.AddLeftChild(&N3); N7.AddRightChild(&N6); TPredicate Pred(&N7); TIntV SelectedRows; Ts.Select(Pred, SelectedRows); TStrV GroupBy; GroupBy.Add("Location"); T->Group(GroupBy, "LocationGroup"); GroupBy.Add("Size"); T->Group(GroupBy, "LocationSizeGroup"); T->Count("LocationCount", "Location"); PTable Tj = T->Join("Location", Ts, "Location"); TStrV UniqueAnimals; UniqueAnimals.Add("Animals_1.Animal"); UniqueAnimals.Add("Animals_2.Animal"); Tj->Unique(UniqueAnimals, false); //print table T->SaveSS("tests/animals_out_T.txt"); Ts.SaveSS("tests/animals_out_Ts.txt"); Tj->SaveSS("tests/animals_out_Tj.txt"); return 0; }
CookiePath *CookiePath::GetNextPrefix() { OpStringC8 pth( PathPart()); if(pth.IsEmpty()) return NULL; CookiePath *cp = Pred(); int len1 = pth.Length(); int clen; int test = 1; while(cp && test!=0) { clen = cp->PathPart().Length(); if(clen < len1 && UriUnescape::isstrprefix(cp->PathPart().CStr(), pth.CStr(), UriUnescape::All)) test = 0; else test = UriUnescape::strcmp(cp->PathPart().CStr(), pth.CStr(), UriUnescape::Safe); if (test != 0) cp = cp->Pred(); } return (test == 0 ? cp : NULL); }
void insertNode(const T &key) { if (root == nullptr) { root = new BSTNode<T>(key); return; } BSTNode<T> *p = root, *pre = p; bool flag_left = true; while (p) { pre = p; if (key == p->key) return; else if (Pred()(key, p->key)) { p = p->left_child; flag_left = true; } else { p = p->right_child; flag_left = false; } } if (flag_left) pre->left_child = new BSTNode<T>(key, pre); else pre->right_child = new BSTNode<T>(key, pre); }
void f() { try { boost::unique_lock < boost::mutex > lk(mut); assert(test2 == 0); test1 = 1; cv.notify_one(); Clock::time_point t0 = Clock::now(); cv.wait_for(lk, milliseconds(250), Pred(test2)); Clock::time_point t1 = Clock::now(); if (runs == 0) { assert(t1 - t0 < max_diff); assert(test2 != 0); } else { assert(t1 - t0 - milliseconds(250) < max_diff); assert(test2 == 0); } ++runs; } catch(...) { std::cout << "ERROR exception" << __LINE__ << std::endl; assert(false); } }
inline typename std::enable_if< is_execution_policy<ExPolicy>::value, typename util::detail::algorithm_result<ExPolicy, OutIter>::type >::type set_union(ExPolicy && policy, InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2, OutIter dest, Pred && op = Pred()) { static_assert( (hpx::traits::is_input_iterator<InIter1>::value), "Requires at least input iterator."); static_assert( (hpx::traits::is_input_iterator<InIter2>::value), "Requires at least input iterator."); static_assert( (hpx::traits::is_output_iterator<OutIter>::value || hpx::traits::is_input_iterator<OutIter>::value), "Requires at least output iterator."); typedef std::integral_constant<bool, is_sequential_execution_policy<ExPolicy>::value || !hpx::traits::is_random_access_iterator<InIter1>::value || !hpx::traits::is_random_access_iterator<InIter2>::value || !hpx::traits::is_random_access_iterator<OutIter>::value > is_seq; return detail::set_union<OutIter>().call( std::forward<ExPolicy>(policy), is_seq(), first1, last1, first2, last2, dest, std::forward<Pred>(op)); }
void f() { L1 lk(m0); assert(test2 == 0); test1 = 1; cv.notify_one(); cv.wait(lk, Pred(test2)); assert(test2 != 0); }
void LWF::RemoveEventHandler(int eventId, int id) { if (id < 0) return; if (eventId < 0 || eventId >= (int)data->events.size()) return; EventHandlerList &list = m_eventHandlers[eventId]; list.erase(remove_if(list.begin(), list.end(), Pred(id)), list.end()); }
void Movie::RemoveEventHandler(string eventName, int id) { MovieEventHandlerListDictionary::iterator it = m_eventHandlers.find(eventName); if (it == m_eventHandlers.end()) return; MovieEventHandlerList& list = it->second; list.erase(remove_if(list.begin(), list.end(), Pred(id)), list.end()); }
void MovieEventHandlers::Remove(int id) { if (id < 0) return; for (int i = 0; i < EVENTS; ++i) remove_if(m_handlers[i].begin(), m_handlers[i].end(), Pred(id)); UpdateEmpty(); }
void ButtonEventHandlers::Remove(int id) { for (int i = 0; i < EVENTS; ++i) { ButtonEventHandlerList &list = m_handlers[i]; list.erase(remove_if(list.begin(), list.end(), Pred(id)), list.end()); } m_keyPressHandler.erase(remove_if(m_keyPressHandler.begin(), m_keyPressHandler.end(), KPred(id)), m_keyPressHandler.end()); UpdateEmpty(); }
inline typename std::enable_if< execution::is_execution_policy<ExPolicy>::value, typename util::detail::algorithm_result<ExPolicy, FwdIter>::type >::type adjacent_find(ExPolicy && policy, FwdIter first, FwdIter last, Pred && op = Pred()) { typedef hpx::traits::is_segmented_iterator<FwdIter> is_segmented; return detail::adjacent_find_( std::forward<ExPolicy>(policy), first, last, std::forward<Pred>(op), is_segmented()); }
void MovieEventHandlers::Remove(int id) { if (id < 0) return; for (int i = 0; i < EVENTS; ++i) { MovieEventHandlerList &list = m_handlers[i]; list.erase(remove_if(list.begin(), list.end(), Pred(id)), list.end()); } UpdateEmpty(); }
std::pair<BSTNode<T>*, bool> searchNode(const T &key) const { BSTNode<T> *p = root; while (p) { if (key == p->key) return{ p, true }; else if (Pred()(key, p->key)) p = p->left_child; else p = p->right_child; } return{ nullptr, false }; }
void test() { const unsigned N = 1000; int ia[N]; for (unsigned i = 0; i < N; ++i) ia[i] = i; int ib[N] = {0}; OutIter r = std::copy_if(InIter(ia), InIter(ia+N), OutIter(ib), Pred()); assert(base(r) == ib+N/3+1); for (unsigned i = 0; i < N/3+1; ++i) assert(ib[i] % 3 == 0); }
void LWFCore::RemoveEventHandler(string eventName, int id) { if (id < 0) return; int eventId = SearchEventId(eventName); if (eventId >= 0 && eventId < (int)data->events.size()) { RemoveEventHandler(eventId, id); } else { GenericEventHandlerDictionary::iterator it = m_genericEventHandlerDictionary.find(eventName); if (it != m_genericEventHandlerDictionary.end()) remove_if(it->second.begin(), it->second.end(), Pred(id)); } }
void dfs(const Vertex &v) { TransformEdge trans; IsEdgePred Pred(edgelist_base, vset_base); st.push(v); pred_val = true; while (!st.empty()) { Vertex tvert = st.top(); if (used.find(tvert) != used.end()) { out_sort.push_back(tvert); st.pop(); } else { in_sort.push_back(tvert); used.insert(tvert); std::for_each(vset_base.first, vset_base.second, [&Pred, &used, &st, this, &trans, &tvert] (const Vertex &q){ if ((used.find(q) == used.end()) && (Pred(trans(tvert, q)))) { st.push(q); } }); } } }
void erase_if(Pred pred = Pred()) { for(std::size_t i = 0; i < t.size(); ++i) { if(t[i].is_filled() && pred(t[i].value())) { t[i].make_deleted(); --elems; ++deleted; } } maybe_shrink(); }
void dfs(const Vertex &v) { TransformEdge trans; IsEdgePred Pred(edgelist_base, vset_base); st.push(v); pred_val = true; while (!st.empty()) { Vertex tvert = st.top(); if (used.find(tvert) != used.end()) { out_sort.push_back(tvert); st.pop(); } else { in_sort.push_back(tvert); used.insert(tvert); for (auto q = vset_base.first; q != vset_base.second; ++q) { if ((used.find(*q) == used.end()) && (Pred(trans(tvert, *q)))) { st.push(*q); } } } } }
// Cette routine efface toutes les listes d'adjacence de points // this routine will erase all the adjacency lists of items void DocRecord::RemoveAllDList() { int i; DListPeek p, temp; for(i = 0; i < numPoints; i++) if(points[i].adjacent != NULL) { p = points[i].adjacent; do { temp = p; p = Pred(p); delete temp; } while(p != points[i].adjacent); points[i].adjacent = NULL; } }
inline typename std::enable_if< is_execution_policy<ExPolicy>::value, typename util::detail::algorithm_result<ExPolicy, FwdIter>::type >::type adjacent_find(ExPolicy && policy, FwdIter first, FwdIter last, Pred && op = Pred()) { static_assert( (hpx::traits::is_forward_iterator<FwdIter>::value), "Requires at least a forward iterator"); typedef is_sequential_execution_policy<ExPolicy> is_seq; return detail::adjacent_find<FwdIter>().call( std::forward<ExPolicy>(policy), is_seq(), first, last, std::forward<Pred>(op)); }
// find a specific connection filtered by predicate function GvConnection* GvField::findConnection(GvBool (*Pred)(GvConnection *c, void *data),void *data) { GvConnection *c = connections; while (c!= NULL) { ASSERT_POINTER(c,GvConnection); GvConnection *next = c->next; if (Pred(c,data)) { return(c); } c = next; } return(NULL); }
void fn5( boost::fibers::mutex & m, boost::fibers::condition_variable & cv) { std::unique_lock< boost::fibers::mutex > lk( m); BOOST_CHECK(test2 == 0); test1 = 1; cv.notify_one(); std::chrono::steady_clock::time_point t0 = std::chrono::steady_clock::now(); int count=0; cv.wait_for(lk, ms(250), Pred(test2)); count++; std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now(); if (runs == 0) { BOOST_CHECK(t1 - t0 < ms(250+1000)); BOOST_CHECK(test2 != 0); } else { BOOST_CHECK(t1 - t0 - ms(250) < ms(count*250+100)); BOOST_CHECK(test2 == 0); } ++runs; }
BSTNode<T>* insertAuxiliary(BSTNode<T> *const p, const T &key) { if (p == nullptr) return p; bool flag_left = true; if (Pred()(key, p->key)) { if (insertAuxiliary(p->left_child, key) == nullptr) p->left_child = new BSTNode<T>(key, p); flag_left = true; } else { if (insertAuxiliary(p->right_child, key) == nullptr) p->right_child = new BSTNode<T>(key, p); flag_left = false; } return flag_left ? p->left_child : p->right_child; }
GvBool GvField::removeConnection(GvBool (*Pred)(GvConnection *c, void *data),void *data) { GvConnection ** prev = &connections; GvConnection *c = connections; while (c!= NULL) { ASSERT_POINTER(c,GvConnection); GvConnection *next = c->next; if (Pred(c,data)) { *prev = next; delete c; return(TRUE); } prev = &c->next; c = next; } return(FALSE); }
void NonLinearLeastSquares::Value (const ColumnVector& Parameters, bool, Real& v, bool& oorg) { Tracer tr("NonLinearLeastSquares::Value"); Y.ReSize(n_obs); X.ReSize(n_obs,n_param); // put the fitted values in Y, the derivatives in X. Pred.Set(Parameters); if (!Pred.IsValid()) { oorg=true; return; } for (int i=1; i<=n_obs; i++) { Y(i) = Pred(i); X.Row(i) = Pred.Derivatives(); } if (!Pred.IsValid()) { oorg=true; return; } // check afterwards as well Y = *DataPointer - Y; Real ssq = Y.SumSquare(); errorvar = ssq / (n_obs - n_param); cout << "\n" << setw(15) << setprecision(10) << " " << errorvar; Derivs = Y.t() * X; // get the derivative and stash it oorg = false; v = -0.5 * ssq; }