int unify_variable2(wam_t *wam, var_t *v1, var_t *v2)
{
if (v1 == NULL || v2 == NULL) return 0;
v1 = deref(v1);
v2 = deref(v2);
if (v1 == v2) return 1;
if (v1->tag == REF) {
trail_add(wam->trail, v1);
var_copy(v1, v2);
return 1;
}
if (v2->tag == REF) {
trail_add(wam->trail, v2);
var_copy(v2, v1);
return 1;
}
if (v1->tag == CON && v2->tag == CON) {
if (strcmp(v1->value, v2->value) == 0)
return 1;
else
return 0;
}
if ((v1->tag == LIS && v2->tag == LIS) ||
(v1->tag == STR && v2->tag == STR)) {
if (unify_variable2(wam, v1->head, v2->head) &&
unify_variable2(wam, v1->tail, v2->tail))
return 1;
}
return 0;
}
int unify_struc2(wam_t *wam, var_t *struc, var_t *head, var_t* tail)
{
if (struc->tag == REF) {
trail_add(wam->trail, struc);
struc->tag = STR;
struc->head = head;
struc->tail = tail;
return 1;
}
if (struc->tag == STR) {
if (unify_variable2(wam, head, struc->head))
if (unify_variable2(wam, tail, struc->tail))
return 1;
}
return 0;
}
int unify_list2(wam_t *wam, var_t *list, var_t *head, var_t *tail)
{
if (list->tag == REF) {
trail_add(wam->trail, list);
list->tag = LIS;
list->head = head;
list->tail = tail;
return 1;
}
if (list->tag == LIS) {
if (unify_variable2(wam, head, list->head)) {
if (unify_variable2(wam, tail, list->tail))
return 1;
}
}
return 0;
}
int get_constant(wam_t *wam, char *constname, char *regname)
{
var_t *v = deref(wam_get_ref(wam, regname));
int failed = 1;
if (v->tag == REF) {
trail_add(wam->trail, v);
v->tag = CON;
strcpy(v->value, constname);
failed = 0;
} else if (v->tag == CON) {
if (strcmp(constname, v->value) == 0)
failed = 0;
}
if (failed)
wam_backtrack(wam);
else
wam->pc += 1;
return 0;
}
bool
DynamicPersistenceTrails<D,CT,OT,E,Cmp,CCmp>::
transpose(iterator i, const DimensionFunctor& dimension, Visitor visitor)
{
#if LOGGING
typename Traits::OutputMap outmap(order());
#endif
Count(cTransposition);
typedef typename Element::Trail::iterator TrailIterator;
visitor.transpose(i);
iterator i_prev = i++;
if (dimension(i_prev) != dimension(i))
{
swap(i_prev, i);
rLog(rlTranspositions, "Different dimension");
Count(cTranspositionDiffDim);
return false;
}
bool si = i_prev->sign(), sii = i->sign();
if (si && sii)
{
rLog(rlTranspositions, "Trail prev: %s", i_prev->trail.tostring(outmap).c_str());
// Case 1
if (trail_remove_if_contains(i_prev, index(i)))
rLog(rlTranspositions, "Case 1, U[i,i+1] = 1");
iterator k = iterator_to(i_prev->pair);
iterator l = iterator_to(i->pair);
// rLog(rlTranspositions, "(i_prev, k), (i, l): (%s, %s), (%s, %s)",
// outmap(i_prev).c_str(), outmap(k).c_str(),
// outmap(i).c_str(), outmap(l).c_str());
// Explicit treatment of unpaired simplex
if (l == i)
{
swap(i_prev, i);
rLog(rlTranspositions, "Case 1.2 --- unpaired");
rLog(rlTranspositions, "%s", outmap(i_prev).c_str());
Count(cTranspositionCase12);
return false;
} else if (k == i_prev)
{
if (!(l->cycle.contains(index(i_prev))))
{
// Case 1.2
swap(i_prev, i);
rLog(rlTranspositions, "Case 1.2 --- unpaired");
rLog(rlTranspositions, outmap(i_prev).c_str());
Count(cTranspositionCase12);
return false;
} else
{
// Case 1.2 --- special version (plain swap, but pairing switches)
swap(i_prev, i);
pairing_switch(i_prev, i);
visitor.switched(i, Case12);
rLog(rlTranspositions, "Case 1.2 --- unpaired (pairing switch)");
rLog(rlTranspositions, outmap(i_prev).c_str());
Count(cTranspositionCase12s);
return true;
}
}
rLog(rlTranspositions, "l cycle: %s", l->cycle.tostring(outmap).c_str());
if (!(l->cycle.contains(index(i_prev))))
{
// Case 1.2
rLog(rlTranspositions, "k is in l: %d", (bool) l->trail.contains(index(k))); // if true, a special update would be needed to maintain lazy decomposition
swap(i_prev, i);
rLog(rlTranspositions, "Case 1.2");
Count(cTranspositionCase12);
return false;
} else
{
// Case 1.1
if (std::not2(order_comparison())(index(k),index(l)))
{
// Case 1.1.1
swap(i_prev, i);
cycle_add(l, k->cycle); // Add column k to l
trail_add(k, l->trail); // Add row l to k
rLog(rlTranspositions, "Case 1.1.1");
Count(cTranspositionCase111);
return false;
} else
{
// Case 1.1.2
swap(i_prev, i);
cycle_add(k, l->cycle); // Add column l to k
trail_add(l, k->trail); // Add row k to l
pairing_switch(i_prev, i);
visitor.switched(i, Case112);
rLog(rlTranspositions, "Case 1.1.2");
Count(cTranspositionCase112);
return true;
}
}
} else if (!si && !sii)
{
// Case 2
if (!(i_prev->trail.contains(index(i))))
{
// Case 2.2
swap(i_prev, i);
rLog(rlTranspositions, "Case 2.2");
Count(cTranspositionCase22);
return false;
} else
{
// Case 2.1
iterator low_i = iterator_to(i_prev->pair);
iterator low_ii = iterator_to(i->pair);
trail_add(i_prev, i->trail); // Add row i to i_prev
cycle_add(i, i_prev->cycle); // Add column i_prev to i
swap(i_prev, i);
if (std::not2(order_comparison())(index(low_ii), index(low_i)))
{
// Case 2.1.2
cycle_add(i_prev, i->cycle); // Add column i to i_prev (after transposition)
trail_add(i, i_prev->trail); // Add row i to i_prev
pairing_switch(i_prev, i);
visitor.switched(i, Case212);
rLog(rlTranspositions, "Case 2.1.2");
Count(cTranspositionCase212);
return true;
}
// Case 2.1.1
rLog(rlTranspositions, "Case 2.1.1");
Count(cTranspositionCase211);
return false;
}
} else if (!si && sii)
{
// Case 3
if (!(i_prev->trail.contains(index(i))))
{
// Case 3.2
swap(i_prev, i);
rLog(rlTranspositions, "Case 3.2");
Count(cTranspositionCase32);
return false;
} else
{
// Case 3.1
trail_add(i_prev, i->trail); // Add row i to i_prev
cycle_add(i, i_prev->cycle); // Add column i_prev to i
swap(i_prev, i);
cycle_add(i_prev, i->cycle); // Add column i_prev to i (after transposition)
trail_add(i, i_prev->trail); // Add row i to i_prev
pairing_switch(i_prev, i);
visitor.switched(i, Case31);
rLog(rlTranspositions, "Case 3.1");
Count(cTranspositionCase31);
return true;
}
} else if (si && !sii)
{
// Case 4
if (trail_remove_if_contains(i_prev, index(i)))
rLog(rlTranspositions, "Case 4, U[i,i+1] = 1");
swap(i_prev, i);
rLog(rlTranspositions, "Case 4");
Count(cTranspositionCase4);
return false;
}
return false; // to avoid compiler complaints; we should never reach this point
}
