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;
}
