// Svmult() multiplies mathematically the matrix of 'sylvester' with the matrix of 'vector'
void Svmult(Sylvester * sylvester, Vector * vector, Vector ** fin){
if(vector->dim!=sylvester->dim){
printf("Multiplication impossible due to different matrix dimensions!\n");
deleteVector(vector);
return;
}
int i=0,j=0;
char v='x';
if(sylvester->hidden=='x'){v='y';}
Sylvester * temp=NULL;
copysylvester(&temp, sylvester);
for(i=0;i<temp->dim;i++){
for(j=0;j<temp->dim;j++){
multiply1polyonym(&(temp->matrix[i][j]), &(temp->matrix[i][j]),(vector->matrix[j]).matrix[0]);
}
}
printVector(vector);
createZeroVector(fin, vector->dim, v);
for(i=0;i<temp->dim;i++){
for(j=0;j<temp->dim;j++){
add1polyonyms(&((*fin)->matrix[i]), &((*fin)->matrix[i]), &(temp->matrix[i][j]));
}
}
printVector(*fin);
destroysylvester(&temp);
deleteVector(vector);
deleteVector(*fin);
}
void VecArrayresize(const VecArray a, int newsize)
{
int i, j, m, nr, nc;
Vector V;
g_assert(a);
nc = VecArraySize(a);
nr = VecArrayVectorSize(a);
g_assert(nr);
g_assert(nc);
if(newsize < nr) m = newsize;
else m = nr;
for(i = 0; i < nc; i++)
{
V = newVector(newsize);
for(j = 0; j < m; j++) V[j] = a[i][j];
if(newsize > nr)
for(j = nr; j < newsize; j++) a[i][j] = 0.0;
deleteVector(a[i]);
a[i] = V;
}
}
void testcreateInputVectoranddeleteVector(void)
{
Vector * s = NULL;
createInputVector(&s);
deleteVector(s);
}
int main() {
int j_order;
int j_row_test;
float j_error;
int j_ite_max, qtdIteracoes;
float** ma;
float* mb;
float* approx;
float result = 0;
scanf("%d", &j_order);
scanf("%d", &j_row_test);
scanf("%f", &j_error);
scanf("%d", &j_ite_max);
ma = createMatrixFloat( j_order );
mb = createVectorFloat( j_order );
approx = createVectorFloat( j_order );
/* reads the values of the matrix a */
for(int i=0; i<j_order; i++)
for(int j=0; j<j_order; j++)
scanf("%f", &ma[i][j]);
/* assign the values of the first approximation */
for( int i=0; i<j_order; i++ )
approx[i] = 0;
/* reads the values of the matrix b */
for(int i=0; i<j_order; i++)
scanf("%f", &mb[i]);
qtdIteracoes = jacobiMethod( ma, approx, mb, j_order, j_ite_max, j_error );
for( int i = 0; i < j_order; i++ )
result += ma[j_row_test][i] * approx[i];
printf("Iterations: %d\n", qtdIteracoes);
printf("RowTest: %d => [%f] =? %f \n", j_row_test, result, mb[j_row_test]);
deleteMatrix( ma, j_order );
deleteVector( mb );
deleteVector( approx );
return 0;
}
VecArray VecArrayfromfile(const char *filename, int mincols)
{
VecArray a;
Vector v;
FILE *in;
int nc = 0, nr = 0, n, i, row;
char line[1024];
in = fopen(filename, "r");
if(!in) return 0;
for(;;)
{
fgets(line, 1023, in);
if(feof(in)) break;
/* look for "standard" comment characters */
if(line[0] == '#' || line[0] > 57 || line[0] == '*'
|| line[0] == '!' || line[0] == ';') continue;
n = stringtoVector(line, 0);
if(n >= mincols)
{
if(nc == 0) nc = n;
if(n >= nc) nr++;
}
}
fclose(in);
a = newpopulatedVecArray(nc, nr);
v = newVector(nc);
in = fopen(filename, "r");
for(row = 0; row < nr;)
{
fgets(line, 1023, in);
if(feof(in)) break;
if(line[0] == '#' || line[0] > 57 || line[0] == '*') continue;
n = stringtoVector(line, v);
if(n >= nc)
{
if(n >= nc)
{
for(i = 0; i < nc; i++) a[i][row] = v[i];
row++;
}
}
}
fclose(in);
deleteVector(v);
return a;
}
//------------------------------
KinematicsIntermediateData::~KinematicsIntermediateData()
{
// delete joints
deleteVectorFW(mJoints);
// delete joint instances
deleteVectorFW(mInstanceJoints);
// delete kinematic models
deleteMap(mKinematicsModels);
// delete kinematic controllers
deleteMap(mKinematicsControllers);
// delete instance kinematics scenes
deleteVector(mInstanceKinematicsScenes);
}
void delMusicFromDB(Music* music) {
Music *last = get_back_element(musicasDB);
//Swap da musica a eliminar pela ultima e "remoção" da ultima
int i = 0;
for (; i < sizeof(Music); ++i) {
*music = *last;
++music;
++last;
}
pop_backVector(musicasDB);
deleteVector(music->notes);
free(music);
}
void multVectorbytridiag(Vector v, const VecArray a)
{
int i, n;
Vector w, d, e;
g_assert(VecArraySize(a) == 2);
n = VectorSize(v);
g_assert(VecArrayVectorSize(a) == n);
d = a[0];
e = a[1];
w = dupVector(v);
v[0] = w[0]*d[0] + w[1]*e[1];
v[n-1] = w[n-1]*d[n-1] + w[n-2]*e[n-1];
for(i = 1; i < n-1; i++)
v[i] = w[i]*d[i] + w[i-1]*e[i-1] + w[i+1]*e[i];
deleteVector(w);
}
int main( int argc, char** argv )
{
//// User's choice
if ( argc == 1 )
{
std::cout << "Usage: " << argv[0] << "<output> <inputFile1> <inputFile2> ..." << std::endl;
std::cout << " - computes the difference of results between the" << std::endl;
std::cout << " CPU version of the estimator and the GPU version" << std::endl;
std::cout << " GPU file : positions are between [0;size]." << std::endl;
std::cout << " CPU file : positions are between [0;2*size]" << std::endl;
std::cout << " or [-size;size]." << std::endl;
std::cout << " Error type : 1 is l_1, 2 is l_2, 3 is l_\\infty." << std::endl;
std::cout << "Example:" << std::endl;
std::cout << argv[ 0 ] << " file1.txt file2.txt 64 3" << std::endl;
return 0;
}
std::string fileOutput = argc > 1 ? std::string( argv[ 1 ] ) : "file1.txt";
std::string fileInput = argc > 2 ? std::string( argv[ 2 ] ) : "file2.txt";
convertCPUtoKhalimsky predicateCPU;
std::vector< std::pair<Position*, Curvatures*> > v_export;
std::vector< std::pair<Position*, Value> > v_temp;
loadFile2( fileInput, v_temp, predicateCPU );
writeVector(v_temp, v_export, 0 );
deleteVector2( v_temp );
for(int i = 3; i < argc; ++i)
{
fileInput = std::string( argv[ i ] );
loadFile2( fileInput, v_temp, predicateCPU );
writeVector(v_temp, v_export, i-2);
deleteVector2( v_temp );
}
writeFile( fileOutput, v_export );
deleteVector( v_export );
return 0;
}
//------------------------------
KinematicsInstanceArticulatedSystem::~KinematicsInstanceArticulatedSystem()
{
// delete kinematic binds
deleteVector(mKinematicsBinds);
}
//------------------------------
KinematicsModel::~KinematicsModel()
{
// delete base links
deleteVector(mBaseLinks);
}
//------------------------------
KinematicsInstanceKinematicsScene::~KinematicsInstanceKinematicsScene()
{
// delete BindJointAxes
deleteVector(mBindJointAxes);
}
int main(int argc, char *argv[])
{
FILE *stream = NULL;
int i, j, r, count;
bool flag;
Matrix matrix = NULL;
Vector rhs = NULL;
VectorArray Lattice = NULL;
Vector vector = NULL;
LinearSystem initialsystem;
ZSolveContext ctx;
char *token;
int memory;
getopts(argc, argv);
puts(FORTY_TWO_BANNER);
if (OResume)
{
// START OF RESUME SECTION - READ FILES AND CREATE CONTEXT
strcat(BaseName, ".backup");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream==NULL)
{
printf("Unable to open backup file %s.backup\n", BaseName);
free(BaseName);
exit(1);
}
// options
if (fscanf(stream, "%d %d %d", &OVerbose, &OLogging, &OBackup)!=3 || OVerbose<0 || OVerbose>3 || OLogging<0 || OLogging>3 || OBackup<0)
{
fclose(stream);
printf("Backup file %s.backup does not contain valid data.\n", BaseName);
free(BaseName);
exit(2);
}
// get context
ctx = createZSolveContextFromBackup(stream, zsolveLogCallbackDefault, backupEvent);
fclose(stream);
// logfile
if (OLogging>0)
{
strcat(BaseName, ".log");
stream = fopen(BaseName, "a");
BaseName[BaseLength] = '\0';
if (stream==NULL)
{
printf("Unable to open log file %s.log\n", BaseName);
free(BaseName);
exit(1);
}
ctx->LogFile = LogFile = stream;
}
// END OF RESUME SECTION
}
else
{
// logfile
if (OLogging>0)
{
strcat(BaseName, ".log");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream==NULL)
{
printf("Unable to open log file %s.log\n", BaseName);
free(BaseName);
exit(1);
}
LogFile = stream;
}
// check for existance of solution files
if (!OForce)
{
strcat(BaseName, ".zhom");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
fclose(stream);
if (OVerbose>0)
printf("%s.hom already exists! Use -f to force calculation.\n", BaseName);
if (OLogging>0)
{
fprintf(LogFile, "%s.hom already exists! Use -f to force calculation.\n", BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
strcat(BaseName, ".zinhom");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
fclose(stream);
if (OVerbose>0)
printf("%s.inhom already exists! Use -f to force calculation.\n", BaseName);
if (LogFile)
{
fprintf(LogFile, "%s.inhom already exists! Use -f to force calculation.\n", BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
}
// matrix
strcat(BaseName, ".mat");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream == NULL)
{
stream = fopen(BaseName, "r");
if (stream) {
if (OVerbose>0)
printf("Matrix file %s.mat not found, falling back to project file %s.\n\n", BaseName, BaseName);
if (OLogging>0)
{
fprintf(LogFile, "Matrix file %s.mat not found, falling back to project file %s.\n\n", BaseName, BaseName);
fclose(LogFile);
}
}
}
if (stream==NULL)
{
strcat(BaseName, ".lat");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream==NULL)
{
// lattice
if (OVerbose>0)
printf("Neither matrix file %s.mat nor lattice file %s.lat exists!\n", BaseName, BaseName);
if (OLogging>0)
{
fprintf(LogFile, "Neither matrix file %s.mat nor lattice file %s.lat exists!\n", BaseName, BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
else
{
// START OF LATTICE SECTION - READ FILES AND CREATE CONTEXT
Lattice = readVectorArray(stream, false);
fclose(stream);
if (Lattice == NULL)
{
if (OVerbose>0)
printf("Lattice file %s.lat does not contain valid data.\n", BaseName);
if (OLogging>0)
{
fprintf(LogFile, "Lattice file %s.lat does not contain valid data.\n", BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
// rhs
if (ORightHandSide)
{
strcat(BaseName, ".rhs");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
fscanf(stream, "%d", &i);
if (i!=1)
{
fclose(stream);
printf("Height of RHS must be 1!\n");
if (LogFile)
{
fprintf(LogFile, "Height of RHS must be 1!\n");
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
fscanf(stream, "%d", &i);
while (i--)
{
if (fscanf(stream, "%d", &j) || j!=0)
{
printf("When reading from %s.lat, RHS file %s.rhs must contain a zero vector.\n", BaseName, BaseName);
if (LogFile)
{
fprintf(LogFile, "When reading from %s.lat, RHS file %s.rhs must contain a zero vector.\n", BaseName, BaseName);
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
}
}
}
// variable properties
for (i=0; i<Lattice->Variables; i++)
{
Lattice->Properties[i].Column = i;
Lattice->Properties[i].Lower = OHilbert ? 0 : -MAXINT;
Lattice->Properties[i].Upper = MAXINT;
Lattice->Properties[i].Free = (!OGraver && !OHilbert);
}
// read .rel
strcat(BaseName, ".rel");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &j)<2 || r != 1)
{
printf("RELATION file %s.rel must start with the dimensions.\n", BaseName);
flag = true;
}
for (i=0; i<j; i++)
{
if (readTokenFromFile(stream, "0123456789=<>", &token, &memory) == 0)
{
printf("RELATION file %s.rel ends unexpectedly.\n", BaseName);
flag = true;
}
else if (!strcmp(token, "<") || !strcmp(token, ">"))
{
printf("When reading from %s.lat, inequalities are not allowed.\n", BaseName);
flag = true;
}
else if (strcmp(token, "="))
{
printf("Unknown token '%s' in RELATION file %s.rel.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
free(BaseName);
exit(1);
}
}
// read .sign
strcat(BaseName, ".sign");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != Lattice->Variables || r != 1)
{
printf("SIGN file %s.sign must start with '1 %d'.\n", BaseName, Lattice->Variables);
flag = true;
}
for (i=0; i<Lattice->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789-abcdefghijklmnopqrstuvwxyz", &token, &memory) == 0)
{
printf("SIGN file %s.sign ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "0") || !strcmp(token, "free") || !strcmp(token, "f"))
{
Lattice->Properties[i].Upper = MAXINT;
Lattice->Properties[i].Lower = -MAXINT;
Lattice->Properties[i].Free = true;
}
else if (!strcmp(token, "1") || !strcmp(token, "hil") || !strcmp(token, "h"))
{
Lattice->Properties[i].Upper = MAXINT;
Lattice->Properties[i].Lower = 0;
Lattice->Properties[i].Free = false;
}
else if (!strcmp(token, "-1") || !strcmp(token, "-hil") || !strcmp(token, "-h"))
{
Lattice->Properties[i].Upper = 0;
Lattice->Properties[i].Lower = -MAXINT;
Lattice->Properties[i].Free = false;
}
else if (!strcmp(token, "2") || !strcmp(token, "graver") || !strcmp(token, "g"))
{
if (OHilbert)
{
printf("Input Error: Graver components for `hilbert' executable.\nInput Error: Use the `graver' executable instead.\n");
flag = true;
}
else
{
Lattice->Properties[i].Upper = MAXINT;
Lattice->Properties[i].Lower = -MAXINT;
Lattice->Properties[i].Free = false;
}
}
else
{
printf("Unknown token '%s' in SIGN file %s.sign.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteVectorArray(Lattice);
free(BaseName);
exit(1);
}
}
// read .ub
strcat(BaseName, ".ub");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != Lattice->Variables || r != 1)
{
printf("UPPER BOUNDS file %s.ub must start with '1 %d'.\n", BaseName, Lattice->Variables);
flag = true;
}
for (i=0; i<Lattice->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789*-", &token, &memory) == 0)
{
printf("UPPER BOUNDS file %s.ub ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "*"))
Lattice->Properties[i].Upper = MAXINT;
else if (sscanf(token, "%d", &j) == 1)
{
if (Lattice->Properties[i].Free)
{
printf("Upper bound '%s' cannot be set for free variables.\n", token);
flag = true;
}
else if (j>=0)
Lattice->Properties[i].Upper = j;
else
{
printf("Negative upper bound '%s' in UPPER BOUNDS file %s.ub.\n", token, BaseName);
flag = true;
}
}
else
{
printf("Unknown token '%s' in UPPER BOUNDS file %s.ub.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteVectorArray(Lattice);
free(BaseName);
exit(1);
}
}
// read .lb
strcat(BaseName, ".lb");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != Lattice->Variables || r != 1)
{
printf("LOWER BOUNDS file %s.lb must start with '1 %d'.\n", BaseName, Lattice->Variables);
flag = true;
}
for (i=0; i<Lattice->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789*-", &token, &memory) == 0)
{
printf("LOWER BOUNDS file %s.lb ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "*"))
Lattice->Properties[i].Lower = -MAXINT;
else if (sscanf(token, "%d", &j) == 1)
{
if (Lattice->Properties[i].Free)
{
printf("Lower bound '%s' cannot be set for free variables.\n", token);
flag = true;
}
else if (j<=0)
Lattice->Properties[i].Lower = j;
else
{
printf("Positive lower bound '%s' in LOWER BOUNDS file %s.lb.\n", token, BaseName);
flag = true;
}
}
else
{
printf("Unknown token '%s' in LOWER BOUNDS file %s.lb.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteVectorArray(Lattice);
free(BaseName);
exit(1);
}
}
ctx = createZSolveContextFromLattice(Lattice, LogFile, OLogging, OVerbose, zsolveLogCallbackDefault, backupEvent);
// print lattice
if (ctx->Verbosity>0)
{
printf("\nLattice to use:\n\n");
printVectorArray(ctx->Lattice, false);
printf("\n\n");
}
if (ctx->LogLevel>0)
{
fprintf(ctx->LogFile, "\nLattice to use:\n\n");
fprintVectorArray(ctx->LogFile, ctx->Lattice, false);
fprintf(ctx->LogFile, "\n\n");
}
// END OF LATTICE SECTION
}
}
else
{
// START OF SYSTEM SECTION - READ FILES AND CREATE CONTEXT
matrix = readMatrix(stream);
fclose(stream);
if (matrix==NULL)
{
printf("Matrix file %s does not contain valid data.\n", BaseName);
if (LogFile)
{
fprintf(LogFile, "Matrix file %s does not contain valid data.\n", BaseName);
fclose(LogFile);
}
free(BaseName);
exit(1);
}
// rhs
if (ORightHandSide)
{
strcat(BaseName, ".rhs");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
if (OGraver || OHilbert)
{
fclose(stream);
printf("Input Error: No rhs file is allowed with --graver and --hilbert!\n");
printf("Input Error: Please delete %s.rhs and rerun zsolve\n", BaseName);
if (LogFile)
{
fprintf(LogFile, "Input Error: No rhs file is allowed with --graver and --hilbert!\n");
fprintf(LogFile, "Input Error: Please delete %s.rhs and rerun zsolve\n", BaseName);
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
fscanf(stream, "%d", &i);
if (i!=1)
{
fclose(stream);
printf("Height of RHS must be 1!\n");
if (LogFile)
{
fprintf(LogFile, "Height of RHS must be 1!\n");
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
fscanf(stream, "%d", &i);
if (i!=matrix->Height)
{
fclose(stream);
printf("Matrix height conflicts with width of rhs!\n");
if (LogFile)
{
fprintf(LogFile, "Matrix height conflicts with width of rhs!\n");
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
rhs = readVector(stream, matrix->Height);
fclose(stream);
if (rhs==NULL)
{
printf("RHS file %s.rhs does not contain valid data.\n", BaseName);
if (LogFile)
{
fprintf(LogFile, "RHS file %s.rhs does not contain valid data.\n", BaseName);
fclose(LogFile);
}
deleteMatrix(matrix);
free(BaseName);
exit(1);
}
}
}
// fill with zeros
if (rhs==NULL)
{
rhs = createVector(matrix->Height);
for (i=0; i<matrix->Height; i++)
rhs[i] = 0;
}
// create system
initialsystem = createLinearSystem();
setLinearSystemMatrix(initialsystem, matrix);
deleteMatrix(matrix);
setLinearSystemRHS(initialsystem, rhs);
deleteVector(rhs);
// default limits
if (OGraver)
setLinearSystemLimit(initialsystem, -1, -MAXINT, MAXINT, false);
else if (OHilbert)
setLinearSystemLimit(initialsystem, -1, 0, MAXINT, false);
else
setLinearSystemLimit(initialsystem, -1, -MAXINT, MAXINT, true);
// default equation type
setLinearSystemEquationType(initialsystem, -1, EQUATION_EQUAL, 0);
// read .rel
strcat(BaseName, ".rel");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != initialsystem->Equations || r != 1)
{
printf("RELATION file %s.rel must start with '1 %d'.\n", BaseName, initialsystem->Equations);
flag = true;
}
for (i=0; i<initialsystem->Equations; i++)
{
if (readTokenFromFile(stream, "0123456789=<>", &token, &memory) == 0)
{
printf("RELATION file %s.rel ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "="))
setLinearSystemEquationType(initialsystem, i, EQUATION_EQUAL, 0);
// BUG: Not a real bug, but maybe misdefinition?? <= is not so hard to type :-)
else if (!strcmp(token, "<"))
setLinearSystemEquationType(initialsystem, i, EQUATION_LESSEREQUAL, 0);
else if (!strcmp(token, ">"))
setLinearSystemEquationType(initialsystem, i, EQUATION_GREATEREQUAL, 0);
else
{
printf("Unknown token '%s' in RELATION file %s.rel.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteLinearSystem(initialsystem);
free(BaseName);
exit(1);
}
}
// read .sign
strcat(BaseName, ".sign");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != initialsystem->Variables || r != 1)
{
printf("SIGN file %s.sign must start with '1 %d'.\n", BaseName, initialsystem->Variables);
flag = true;
}
for (i=0; i<initialsystem->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789-abcdefghijklmnopqrstuvwxyz", &token, &memory) == 0)
{
printf("SIGN file %s.sign ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "0") || !strcmp(token, "free") || !strcmp(token, "f"))
setLinearSystemLimit(initialsystem, i, -MAXINT, MAXINT, true);
else if (!strcmp(token, "1") || !strcmp(token, "hil") || !strcmp(token, "h"))
setLinearSystemLimit(initialsystem, i, 0, MAXINT, false);
else if (!strcmp(token, "-1") || !strcmp(token, "-hil") || !strcmp(token, "-h"))
setLinearSystemLimit(initialsystem, i, -MAXINT, 0, false);
else if (!strcmp(token, "2") || !strcmp(token, "graver") || !strcmp(token, "g"))
{
if (OHilbert)
{
if (!flag)
printf("Input Error: Graver components for `hilbert' executable.\nInput Error: Use the `graver' executable instead.\n");
flag = true;
}
else
setLinearSystemLimit(initialsystem, i, -MAXINT, MAXINT, false);
}
else
{
printf("Unknown token '%s' in SIGN file %s.sign.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteLinearSystem(initialsystem);
free(BaseName);
exit(1);
}
}
// read .ub
strcat(BaseName, ".ub");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != initialsystem->Variables || r != 1)
{
printf("UPPER BOUNDS file %s.ub must start with '1 %d'.\n", BaseName, initialsystem->Variables);
flag = true;
}
for (i=0; i<initialsystem->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789*-", &token, &memory) == 0)
{
printf("UPPER BOUNDS file %s.ub ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "*"))
setLinearSystemBound(initialsystem, i, 'u', MAXINT);
else if (sscanf(token, "%d", &j) == 1)
{
if (initialsystem->VarProperties[i].Free)
{
printf("Upper bound '%s' cannot be set for free variables.\n", token);
flag = true;
}
else if (j>=0)
setLinearSystemBound(initialsystem, i, 'u', j);
else
{
printf("Negative upper bound '%s' in UPPER BOUNDS file %s.ub.\n", token, BaseName);
flag = true;
}
}
else
{
printf("Unknown token '%s' in UPPER BOUNDS file %s.ub.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteLinearSystem(initialsystem);
free(BaseName);
exit(1);
}
}
// read .lb
strcat(BaseName, ".lb");
stream = fopen(BaseName, "r");
BaseName[BaseLength] = '\0';
if (stream!=NULL)
{
token = NULL;
memory = 0;
flag = false;
if (fscanf(stream, "%d %d", &r, &i)<2 || i != initialsystem->Variables || r != 1)
{
printf("LOWER BOUNDS file %s.lb must start with '1 %d'.\n", BaseName, initialsystem->Variables);
flag = true;
}
for (i=0; i<initialsystem->Variables; i++)
{
if (readTokenFromFile(stream, "0123456789*-", &token, &memory) == 0)
{
printf("LOWER BOUNDS file %s.lb ends unexpectedly.\n", BaseName);
flag = true;
}
if (!strcmp(token, "*"))
setLinearSystemBound(initialsystem, i, 'l', -MAXINT);
else if (sscanf(token, "%d", &j) == 1)
{
if (initialsystem->VarProperties[i].Free)
{
printf("Lower bound '%s' cannot be set for free variables.\n", token);
flag = true;
}
else if (j<=0)
setLinearSystemBound(initialsystem, i, 'l', j);
else
{
printf("Positive lower bound '%s' in LOWER BOUNDS file %s.lb.\n", token, BaseName);
flag = true;
}
}
else
{
printf("Unknown token '%s' in LOWER BOUNDS file %s.lb.\n", token, BaseName);
flag = true;
}
}
free(token);
fclose(stream);
if (flag)
{
deleteLinearSystem(initialsystem);
free(BaseName);
exit(1);
}
}
ctx = createZSolveContextFromSystem(initialsystem, LogFile, OLogging, OVerbose, zsolveLogCallbackDefault, backupEvent);
// END OF SYSTEM SECTION
}
}
// DEBUG
// printVectorArray(ctx->Lattice, true);
zsolveSystem(ctx, !OResume);
if (OGraver)
{
printf("Writing %d vectors to graver file, with respect to symmetry.\n", ctx->Graver->Size);
if (LogFile)
fprintf(LogFile, "Writing %d vectors to graver file, with respect to symmetry.\n", ctx->Graver->Size);
strcat(BaseName, ".gra");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Graver->Size, ctx->Graver->Variables);
fprintVectorArray(stream, ctx->Graver, false);
fclose(stream);
}
}
else if (OHilbert)
{
strcat(BaseName, ".hil");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Homs->Size + ctx->Frees->Size, ctx->Homs->Variables);
fprintVectorArray(stream, ctx->Homs, false);
fprintf(stream, "\n");
fprintVectorArray(stream, ctx->Frees, false);
fclose(stream);
}
}
else
{
strcat(BaseName, ".zinhom");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Inhoms->Size, ctx->Inhoms->Variables);
fprintVectorArray(stream, ctx->Inhoms, false);
fclose(stream);
}
strcat(BaseName, ".zhom");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Homs->Size, ctx->Homs->Variables);
fprintVectorArray(stream, ctx->Homs, false);
fclose(stream);
}
if (ctx->Frees->Size>0)
{
strcat(BaseName, ".zfree");
stream = fopen(BaseName, "w");
BaseName[BaseLength] = '\0';
if (stream)
{
fprintf(stream, "%d %d\n\n", ctx->Frees->Size, ctx->Frees->Variables);
fprintVectorArray(stream, ctx->Frees, false);
fclose(stream);
}
}
}
printf("\n4ti2 Total Time: ");
printCPUTime(maxd(getCPUTime() - ctx->AllTime, 0.0));
printf("\n");
if (LogFile) {
fprintf(LogFile, "\n4ti2 Total Time: ");
fprintCPUTime(LogFile, maxd(getCPUTime() - ctx->AllTime, 0.0));
fprintf(LogFile, "\n");
}
deleteZSolveContext(ctx, true);
if (BaseName!=NULL)
free(BaseName);
if (LogFile)
fclose(LogFile);
return EXIT_SUCCESS;
}
/*
* Cleanup after the init method.
*/
void finalizePhysics()
{
deleteVector(&temp1);
deleteVector(&temp2);
deleteVector(&rhs);
}
int jacobiMethod( float** a, float* approx, float* b, int size, int iter, float error ){
float** Dinv;
float**R;
float* matrixRes;
float* temp;
float* approx0;
int ctr = 0, octr;
int lastIteration = 0;
bool approachAchieved = 0;
Dinv = createMatrixFloat( size );
R = createMatrixFloat( size );
matrixRes = createVectorFloat( size );
temp = createVectorFloat( size );
approx0 = createVectorFloat( size );
//We calculate the diagonal inverse matrix make all other entries
//as zero except Diagonal entries whose resciprocal we store
for(int row = 0; row < size; row++){
for( int column = 0; column < size; column++ ){
if( row == column )
Dinv[row][column] = 1/a[row][column];
else
Dinv[row][column] = 0;
}
}
for(int row = 0; row < size; row++){
//calculating the R matrix L+U
for( int column = 0; column < size; column++ ){
if( row == column ){
R[row][column] = 0;
}
else if( row != column ){
R[row][column] = a[row][column];
}
}
}
while( ctr <= iter && approachAchieved == FALSE){
//copy values of approx to approx0
for(int i = 0; i < size; i++)
approx0[i] = approx[i];
//multiply L+U and the approximation
multiply( matrixRes, R, approx, size );
for( int row = 0; row < size; row++ ){
//the matrix( b-Rx )
temp[row] = b[row] - matrixRes[row]; //the matrix( b-Rx ) i
}
//multiply D inverse and ( b-Rx )
multiply( matrixRes, Dinv, temp, size );
for( octr = 0; octr < size; octr++ ){
//store matrixRes value int the nex approximation
approx[octr] = matrixRes[octr];
}
if( ctr > 0 )
approachAchieved = checkStoppingCriterion( approx, approx0, size, error );
lastIteration = ctr;
ctr++;
}
deleteMatrix(Dinv, size);
deleteMatrix(R, size);
deleteVector(matrixRes );
deleteVector(temp );
deleteVector(approx0 );
return lastIteration;
}
int main()
{
srand(time(NULL));
cout << "Vector:" << endl << endl;
insertVector(0); // Insert at start
insertVector(1); // Insert at middle
insertVector(2); // Insert at end
deleteVector(0); // Removes at first
deleteVector(1);
deleteVector(2);
walkVector(0);
walkVector(1);
cout << endl;
cout << "Deque:" << endl << endl;
insertDeque(0); // Insert at start
insertDeque(1); // Insert at middle
insertDeque(2); // Insert at end
deleteDeque(0); // Removes at first
deleteDeque(1);
deleteDeque(2);
walkDeque(0);
walkDeque(1);
// START OF ASSIGNMENT 4
linkedListType<int> *temp1;
temp1 = new linkedListType<int>;
timer t1;
cout << endl << "Linked List" << endl;
t1.start();
for(int c = 0; c<=5000; c++)
temp1->insertLast(rand() % 512);
t1.stop();
t1.start();
temp1->insertFirst(1); // Insert at first
temp1->insertFirst(2); // Insert at first
temp1->insertFirst(3); // Insert at first
t1.stop();
cout << setw(25) << setiosflags(ios::left) << "Insertion at first: " << setw(7) << resetiosflags(ios::left) << t1.putTime() << endl;
// Test to see if it was inserted correctly
if(temp1->getType(0) != 3) // It should equal 3
cout << "There was an error" << endl;
t1.start();
temp1->insertMiddle(13); // Insert at middle
temp1->insertMiddle(14); // Insert at middle
temp1->insertMiddle(15); // Insert at middle
t1.stop();
cout << setw(25) << setiosflags(ios::left) << "Insertion at middle: " << setw(7) << resetiosflags(ios::left) << t1.putTime() << endl;
// Test to see if it was inserted correctly
// ... the middle should be 15
if(temp1->getType((temp1->length() / 2)) != 15)
cout << "There was an error!" << endl;
t1.start();
temp1->insertLast(20); // Insert at last
temp1->insertLast(21); // Insert at last
temp1->insertLast(22); // Insert at last
t1.stop();
cout << setw(25) << setiosflags(ios::left) << "Insertion at last: " << setw(7) << resetiosflags(ios::left) << t1.putTime() << endl;
// Test the insertion
if(temp1->getType(temp1->length() - 1) != 22)
{
cout << "There was an error!" << endl;
}
t1.start();
temp1->deleteLocation(0); // Removal at first
temp1->deleteLocation(0); // Removal at first
temp1->deleteLocation(0); // Removal at first
t1.stop();
cout << setw(25) << setiosflags(ios::left) << "Removal at first: " << setw(7) << resetiosflags(ios::left) << t1.putTime() << endl;
// Test the removal
// it cannot be 3, because that's what was there before
if(temp1->getType(temp1->length()) == 3)
cout << "There was an error!" << endl;
t1.start();
temp1->deleteLocation(temp1->length() / 2); // Removal at middle
temp1->deleteLocation(temp1->length() / 2); // Removal at middle
temp1->deleteLocation(temp1->length() / 2); // Removal at middle
t1.stop();
cout << setw(25) << setiosflags(ios::left) << "Removal at middle: " << setw(7) << resetiosflags(ios::left) << t1.putTime() << endl;
t1.start();
temp1->deleteLocation(temp1->length()); // Removal at end
temp1->deleteLocation(temp1->length()); // Removal at end
temp1->deleteLocation(temp1->length()); // Removal at end
t1.stop();
cout << setw(25) << setiosflags(ios::left) << "Removal at end: " << setw(7) << resetiosflags(ios::left) << t1.putTime() << endl;
// Test the removal
// It shouldn't equal 22, because that's what was there
if(temp1->getType(temp1->length()) == 22)
cout << "There was an error" << endl;
// Walk forwards
t1.start();
for(int temp = 0; temp < temp1->length(); temp++)
// cout << temp << ": " << temp1->getType(temp) << endl;
int x = temp1->getType(temp); // Clean up output a bit
t1.stop();
cout << setw(25) << setiosflags(ios::left) << "Walk forwards: " << setw(7) << resetiosflags(ios::left) << t1.putTime() << endl;
// Walk backwards
t1.start();
temp1->reverseList();
for(int temp = 0; temp < temp1->length(); temp++)
// cout << temp << ": " << temp1->getType(temp) << endl;
int x = temp1->getType(temp); // clean up output
t1.stop();
cout << setw(25) << setiosflags(ios::left) << "Walk backwards: " << setw(7) << resetiosflags(ios::left) << t1.putTime() << endl;
return(0);
}
//------------------------------
KinematicsScene::~KinematicsScene()
{
// delete kinematics instance articulated systems
deleteVector(mKinematicsInstanceArticulatedSystems);
}
/* Assumes C is a linear cone (i.e. with apex zero).
* All equalities are removed first to speed up the computation
* in zsolve.
*/
Matrix *Cone_Hilbert_Basis(Polyhedron *C, unsigned MaxRays)
{
unsigned dim;
int i;
Matrix *M2, *M3, *T;
Matrix *CV = NULL;
LinearSystem initialsystem;
ZSolveMatrix matrix;
ZSolveVector rhs;
ZSolveContext ctx;
remove_all_equalities(&C, NULL, NULL, &CV, 0, MaxRays);
dim = C->Dimension;
for (i = 0; i < C->NbConstraints; ++i)
assert(value_zero_p(C->Constraint[i][1+dim]) ||
First_Non_Zero(C->Constraint[i]+1, dim) == -1);
M2 = Polyhedron2standard_form(C, &T);
matrix = Matrix2zsolve(M2);
Matrix_Free(M2);
rhs = createVector(matrix->Height);
for (i = 0; i < matrix->Height; i++)
rhs[i] = 0;
initialsystem = createLinearSystem();
setLinearSystemMatrix(initialsystem, matrix);
deleteMatrix(matrix);
setLinearSystemRHS(initialsystem, rhs);
deleteVector(rhs);
setLinearSystemLimit(initialsystem, -1, 0, MAXINT, 0);
setLinearSystemEquationType(initialsystem, -1, EQUATION_EQUAL, 0);
ctx = createZSolveContextFromSystem(initialsystem, NULL, 0, 0, NULL, NULL);
zsolveSystem(ctx, 0);
M2 = VectorArray2Matrix(ctx->Homs, C->Dimension);
deleteZSolveContext(ctx, 1);
Matrix_Transposition(T);
M3 = Matrix_Alloc(M2->NbRows, M2->NbColumns);
Matrix_Product(M2, T, M3);
Matrix_Free(M2);
Matrix_Free(T);
if (CV) {
Matrix *T, *M;
T = Transpose(CV);
M = Matrix_Alloc(M3->NbRows, T->NbColumns);
Matrix_Product(M3, T, M);
Matrix_Free(M3);
Matrix_Free(CV);
Matrix_Free(T);
Polyhedron_Free(C);
M3 = M;
}
return M3;
}
