void testGeometry() {
cout << "running testGeometry" << endl;
cout << "Creating Variables" << endl;
// Variable Declarations
// Points
const Point a = Point(0, 0), b = Point(100, 100), c = Point(0, 100);
const Point e = Point(200, 0), d = Point(100, 0), f = Point(100, 200);
// Poly's
const cnt tri {a, e, b}; // non-equal sides
const cnt square {a, c, b, d};
const cnt rect {a, c*2, f, d};
const cnt bigSquare {a*2-b, c*2-b, b*2-b, d*2-b};
// Fp's
const Fp testFp1 = Fp({bigSquare, square});
const Fp testFp2 = Fp({bigSquare}); // not a valid Fp
const Fp testFp3 = Fp({square}); // not a valid Fp
cout << "Creating Vectors" << endl;
// Vectors
// Poly's
const vector<cnt> vpoly1 {tri, square, bigSquare};
const vector<cnt> vpoly2 {tri, square};
const vector<cnt> vpoly3 {square, bigSquare};
const vector<cnt> vpoly4 {tri, bigSquare};
const vector<cnt> vpoly5 {tri};
const vector<cnt> vpoly6 {square};
const vector<cnt> vpoly7 {bigSquare};
// Fp's
const vector<Fp> vfp1 {testFp1, testFp2, testFp3};
const vector<Fp> vfp2 {testFp1, testFp2};
const vector<Fp> vfp3 {testFp2, testFp3};
const vector<Fp> vfp4 {testFp1, testFp3};
const vector<Fp> vfp5 {testFp1};
const vector<Fp> vfp6 {testFp2};
const vector<Fp> vfp7 {testFp3};
cout << "Test Methods..." << endl;
// Test Methods
// Centroid
Point tric = centroid(tri);
Point squarec = centroid(square);
Point bigsc = centroid(bigSquare);
cout << "Triangle" << tostr(tri) << tostr(tric) << endl;
cout << "Square" << tostr(square) << tostr(squarec) << endl;
cout << "Big Square" << tostr(bigSquare) << tostr(bigsc) << endl;
cout << "Square & BigSquare Centroid: " << tostr(centroid(vpoly3)) << endl;
// Dist & Angs
vector<double> dts = dists(tri);
vector<double> ans = angles(tri);
cout << "Triangle lengths: " << vtostr(dts) << endl;
cout << "Triangle angles: " << vtostr(ans) << endl;
cout << "Unit Angle: " << "Origin - " << tostr(a) << "; Point - " << tostr(b) << "; Ang - " << angle(a,b) << endl;
// All same length
cout << "Triangle all same length? " << allSameLength(tri, (double)0.0) << endl;
cout << "Square all same length? " << allSameLength(square, (double)0.0) << endl;
// isPoly
bool test1 = isPoly(tri, 3, false, false, 0, 0); // True
bool test2 = isPoly(tri, 3, true, true, 0, 0); // False
bool test3 = isPoly(tri, 4, false, false, 0, 0); // False
bool test4 = isRectangle(rect, false, 0, 0); // True
bool test5 = isRectangle(rect, true, 0, 0); // False
bool test6 = isSquare(square, 0, 0); // True
cout << test1 << test2 << test3 << test4 << test5 << test6 << endl;
}
/*
* adds a new row (constraint)
*/
BP_RETCODE bp_put(
BinaryProgram* bp, /**< binary program */
TYPE* coefs, /**< array of coefficients */
TYPE rhs /**< right hand side */
)
{
assert(bp_is_valid(bp));
/* abort if more rows (constraints) wants to be added than announced */
if (bp->m == bp->size)
{
fprintf(stderr, "BinaryProgram overflow size=%d\n", bp->m);
abort();
}
assert(bp->m < bp->size);
/* compute maximal and minimal activity */
TYPE max = 0;
TYPE min = 0;
#ifdef MORE_DEBUG
fprintf(stdout, "Add consttraint: ");
char* str;
str = allocate(MAX_STR_LEN, sizeof(*str));
#endif
for (int j = 0; j < bp->n; j++)
{
if (coefs[j] > 0)
{
max += coefs[j];
if (max < coefs[j])
{
printf("Reading detected possible overflow.\n");
return BP_ERROR;
}
}
else
{
if (coefs[j] < 0)
{
min += coefs[j];
if (min > coefs[j])
{
printf("Reading detected possible underflow.\n");
return BP_ERROR;
}
}
}
#ifdef MORE_DEBUG
if (j > 0)
fprintf(stdout, "+ ");
vtostr(str, coefs[j]);
fprintf(stdout, "%s x_%i ", str, j+1);
#endif
}
#ifdef MORE_DEBUG
vtostr(str, rhs);
fprintf(stdout, "<= %s\n", str);
deallocate(str);
#endif
/* constraint is redundant, when maximal activity is smaller or equal to rhight-hand side
* => constraint is not added
*/
if (max <= rhs)
{
#ifdef MORE_DEBUG
printf("Constraint is redundant.\n");
#endif
bp->redundant++;
return BP_OKAY;
}
/* constraint is infeasible, when minimal activity is greater than rhight-hand side
* => return infeasible
*/
if (min > rhs)
return BP_INFEASIBLE;
/* check for redundancy (multiple of other constraint)
* => constraint is not added, when it is redundant
*/
for (int i = 0; i < bp->m; i++)
{
if ((rhs == 0 && bp->rhs[i] == 0) || (rhs != 0 && bp->rhs[i] != 0))
{
double quotposmax = 0;
double quotposmin = 0;
double quotnegmax = 0;
double quotnegmin = 0;
double quot = 0;
int dom = 0;
int j = 0;
for (; j < bp->n; j++)
{
/* nothing to do, when both coefficients are zero */
if (coefs[j] == 0 && bp->coefs[j] == 0)
continue;
/* break, when one coefficient is zero and the other is negative */
else if ((coefs[j] == 0 && bp->coefs[j] < 0) || (coefs[j] < 0 && bp->coefs[j] == 0))
break;
/* only stored constraint can dominates new one, when coefficient of new one is zero */
else if (coefs[j] == 0 && bp->coefs[j] > 0)
{
if (dom == -1 || quot != 0)
break;
dom = 1;
}
/* only new constraint can dominates stored one, when coefficient of stored one is zero */
else if (coefs[j] > 0 && bp->coefs[j] == 0)
{
if (dom == 1 || quot != 0)
break;
dom = -1;
}
else
{
assert(coefs[j] != 0);
assert(bp->coefs[j] != 0);
double q = coefs[j] / bp->coefs[i*bp->n+j];
/* compute quotient for positive coefficients */
if (coefs[j] > 0 && bp->coefs[i*bp->n+j] > 0)
{
if (quot != 0)
break;
if (quotposmax == 0)
{
assert(quotposmin == 0);
quotposmax = q;
quotposmin = q;
}
else
{
quotposmax = MAX(quotposmax, q);
quotposmin = MIN(quotposmin, q);
}
if (quotnegmax != 0 && ((dom == 1 && quotposmax > quotnegmin) || (dom == -1 && quotposmin > quotnegmax)))
break;
}
/* compute quotient for negative coefficients */
else if (coefs[j] < 0 && bp->coefs[i*bp->n+j] < 0)
{
if (quot != 0)
break;
if (quotnegmax == 0)
{
assert(quotnegmin == 0);
quotnegmax = q;
quotnegmin = q;
}
else
{
quotnegmax = MAX(quotnegmax, q);
quotnegmin = MIN(quotnegmin, q);
}
if (quotposmax != 0 && ((dom == 1 && quotposmax > quotnegmin) || (dom == -1 && quotposmin > quotnegmax)))
break;
}
/* compute quotient for coefficients with different sign */
else
{
if (quotnegmax != 0 || quotposmax != 0 || dom != 0)
break;
if (quot == 0)
quot = q;
else if (abs(quot) - abs(q) < EPSILON )
break;
}
if (quotposmax == 0 && quotnegmax == 0)
continue;
if (quotposmax != 0 && quotnegmax != 0 && (quotposmax > quotnegmin || quotposmin < quotnegmax))
break;
if (quotposmax != 0 || quotnegmax != 0)
{
/* check whether stored constraint dominates new one */
if ((quotposmax > 0 && rhs >= bp->rhs[i] * quotposmax) || (quotposmax == 0 && rhs >= bp->rhs[i] * quotnegmin))
{
if (dom == -1)
break;
dom = 1;
}
/* check whether new constraint dominates stored one */
else if ((quotposmin > 0 && rhs <= bp->rhs[i] * quotposmin) || (quotposmin == 0 && rhs <= bp->rhs[i] * quotnegmax))
{
if (dom == 1)
break;
dom = -1;
}
/* none of the two constraints is dominating */
else
break;
}
/* should be dead code */
if (dom != 0 && quot != 0)
break;
}
}
if (j == bp->n)
{
assert( quotposmax != 0 || quotnegmax != 0 || quot != 0);
if (quot != 0)
{
if (rhs / quot + bp->rhs[i] < -EPSILON && dom == 0)
return BP_INFEASIBLE;
}
else
{
if (quotposmax == quotposmin && quotnegmax == quotnegmin)
{
assert(quotposmax != 0 || quotnegmax != 0);
assert(quotposmax == quotnegmax || quotposmax == 0 || quotnegmax == 0);
if (dom == 0)
bp->rhs[i] = MIN(bp->rhs[i], (TYPE)(rhs / quotposmax));
else if (dom == -1)
{
if ((quotposmin > 0 && rhs > bp->rhs[i] * quotposmin) || (quotposmin == 0 && rhs > bp->rhs[i] * quotnegmax))
continue;
for (int k= 0; k < bp->n; k++)
bp->coefs[i*bp->n+k] = coefs[k];
bp->rhs[i] = rhs;
}
else if ((quotposmax > 0 && rhs < bp->rhs[i] * quotposmax) || (quotposmax == 0 && rhs < bp->rhs[i] * quotnegmin))
continue;
}
else
{
assert(dom != 0);
if (dom == -1)
{
if ((quotposmin > 0 && rhs > bp->rhs[i] * quotposmin) || (quotposmin == 0 && rhs > bp->rhs[i] * quotnegmax))
continue;
for (int k= 0; k < bp->n; k++)
bp->coefs[i*bp->n+k] = coefs[k];
bp->rhs[i] = rhs;
}
else if ((quotposmax > 0 && rhs < bp->rhs[i] * quotposmax) || (quotposmax == 0 && rhs < bp->rhs[i] * quotnegmin))
continue;
}
#ifdef MORE_DEBUG
printf("redundant constraint.\n");
#endif
bp->redundant++;
return BP_OKAY;
}
}
}
}
/* add row (constraint) to binary program */
for (int i = 0; i < bp->n; i++)
bp->coefs[bp->m * bp->n + i] = coefs[i];
bp->rhs[bp->m] = rhs;
bp->m++;
assert(bp_is_valid(bp));
return BP_OKAY;
}
static char *
vtostr(char *name, void *_ts)
{
tcconf_section_t *ts = _ts;
tclist_item_t *li = NULL;
tcc_value *tv;
tcc_entry *te;
int l = 0;
char *s = NULL;
char *p = s;
int sp = 0;
#define ext(n) do { \
int o = p - s; \
s = realloc(s, l += n); \
p = s + o; \
} while(0)
tcref(ts);
if(!(te = getvalue(ts->sec, name, &ts)))
return NULL;
while((tv = tclist_next(te->value.values, &li))){
union {
uint64_t i;
double d;
char *s;
} v;
int sl;
cp_val(ts, tv, tv->type | TCC_LONG, &v);
if(sp)
*p++ = ' ';
switch(tv->type & TCC_TYPEMASK){
case TCC_INTEGER:
ext(22);
p += snprintf(p, 22, "%lli", v.i);
break;
case TCC_FLOAT:
ext(40);
p += snprintf(p, 40, "%lf", v.d);
break;
case TCC_REF:
v.s = vtostr(tv->value.string, ts);
case TCC_STRING:
sl = strlen(v.s);
ext(sl + 1);
strcpy(p, v.s);
free(v.s);
p += sl;
break;
}
sp = 1;
}
*p = 0;
#undef ext
tcfree(ts);
return s;
}
