ddf_boolean ddf_CheckEmptiness(ddf_PolyhedraPtr poly, ddf_ErrorType *err)
{
ddf_rowset R, S;
ddf_MatrixPtr M=NULL;
ddf_boolean answer=ddf_FALSE;
*err=ddf_NoError;
if (poly->representation==ddf_Inequality){
M=ddf_CopyInequalities(poly);
set_initialize(&R, M->rowsize);
set_initialize(&S, M->rowsize);
if (!ddf_ExistsRestrictedFace(M, R, S, err)){
poly->child->CompStatus=ddf_AllFound;
poly->IsEmpty=ddf_TRUE;
poly->n=0;
answer=ddf_TRUE;
}
set_free(R);
set_free(S);
ddf_FreeMatrix(M);
} else if (poly->representation==ddf_Generator && poly->m<=0){
*err=ddf_EmptyVrepresentation;
poly->IsEmpty=ddf_TRUE;
poly->child->CompStatus=ddf_AllFound;
answer=ddf_TRUE;
poly->child->Error=*err;
}
return answer;
void ddf_InitialDataSetup(ddf_ConePtr cone)
{
long j, r;
ddf_rowset ZSet;
static ddf_Arow Vector1,Vector2;
static ddf_colrange last_d=0;
if (last_d < cone->d){
if (last_d>0) {
for (j=0; j<last_d; j++){
ddf_clear(Vector1[j]);
ddf_clear(Vector2[j]);
}
free(Vector1); free(Vector2);
}
Vector1=(myfloat*)calloc(cone->d,sizeof(myfloat));
Vector2=(myfloat*)calloc(cone->d,sizeof(myfloat));
for (j=0; j<cone->d; j++){
ddf_init(Vector1[j]);
ddf_init(Vector2[j]);
}
last_d=cone->d;
}
cone->RecomputeRowOrder=ddf_FALSE;
cone->ArtificialRay = NULL;
cone->FirstRay = NULL;
cone->LastRay = NULL;
set_initialize(&ZSet,cone->m);
ddf_AddArtificialRay(cone);
set_copy(cone->AddedHalfspaces, cone->InitialHalfspaces);
set_copy(cone->WeaklyAddedHalfspaces, cone->InitialHalfspaces);
ddf_UpdateRowOrderVector(cone, cone->InitialHalfspaces);
for (r = 1; r <= cone->d; r++) {
for (j = 0; j < cone->d; j++){
ddf_set(Vector1[j], cone->B[j][r-1]);
ddf_neg(Vector2[j], cone->B[j][r-1]);
}
ddf_Normalize(cone->d, Vector1);
ddf_Normalize(cone->d, Vector2);
ddf_ZeroIndexSet(cone->m, cone->d, cone->A, Vector1, ZSet);
if (set_subset(cone->EqualitySet, ZSet)){
if (ddf_debug) {
fprintf(stderr,"add an initial ray with zero set:");
set_fwrite(stderr,ZSet);
}
ddf_AddRay(cone, Vector1);
if (cone->InitialRayIndex[r]==0) {
ddf_AddRay(cone, Vector2);
if (ddf_debug) {
fprintf(stderr,"and add its negative also.\n");
}
}
}
}
ddf_CreateInitialEdges(cone);
cone->Iteration = cone->d + 1;
if (cone->Iteration > cone->m) cone->CompStatus=ddf_AllFound; /* 0.94b */
set_free(ZSet);
mxArray * ZH_set_Vlist(const dd_SetFamilyPtr Inc, const dd_SetFamilyPtr Adj)
{
mxArray *A, *row;
double *r;
dd_bigrange i, j; /* unsigned long int */
dd_bigrange cur;
set_type s, adj;
int count, total;
int num;
if(Inc){
num = (int) Inc->famsize;
A = mxCreateCellMatrix(num,1);
for (i=0;i<Inc->famsize;i++){
set_initialize(&s, Inc->set[i][0]);
set_copy(s, Inc->set[i]);
count=0;
if (set_card(s)>0) {
/*get the first element in the set*/
for (j=1;j<=s[0];j++){
if (set_member(j,s)) break;
}
cur = j;
total = set_card(s);
row = mxCreateDoubleMatrix(1,total,mxREAL);
r = mxGetPr(row);
while (count <= total){
/* write to the output */
set_delelem(s, cur);
r[count++]=(double)cur;
/* find its neighbor in list */
adj = Adj->set[cur-1];
for (j=1; j<=s[0]; j++){
if ((set_member(j,adj)==1 )&&(set_member(j,s)==1)) {
break;
}
}
if (j<=s[0])
cur = j;
else
break;
}
mxSetCell(A, i, row);
}
}
return A;
}
return 0;
}
static dd_ErrorType FaceEnumHelper(dd_MatrixPtr M, dd_rowset R, dd_rowset S)
{
dd_ErrorType err;
dd_rowset LL, ImL, RR, SS, Lbasis;
dd_rowrange iprev = 0;
dd_colrange dim;
dd_LPSolutionPtr lps = NULL;
set_initialize(&LL, M->rowsize);
set_initialize(&RR, M->rowsize);
set_initialize(&SS, M->rowsize);
set_copy(LL, M->linset);
set_copy(RR, R);
set_copy(SS, S);
/* note actual type of "value" is mpq_t (defined in cddmp.h) */
mytype value;
dd_init(value);
err = dd_NoError;
dd_boolean foo = dd_ExistsRestrictedFace(M, R, S, &err);
if (err != dd_NoError) {
#ifdef MOO
fprintf(stderr, "err from dd_ExistsRestrictedFace\n");
fprintf(stderr, "err = %d\n", err);
#endif /* MOO */
set_free(LL);
set_free(RR);
set_free(SS);
dd_clear(value);
return err;
}
if (foo) {
set_uni(M->linset, M->linset, R);
err = dd_NoError;
dd_FindRelativeInterior(M, &ImL, &Lbasis, &lps, &err);
if (err != dd_NoError) {
#ifdef MOO
fprintf(stderr, "err from dd_FindRelativeInterior\n");
fprintf(stderr, "err = %d\n", err);
#endif /* MOO */
dd_FreeLPSolution(lps);
set_free(ImL);
set_free(Lbasis);
set_free(LL);
set_free(RR);
set_free(SS);
dd_clear(value);
return err;
}
dim = M->colsize - set_card(Lbasis) - 1;
set_uni(M->linset, M->linset, ImL);
SEXP mydim, myactive, myrip;
PROTECT(mydim = ScalarInteger(dim));
PROTECT(myactive = rr_set_fwrite(M->linset));
int myd = (lps->d) - 2;
PROTECT(myrip = allocVector(STRSXP, myd));
for (int j = 1; j <= myd; j++) {
dd_set(value, lps->sol[j]);
char *zstr = NULL;
zstr = mpq_get_str(zstr, 10, value);
SET_STRING_ELT(myrip, j - 1, mkChar(zstr));
free(zstr);
}
REPROTECT(dimlist = CONS(mydim, dimlist), dimidx);
REPROTECT(riplist = CONS(myrip, riplist), ripidx);
REPROTECT(activelist = CONS(myactive, activelist), activeidx);
UNPROTECT(3);
dd_FreeLPSolution(lps);
set_free(ImL);
set_free(Lbasis);
if (dim > 0) {
for (int i = 1; i <= M->rowsize; i++) {
if ((! set_member(i, M->linset)) && (! set_member(i, S))) {
set_addelem(RR, i);
if (iprev) {
set_delelem(RR, iprev);
set_delelem(M->linset, iprev);
set_addelem(SS, iprev);
}
iprev = i;
err = FaceEnumHelper(M, RR, SS);
if (err != dd_NoError) {
#ifdef MOO
fprintf(stderr, "err from FaceEnumHelper\n");
fprintf(stderr, "err = %d\n", err);
#endif /* MOO */
set_copy(M->linset, LL);
set_free(LL);
set_free(RR);
set_free(SS);
dd_clear(value);
return err;
}
}
}
}
}
set_copy(M->linset, LL);
set_free(LL);
set_free(RR);
set_free(SS);
dd_clear(value);
return dd_NoError;
}
static SEXP FaceEnum(dd_MatrixPtr M)
{
PROTECT_WITH_INDEX(dimlist = R_NilValue, &dimidx);
PROTECT_WITH_INDEX(riplist = R_NilValue, &ripidx);
PROTECT_WITH_INDEX(activelist = R_NilValue, &activeidx);
dd_rowset R, S;
set_initialize(&R, M->rowsize);
set_initialize(&S, M->rowsize);
dd_ErrorType err = FaceEnumHelper(M, R, S);
set_free(R);
set_free(S);
if (err != dd_NoError) {
#ifdef MOO
switch (err) {
case dd_DimensionTooLarge:
fprintf(stderr, "err = dd_DimensionTooLarge\n");
break;
case dd_ImproperInputFormat:
fprintf(stderr, "err = dd_ImproperInputFormat\n");
break;
case dd_NegativeMatrixSize:
fprintf(stderr, "err = dd_NegativeMatrixSize\n");
break;
case dd_EmptyVrepresentation:
fprintf(stderr, "err = dd_EmptyVrepresentation\n");
break;
case dd_EmptyHrepresentation:
fprintf(stderr, "err = dd_EmptyHrepresentation\n");
break;
case dd_EmptyRepresentation:
fprintf(stderr, "err = dd_EmptyRepresentation\n");
break;
case dd_IFileNotFound:
fprintf(stderr, "err = dd_IFileNotFound\n");
break;
case dd_OFileNotOpen:
fprintf(stderr, "err = dd_OFileNotOpen\n");
break;
case dd_NoLPObjective:
fprintf(stderr, "err = dd_NoLPObjective\n");
break;
case dd_NoRealNumberSupport:
fprintf(stderr, "err = dd_NoRealNumberSupport\n");
break;
case dd_NotAvailForH:
fprintf(stderr, "err = dd_NotAvailForH\n");
break;
case dd_NotAvailForV:
fprintf(stderr, "err = dd_NotAvailForV\n");
break;
case dd_CannotHandleLinearity:
fprintf(stderr, "err = dd_CannotHandleLinearity\n");
break;
case dd_RowIndexOutOfRange:
fprintf(stderr, "err = dd_RowIndexOutOfRange\n");
break;
case dd_ColIndexOutOfRange:
fprintf(stderr, "err = dd_ColIndexOutOfRange\n");
break;
case dd_LPCycling:
fprintf(stderr, "err = dd_LPCycling\n");
break;
case dd_NumericallyInconsistent:
fprintf(stderr, "err = dd_NumericallyInconsistent\n");
break;
case dd_NoError:
fprintf(stderr, "err = dd_NoError\n");
break;
default:
fprintf(stderr, "err bogus, WTF????\n");
}
#endif /* MOO */
rr_WriteErrorMessages(err);
UNPROTECT(3);
return R_NilValue;
}
SEXP result;
SEXP resultnames;
PROTECT(result = allocVector(VECSXP, 3));
PROTECT(resultnames = allocVector(STRSXP, 3));
SET_STRING_ELT(resultnames, 0, mkChar("dimension"));
SET_STRING_ELT(resultnames, 1, mkChar("active.set"));
SET_STRING_ELT(resultnames, 2, mkChar("relative.interior.point"));
namesgets(result, resultnames);
SET_VECTOR_ELT(result, 0, PairToVectorList(dimlist));
SET_VECTOR_ELT(result, 1, PairToVectorList(activelist));
SET_VECTOR_ELT(result, 2, PairToVectorList(riplist));
UNPROTECT(5);
return result;
}
int main(int argc, char *argv[])
{
dd_MatrixPtr M1=NULL,M2=NULL,M2row=NULL,M1plus=NULL;
dd_colrange d1;
dd_rowrange i,m1,m2,m1plus;
dd_ErrorType err=dd_NoError,err1=dd_NoError,err2=dd_NoError;
dd_rowset delset,rowset2;
dd_Arow cvec; /* certificate */
time_t starttime, endtime;
dd_DataFileType inputfile1,inputfile2;
FILE *reading1=NULL,*reading2=NULL;
dd_set_global_constants(); /* First, this must be called. */
dd_WriteProgramDescription(stdout);
fprintf(stdout,"\ncddlib test program to check redundancy of additional data.\n");
if (argc>2){
strcpy(inputfile1,argv[1]);
strcpy(inputfile2,argv[2]);
}
/*
if (argc<=2){
fprintf(stdout,"\nUsage:\n redexter file1 file2\n");
goto _L99;
}
*/
if (!SetInputFile(&reading1,argv[1])){
fprintf(stdout,"\nSpecify file1.\n");
dd_SetInputFile(&reading1,inputfile1, &err1);
}
if (!SetInputFile(&reading2,argv[2])){
fprintf(stdout,"\nSpecify the secondary file.\n");
dd_SetInputFile(&reading2,inputfile2, &err2);
}
if ((err1==dd_NoError) && (err2==dd_NoError)) {
M1=dd_PolyFile2Matrix(reading1, &err1);
M2=dd_PolyFile2Matrix(reading2, &err2);
}
else {
fprintf(stderr,"Input file(s) not found\n");
goto _L99;
}
if ((err1!=dd_NoError) || (err2!=dd_NoError)) goto _L99;
m1=M1->rowsize;
m2=M2->rowsize;
set_initialize(&delset,m2);
m1plus=m1+1;
if (M1->representation==dd_Generator){
d1=(M1->colsize)+1;
} else {
d1=M1->colsize;
}
dd_InitializeArow(d1,&cvec);
fprintf(stdout, "\nThe first matrix\n");
dd_WriteMatrix(stdout, M1);
fprintf(stdout, "\nThe second matrix\n");
dd_WriteMatrix(stdout, M2);
printf("\nChecking whether each row of the second matrix is redundant w.r.t. the first.\n");
time(&starttime);
for (i=1; i<=m2; i++){
set_initialize(&rowset2,m2);
set_addelem(rowset2, i);
set_compl(delset, rowset2);
M2row=dd_MatrixSubmatrix(M2, delset);
M1plus=dd_MatrixAppend(M1,M2row);
if (dd_Redundant(M1plus, m1plus, cvec, &err)) {
printf("%ld-th row: redundant\n", i);
} else {
printf("%ld-th row: non-redundant\n A certificate:", i);
dd_WriteArow(stdout, cvec, d1);
}
dd_FreeMatrix(M1plus);
dd_FreeMatrix(M2row);
set_free(rowset2);
}
time(&endtime);
dd_WriteTimes(stdout,starttime,endtime);
set_free(delset);
dd_FreeMatrix(M1);
dd_FreeMatrix(M2);
_L99:;
if (err1!=dd_NoError) dd_WriteErrorMessages(stderr,err1);
if (err2!=dd_NoError) dd_WriteErrorMessages(stderr,err2);
return 0;
}
/*
* Parse the generator output. Find the generators which are vertices
* (non-rays) add their corresponding inequalities to an output set.
*
* Returns a matrix where each row contains the x-coordinate of the vertex,
* y-coordinate of the vertex, and 0-based index of the inequality which bounds
* the polytope to the right of the vertex. output_size is set to the total
* length of the ouptut.
*/
static double *list_extreme_vertices(const dd_MatrixPtr generators,
const dd_SetFamilyPtr incidence,
const size_t nrows,
long lower_bound_index,
/*OUT*/ size_t * output_size)
{
assert(generators->rowsize > 0);
assert(generators->colsize > 2);
set_type cur_vert_set, next_vert_set, s;
dd_rowrange i;
long elem;
size_t out_row = 0, r;
size_t vertex_count = count_vertices(generators);
/* Last vertex intersects with upper bound - not output */
*output_size = 3 * (vertex_count - 1);
double *output = (double *) malloc(sizeof(double) * (*output_size));
/* Sorted indices into generators */
size_t *indices = sort_generators(generators);
assert(*output_size > 0);
/* Loop over vertices in generators, extracting solutions
*
* For vertices 0..n_vertices-2, find the inequality incident to the vertex
* also incident in the next vertex.
*/
for (i = 0; i < vertex_count - 1; i++) {
r = indices[i];
assert(is_vertex(generators->matrix[r][0]));
assert(is_vertex(generators->matrix[indices[i + 1]][0]));
assert(out_row < vertex_count - 1);
cur_vert_set = incidence->set[r];
next_vert_set = incidence->set[indices[i + 1]];
/* Sets should be same size */
assert(cur_vert_set[0] == next_vert_set[0]);
set_initialize(&s, cur_vert_set[0]);
set_int(s, cur_vert_set, next_vert_set);
/* Remove added index for first item */
/*if (!i)*/
/*set_delelem(s, lower_bound_index);*/
/* Set may have > 1 solution if ~identical slopes and intercepts due to
* rounding. */
/*assert(set_card(s) == 1); */
/* Only one item in the set */
elem = set_first(s);
set_free(s);
/* Fill output row */
int base = out_row * 3;
output[base] = *generators->matrix[r][1]; /* x */
output[base + 1] = *generators->matrix[r][2]; /* y */
output[base + 2] = (double) (elem - 1); /* ineq index, converted to 0-base */
out_row++;
}
free(indices);
return output;
}
