int input_argument_free ( void )
{
int fail,n;
char outfile[80],ch;
printf("\nReading and writing a polynomial system ...\n");
fail = read_standard_target_system();
if(v==1) printf("-> read_target_system returns %d\n",fail);
fail = copy_target_system_to_container();
if(v==1) printf("-> copy_target_system_to_container returns %d\n",fail);
printf("\nThe system read :\n");
fail = print_system();
if(v==1) printf("-> print_system returns %d\n",fail);
printf("\nGive name of the output file : ");
scanf("%s",outfile);
n = (int) strlen(outfile);
fail = define_output_file_with_string(n,outfile);
if(v==1) printf("-> define_output_file_with_string returns %d\n",fail);
fail = print_system();
if(v==1) printf("-> print_system returns %d\n",fail);
fail = write_string_to_defined_output_file(21,"\nTITLE : some system\n");
if(v==1) printf("-> write_string_to_defined_output_file returns %d\n",fail);
fail = close_output_file();
if(v==1) printf("-> close_output_file returns %d\n",fail);
return 0;
}
int main(int argc, char** argv) {
if (argc != (1 + NREACT + 4 + 2)) {
printf("usage: %s " // argc = 1
"<c1> <c2> <c3> <c4> <c5> <c6> " // + NREACT
"<W> <X> <Y> <Z> " // + 4
"<tint> <tmax>\n", argv[0]); // + 2
exit(EXIT_FAILURE);
}
struct sys33* sys = init_system(argv);
double tint = strtod(argv[NREACT + 4 + 1], NULL); // time inteval between outputs
double tmax = strtod(argv[NREACT + 4 + 2], NULL); // maximum time of simulation
double tout = tint; // time of next output
double t = 0.0; // time
print_system(t, sys);
srand(time(NULL));
while (t <= tmax) {
t += react_system(sys);
if (t >= tout) {
print_system(t, sys);
tout += tint;
}
}
free(sys);
exit(EXIT_SUCCESS);
}
static void print_systems(cfg_t *cfg)
{
size_t i;
for (i = 0; i < cfg_size(cfg, "provider"); i++)
print_system(cfg_getnsec(cfg, "provider", i));
}
/* simulate the system with the parameters specified in sys and write output to outfile */
void simulate(FILE* outfile, System* sys)
{
long long nsteps = sys->nsteps;
long long print_period = sys->print_period;
for(int i = 0; i < nsteps; i++)
{
if(i % print_period == 0)
{
sys->cur_step = i;
print_system(outfile, sys);
}
simulate_one_step(sys, i, sys->time_step);
}
sys->cur_step = nsteps;
print_system(outfile, sys);
}
unsigned long long
dt08rf1(char* aname, char* cname, int seconds)
{
FILE* afile = fopen(aname, "r");
FILE* cfile = fopen(cname, "r");
fm_count = 0;
if (afile == NULL) {
fprintf(stderr, "could not open file A\n");
exit(1);
}
if (cfile == NULL) {
fprintf(stderr, "could not open file c\n");
exit(1);
}
/*fm_system* system = (fm_system*)malloc(sizeof(fm_system));
system->rows = parse_files(afile, cfile);
system->nbr_rows = count_rows(afile);*/
fm_system* system = parse_files(afile, cfile);
print_system(system);
//TODO: move
f_m_elim(system);
elim_2(system);
if (seconds == 0) {
/* Just run once for validation. */
// Uncomment when your function and variables exist...
// return fm_elim(rows, cols, a, c);
fm_elim(NULL, 0);
return 1; // return one, i.e. has a solution for now...
}
/* Tell operating system to call function DONE when an ALARM comes. */
signal(SIGALRM, done);
alarm(seconds);
/* Now loop until the alarm comes... */
proceed = true;
while (proceed) {
// Uncomment when your function and variables exist...
// fm_elim(rows, cols, a, c);
fm_elim(NULL, 0);
fm_count++;
}
return fm_count;
}
int main(int argc, char *argv[]) {
int dims = 2;
int nr_particles = 5;
if (argc > 1)
dims = atoi(argv[1]);
if (argc > 2)
nr_particles = atoi(argv[2]);
System *system = init_system(nr_particles, dims);
print_system(system);
printf("total mass = %lf\n", total_mass(system));
double cms[dims];
center_of_mass(system, cms);
print_position(cms, dims);
free_system(system);
return EXIT_SUCCESS;
}
int standard_test ( void )
{
int fail,n,dim,deg,nbloops,kind;
char ans;
printf("\nReading a witness set ...\n");
fail = read_witness_set(&n,&dim,°);
printf("\nMENU for the kind of output :\n");
printf(" 0. remain silent with no intermediate output;\n");
printf(" 1. all intermediate output goes to screen;\n");
printf(" 2. give a file name for all intermediate output.\n");
printf("Type 0, 1, or 2 to make a choice : "); scanf("%d",&kind);
scanf("%c",&ans); /* skip end of line character */
if(kind == 0) fail = set_state_to_silent();
if(kind == 2) fail = define_output_file();
if(verbose>0) /* only in verbose mode */
{
printf("\nThe ambient dimension : %d.\n",n);
printf("The dimension of the solution set : %d.\n",dim);
printf("The degree of the solution set : %d.\n",deg);
printf("\nDo you wish to see the embedded system ? (y/n) ");
scanf("%c",&ans);
if(ans == 'y')
{
printf("\nThe system read :\n");
fail = print_system();
}
}
fail = assign_labels(n,deg,0);
printf("\nGive the number of loops : ");
scanf("%d",&nbloops);
fail = standard_monodromy_breakup(nbloops,n,dim,deg);
if(kind == 2) printf("See the output file for results.\n");
return 0;
}
int f_m_elim(fm_system* system){
return 5;
unsigned int r = system->nbr_rows;
unsigned int s = system->curr_nbr_x;
unsigned int s2;
printf("sizeof(fm_poly_entry): %llu\n", (unsigned long long) sizeof(fm_poly_entry));
printf("system->nbr_rows: %u\n", system->nbr_rows);
printf("system->nbr_x: %u\n", system->nbr_x);
printf("system->curr_nbr_x: %u\n", system->curr_nbr_x);
fm_poly_entry* t = (fm_poly_entry*)malloc(sizeof(fm_poly_entry)*system->nbr_rows*system->nbr_x);
fm_poly_entry* q = (fm_poly_entry*)malloc(sizeof(fm_poly_entry)*system->nbr_rows);
unsigned int i, j, n1, n2;
unsigned int* ns;
fm_poly_entry entry;
fm_poly *b1, *b2;
fm_row row;
fm_poly *poly_lesser, *poly_greater;
for(i = 0; i < system->nbr_rows; ++i){
row = system->rows[i];
poly_lesser = row.lesser;
poly_greater = row.greater;
if(poly_lesser->poly_len == 1 && poly_lesser->poly[0].index == 0){ //lesser == const side
for(j = 0; j < system->nbr_x; ++j){
t[i + j] = poly_greater->poly[j];
}
q[i] = poly_lesser->poly[0];
} else if(poly_greater->poly_len == 1 && poly_greater->poly[0].index == 0){ //greater == const side
for(j = 0; j < system->nbr_x; ++j){
t[i + j] = poly_lesser->poly[j];
}
q[i] = poly_greater->poly[0];
}
}
while(1){
ns = sort_by_coeffs(system);
n1 = ns[0];
n2 = n1 + ns[1];
for(i = 0; i < r - 1; ++i){
for(j = 0; j < n2; ++j){
entry = t[i + j];
entry.numerator = entry.numerator * t[r + j].denominator;
entry.denominator = entry.denominator * t[r + j].numerator;
}
}
for(j = 0; j < n2; ++j){
entry = q[j];
entry.numerator = entry.numerator * t[r + j].denominator;
entry.denominator = entry.denominator * t[r + j].numerator;
}
printf("B1:\n");
if(n2 > n1){
int c = 0;
b1 = (fm_poly*)malloc(sizeof(fm_poly)*(n2 - (n1)));
//b1->poly_len = 0;
for(j = n1; j < n2; ++j){
fm_poly_entry* tmp = malloc(sizeof(fm_poly_entry)*(r+1));
for(i = 0; i < r - 1; ++i){
tmp[i] = t[i + j]; //TODO: neg?
}
tmp[i+1] = q[j];
b1[c].poly_len = r - 1;
b1[c].poly = tmp;
c++;
}
print_poly(&(b1[c]));
//free(tmp);
}else{
b1 = NULL;
}
printf("B2:\n");
if(n1 > 0){
int c = 0;
b2 = (fm_poly*)malloc(sizeof(fm_poly)*(n1));
//b2->poly_len = 0;
for(j = 0; j < n1; ++j){
fm_poly_entry* tmp = malloc(sizeof(fm_poly_entry)*(r+1));
for(i = 0; i < r - 1; ++i){
tmp[i] = t[i + j]; //TODO: neg?
}
tmp[i+1] = q[j];
b2[c].poly_len = r - 1;
b2[c].poly = tmp;
c++;
}
print_poly(&(b2[c]));
}else{
b2 = NULL;
}
if(r == 1){
if((b1 != NULL && b2 != NULL) && (b1[0].poly->numerator * b2[0].poly->denominator) > (b2[0].poly->numerator * b1[0].poly->denominator)){
return 0;
}
for(j = n2; j < s; ++j){
if(q[j].numerator < 0){
return 0;
}
}
return 1;
}
s2 = s - n2 + n1 * (n2 - n1);
if(s2 == 0){
return 1;
}
//s - n2 + n1n2 -n1n1
//n2
r--;
s = s2;
//fm_row *b_combined_rows = (fm_row*) malloc(sizeof(fm_row)*n1*(n2-n1)); //TODO: wutwutwut
fm_row *b_combined_rows = (fm_row*) malloc(sizeof(fm_row)*s);
fm_poly l, g;
unsigned int k, row_count;
row_count = 0;
fm_row *tmp_test_row = (fm_row*) malloc(sizeof(fm_row));
for(i = 0; i < (n2-n1); ++i){
for(j = 0; j < n1; ++j){
l = b1[i];
g = b2[j];
tmp_test_row->lesser = &l;
tmp_test_row->greater = &g;
printf("tem test? ");
print_row(tmp_test_row);
fm_poly *poly = (fm_poly*) malloc(sizeof(fm_poly));
fm_poly_entry *entries = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*(l.poly_len-1));
for(k = 0; k < l.poly_len - 2; ++k){
fm_poly_entry pe_l = l.poly[k];
fm_poly_entry pe_g = g.poly[k];
fm_poly_entry *tmp_entry = &(entries[k]);
tmp_entry->numerator = pe_l.numerator * pe_g.denominator - pe_g.numerator * pe_l.denominator;
tmp_entry->denominator = pe_l.denominator * pe_g.denominator;
tmp_entry->index = pe_g.index;
}
poly->poly = entries;
poly->poly_len = k;
b_combined_rows[row_count].lesser = poly;
fm_poly_entry pe_l = l.poly[k];
fm_poly_entry pe_g = g.poly[k];
poly = (fm_poly*) malloc(sizeof(fm_poly));
poly->poly = (fm_poly_entry*) malloc(sizeof(fm_poly_entry));
poly->poly_len = 1;
b_combined_rows[row_count].greater = poly;
poly->poly[0].numerator = pe_l.numerator * pe_g.denominator - pe_g.numerator * pe_l.denominator;
poly->poly[0].denominator = pe_l.denominator * pe_g.denominator;
poly->poly[0].index = pe_g.index;
printf("comb rows \n");
print_row(b_combined_rows);
row_count++;
}
for(i = n2; i < s; ++i){
b_combined_rows[row_count].lesser = system->rows[i].lesser;
b_combined_rows[row_count].greater = system->rows[i].greater;
print_row(b_combined_rows);
row_count++;
}
}
system->rows = b_combined_rows;
printf("Changed system?!?!?!?\n");
print_system(system);
/*
typedef struct {
long long numerator;
long long denominator;
unsigned long long index; // 14*x_{index} + -2x_{index} <= 68. 0 designates no x variable
} fm_poly_entry;
typedef struct {
unsigned int poly_len;
fm_poly_entry *poly;
} fm_poly;
typedef struct {
fm_poly *lesser;
fm_poly *greater;
} fm_row;
typedef struct{
unsigned int nbr_rows;
unsigned int nbr_x; //largest x index in system
unsigned int curr_nbr_x; //current largest x index, changes with elimination
fm_row* rows;
} fm_system;
*/
/*
fm_poly *b_combined = (fm_poly*) malloc(sizeof(fm_poly)*s);
fm_poly_entry b_constants
*/
/*///////////////////////////
fm_poly_entry *t_ik;
fm_poly_entry *t_il;
fm_poly_entry *q_k;
fm_poly_entry *q_l;
unsigned int k, l;
fm_poly_entry *new_t = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*(r-1)*s2);
fm_poly_entry *new_q = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*s2);
fm_poly_entryb1plusb2 =
for(i = 0; i < r - 1; ++i){
for(k = 0; k < n1; ++k){
for(l = n1; l < n2; ++l){
t_ik = t[i + k];
t_il = t[i + l];
q_k = q[k];
q_l = q[l];
//TODO: wut?
new_t[ + i].numerator = (t_ik->numerator * t_il->denominator) - (t_il->numerator * t_ik->denominator);
new_t[ + i].denominator = t_ik->denominator * t_il->denominator;
new_t[ + i].index = i;
new_q[].numerator = (q_k->numerator * q_l->denominator) - (q_l->numerator * q_k->denominator);
new_q[].denominator = q_k->denominator * q_l->denominator;
new_q[].index = 0;
}
}
for(j = n2; j < s2; ++j){
new_t[].numerator = t[i +j].numerator;
new_t[].denominator = t[i +j].denominator;
new_t[].index = t[i +j].index;
new_q[].numerator = q[j].numerator;
new_q[].denominator = q[j].denominator;
new_q[].index = 0;
}
}
//TODO: move up
r--;
s = s2;
*/
/*
fm_poly_entry *new_t = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*r*s);
fm_poly_entry *new_q = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*s);
fm_row *new_rows = (fm_row*) malloc(sizeof(fm_row)*s);
for(j = 0; j < s; ++j){
fm_poly *lesser_poly = (fm_poly*) malloc(sizeof(fm_poly));
fm_poly *greater_poly = (fm_poly*) malloc(sizeof(fm_poly));
fm_poly_entry *lesser_poly_entries = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*r);
fm_poly_entry *greater_poly_entries = (fm_poly_entry*) malloc(sizeof(fm_poly_entry));
lesser_poly->poly_len = r;
greater_poly->poly_len = 1;
lesser_poly->poly = lesser_poly_entries;
greater_poly->poly = greater_poly_entries;
new_rows[j].lesser = lesser_poly;
new_rows[j].greater = greater_poly;
//memcpy(&(greater_poly->poly[0]), &(q[j]), sizeof(fm_poly_entry));
greater_poly->poly[0].numerator = q[j].numerator;
greater_poly->poly[0].denominator = q[j].denominator;
greater_poly->poly[0].index = q[j].index;
//memcpy(&(new_q[j]), &(q[j]), sizeof(fm_poly_entry));
new_q[j].numerator = q[j].numerator;
new_q[j].denominator = q[j].denominator;
new_q[j].index = q[j].index;
for(i = 0; i < r; ++i){
//memcpy(&(lesser_poly->poly[0]), &(t[i+j]), sizeof(fm_poly_entry));
lesser_poly->poly[0].numerator = t[i+j].numerator;
lesser_poly->poly[0].denominator = t[i+j].denominator;
lesser_poly->poly[0].index = t[i+j].index;
//memcpy(&(new_t[i+j]), &(t[i+j]), sizeof(fm_poly_entry));
new_t[i+j].numerator = t[i+j].numerator;
new_t[i+j].denominator = t[i+j].denominator;
new_t[i+j].index = t[i+j].index;
}
printf("ROW: ");
print_row(&(new_rows[j]));
}
//TODO: Free old t&&q
//t = new_t;
//q = new_q;
printf("SYSTEM #1?\n");
print_system(system);
system->nbr_rows = r;
system->curr_nbr_x -= 1;
system->rows = new_rows;
printf("SYSTEM #2?\n");
print_system(system);
*/
}
}
int elim_2(fm_system* system){
unsigned int i, j;
//Sort
unsigned int* ns = sort_by_coeffs(system);
unsigned int n_pos = ns[0];
unsigned int n_neg = ns[1];
unsigned int n_zero = ns[2];
unsigned int n_non_zero = n_pos + n_neg;
fm_poly *tmp_poly;
fm_poly_entry tmp_poly_entry;
//Divide
for(i = 0; i < n_pos + n_neg; ++i){
tmp_poly = system->rows[i].lesser;
tmp_poly_entry = tmp_poly->poly[tmp_poly->poly_len - 1];
for(j = 0; j < tmp_poly->poly_len; ++j){
tmp_poly->poly[j].numerator = tmp_poly->poly[j].numerator * tmp_poly_entry.denominator;
tmp_poly->poly[j].denominator = tmp_poly->poly[j].denominator * tmp_poly_entry.numerator;
}
system->rows[i].greater->poly[0].numerator = system->rows[i].greater->poly[0].numerator * tmp_poly_entry.denominator;
system->rows[i].greater->poly[0].denominator = system->rows[i].greater->poly[0].denominator * tmp_poly_entry.numerator;
if((tmp_poly_entry.numerator < 0 && tmp_poly_entry.denominator > 0) || (tmp_poly_entry.numerator > 0 && tmp_poly_entry.denominator < 0)){
system->rows[i].lesser = system->rows[i].greater;
system->rows[i].greater = tmp_poly;
}
}
printf("\nDivide:\n");print_system(system);
//Isolate
fm_row *new_rows = (fm_row*) malloc(sizeof(fm_row)*n_non_zero);
fm_poly *new_poly = (fm_poly*) malloc(sizeof(fm_poly)*n_non_zero);
fm_poly_entry *new_entries = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*system->nbr_rows*system->curr_nbr_x);
fm_poly *curr_poly;
printf("\nIsolate:\n");
for(i = 0; i < n_non_zero; ++i){
curr_poly = &(new_poly[i]);
curr_poly->poly_len = system->curr_nbr_x;
curr_poly->poly = &(new_entries[i*curr_poly->poly_len]);
if(system->rows[i].lesser->poly_len == 1 && system->rows[i].lesser->poly[0].index == 0){ //if lesser == const side
for(j=0; j < system->curr_nbr_x-1; ++j){
curr_poly->poly[j].numerator = -system->rows[i].greater->poly[j].numerator;
curr_poly->poly[j].denominator = system->rows[i].greater->poly[j].denominator;
curr_poly->poly[j].index = system->rows[i].greater->poly[j].index;
}
curr_poly->poly[j].numerator = system->rows[i].lesser->poly[0].numerator;
curr_poly->poly[j].denominator = system->rows[i].lesser->poly[0].denominator;
curr_poly->poly[j].index = system->rows[i].lesser->poly[0].index;
new_rows[i].greater = NULL;
new_rows[i].lesser = curr_poly;
} else {
for(j=0; j < system->curr_nbr_x-1; ++j){
curr_poly->poly[j].numerator = -system->rows[i].lesser->poly[j].numerator;
curr_poly->poly[j].denominator = system->rows[i].lesser->poly[j].denominator;
curr_poly->poly[j].index = system->rows[i].lesser->poly[j].index;
}
curr_poly->poly[j].numerator = system->rows[i].greater->poly[0].numerator;
curr_poly->poly[j].denominator = system->rows[i].greater->poly[0].denominator;
curr_poly->poly[j].index = system->rows[i].greater->poly[0].index;
new_rows[i].lesser = NULL;
new_rows[i].greater = curr_poly;
}
print_row(&(new_rows[i]));
}
//B's
fm_poly *b1 = (fm_poly*) malloc(sizeof(fm_poly)*(system->nbr_rows));
fm_poly *b2 = (fm_poly*) malloc(sizeof(fm_poly)*(system->nbr_rows));
unsigned int n_b1 = 0;
unsigned int n_b2 = 0;
for(i = 0; i < n_non_zero; ++i){
if(new_rows[i].lesser == NULL){
b2[n_b2++] = *(new_rows[i].greater);
} else {
b1[n_b1++] = *(new_rows[i].lesser);
}
}
printf("\nCreate b1:\n");
for(i = 0; i<n_b1;++i) {print_poly(&(b1[i])); printf("\n");}
printf("Create b2:\n");
for(i = 0; i<n_b2;++i) {print_poly(&(b2[i])); printf("\n");}
printf("#b1: %u\t #b2: %u\n", n_b1, n_b2);
//Merge b's
printf("\nMerge b*:\n");
fm_row *b_rows = (fm_row*) malloc(sizeof(fm_row)*(n_b1*n_b2+n_zero));
for(i = 0; i < n_b1; ++i){
for(j = 0; j < n_b2; ++j){
b_rows[i*n_b1+j].lesser = &(b1[i]);
b_rows[i*n_b1+j].greater = &(b2[j]);
}
}
for(i = 0; i < n_b1*n_b2; ++i) print_row(&(b_rows[i]));
//Add rows with 0 coeff
printf("\nAdd zero-coeff rows:\n");
i = n_b1*n_b2;
for(j = n_pos + n_neg; j < system->nbr_rows; ++j){
b_rows[i] = system->rows[j];
b_rows[i].lesser->poly_len = system->curr_nbr_x-1;
++i;
}
for(i = 0; i < n_b1*n_b2+n_zero; ++i) print_row(&(b_rows[i]));
//Simplify
printf("\nSimplify:\n");
fm_poly_entry *great_e, *less_e;
for(i = 0; i < n_b1*n_b2+n_zero; ++i){
//Move non-constants to lesser side
for(j = 0; j < b_rows[i].greater->poly_len-1; ++j){
great_e = &(b_rows[i].greater->poly[j]);
less_e = &(b_rows[i].lesser->poly[j]);
printf("(%lld/%lld) - (%lld/%lld) = ", less_e->numerator, less_e->denominator, great_e->numerator, great_e->denominator);
less_e->numerator = less_e->numerator*great_e->denominator - great_e->numerator*less_e->denominator;
less_e->denominator = less_e->denominator*great_e->denominator;
printf("(%lld/%lld)\n\n", less_e->numerator, less_e->denominator);
great_e->numerator = 0;
great_e->denominator = 1;
}
}
for(i = 0; i < n_b1*n_b2+n_zero; ++i) print_row(&(b_rows[i]));
for(i = 0; i < n_b1*n_b2+n_zero; ++i){
//Move constants to greater side
great_e = &(b_rows[i].greater->poly[b_rows[i].greater->poly_len-1]);
less_e = &(b_rows[i].lesser->poly[b_rows[i].greater->poly_len-1]);
great_e->numerator = great_e->numerator*less_e->denominator - less_e->numerator*great_e->denominator;
great_e->denominator = great_e->denominator*less_e->denominator;
}
for(i = 0; i < n_b1*n_b2+n_zero; ++i) print_row(&(b_rows[i]));
printf("elim_2 done\n");
return 7;
}
static unsigned int* sort_by_coeffs(fm_system* system){ //sort system->rows by coeffs of largest x-index
unsigned int i;
fm_row row;
fm_poly *poly_lesser, *poly_greater, *poly;
fm_poly_entry sort_entry;
long long numerator, denominator;
unsigned int nbr_pos, nbr_neg, nbr_zero;
nbr_pos = nbr_neg = nbr_zero = 0;
unsigned int nbr_rows = system->nbr_rows;
unsigned int nbr_x = system->curr_nbr_x;
fm_row *pos_rows = (fm_row*) malloc(sizeof(fm_row)*nbr_rows);
fm_row *neg_rows = (fm_row*) malloc(sizeof(fm_row)*nbr_rows);
fm_row *zero_rows = (fm_row*) malloc(sizeof(fm_row)*nbr_rows);
for(i = 0; i < nbr_rows; ++i){
row = system->rows[i];
poly_lesser = row.lesser;
poly_greater = row.greater;
if(poly_lesser->poly_len == 1 && poly_lesser->poly[0].index == 0){ //lesser == const side
poly = poly_greater;
} else if(poly_greater->poly_len == 1 && poly_greater->poly[0].index == 0){ //greater == const side
poly = poly_lesser;
} else { //TODO: is this possible?
printf("no const side in row: ");
print_row(&row);
exit(1);
}
sort_entry = poly->poly[poly->poly_len-1]; //largest x-index term in row
if(sort_entry.index != nbr_x || sort_entry.numerator == 0){ //coeff == 0
zero_rows[nbr_zero++] = row;
continue;
}
numerator = sort_entry.numerator;
denominator = sort_entry. denominator;
if((numerator > 0 && denominator > 0) || (numerator < 0 && denominator < 0)){ // coeff > 0
pos_rows[nbr_pos++] = row;
} else { //coeff < 0
neg_rows[nbr_neg++] = row;
}
}
for(i = 0; i < nbr_pos; ++i){
system->rows[i] = pos_rows[i];
}
for(; i < nbr_pos + nbr_neg; ++i){
system->rows[i] = neg_rows[i - nbr_pos];
}
for(; i < nbr_rows; ++i){
system->rows[i] = zero_rows[i - (nbr_pos + nbr_neg)];
}
/*free(pos_rows);
free(neg_rows);
free(zero_rows);*/
printf("sorted on x_{%d}?\n", nbr_x);
print_system(system);
unsigned int *ret = malloc(sizeof(unsigned int)*3);
ret[0] = nbr_pos;
ret[1] = nbr_neg;
ret[2] = nbr_zero;
return ret;
}
static int
print_struct(smbios_hdl_t *shp, const smbios_struct_t *sp, void *fp)
{
smbios_info_t info;
int hex = opt_x;
const char *s;
if (opt_t != -1 && opt_t != sp->smbstr_type)
return (0); /* skip struct if type doesn't match -t */
if (!opt_O && (sp->smbstr_type == SMB_TYPE_MEMCTL ||
sp->smbstr_type == SMB_TYPE_MEMMOD))
return (0); /* skip struct if type is obsolete */
if (g_hdr++ == 0 || !opt_s)
oprintf(fp, "%-5s %-4s %s\n", "ID", "SIZE", "TYPE");
oprintf(fp, "%-5u %-4lu",
(uint_t)sp->smbstr_id, (ulong_t)sp->smbstr_size);
if ((s = smbios_type_name(sp->smbstr_type)) != NULL)
oprintf(fp, " %s (type %u)", s, sp->smbstr_type);
else if (sp->smbstr_type > SMB_TYPE_OEM_LO &&
sp->smbstr_type < SMB_TYPE_OEM_HI)
oprintf(fp, " %s+%u (type %u)", "SMB_TYPE_OEM_LO",
sp->smbstr_type - SMB_TYPE_OEM_LO, sp->smbstr_type);
else
oprintf(fp, " %u", sp->smbstr_type);
if ((s = smbios_type_desc(sp->smbstr_type)) != NULL)
oprintf(fp, " (%s)\n", s);
else
oprintf(fp, "\n");
if (opt_s)
return (0); /* only print header line if -s specified */
if (smbios_info_common(shp, sp->smbstr_id, &info) == 0) {
oprintf(fp, "\n");
print_common(&info, fp);
}
switch (sp->smbstr_type) {
case SMB_TYPE_BIOS:
oprintf(fp, "\n");
print_bios(shp, fp);
break;
case SMB_TYPE_SYSTEM:
oprintf(fp, "\n");
print_system(shp, fp);
break;
case SMB_TYPE_BASEBOARD:
oprintf(fp, "\n");
print_bboard(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_CHASSIS:
oprintf(fp, "\n");
print_chassis(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_PROCESSOR:
oprintf(fp, "\n");
print_processor(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_CACHE:
oprintf(fp, "\n");
print_cache(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_PORT:
oprintf(fp, "\n");
print_port(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_SLOT:
oprintf(fp, "\n");
print_slot(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_OBDEVS:
oprintf(fp, "\n");
print_obdevs(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_OEMSTR:
case SMB_TYPE_SYSCONFSTR:
oprintf(fp, "\n");
print_strtab(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_LANG:
oprintf(fp, "\n");
print_lang(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_EVENTLOG:
oprintf(fp, "\n");
print_evlog(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_MEMARRAY:
oprintf(fp, "\n");
print_memarray(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_MEMDEVICE:
oprintf(fp, "\n");
print_memdevice(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_MEMARRAYMAP:
oprintf(fp, "\n");
print_memarrmap(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_MEMDEVICEMAP:
oprintf(fp, "\n");
print_memdevmap(shp, sp->smbstr_id, fp);
break;
case SMB_TYPE_SECURITY:
oprintf(fp, "\n");
print_hwsec(shp, fp);
break;
case SMB_TYPE_BOOT:
oprintf(fp, "\n");
print_boot(shp, fp);
break;
case SMB_TYPE_IPMIDEV:
oprintf(fp, "\n");
print_ipmi(shp, fp);
break;
case SMB_TYPE_OBDEVEXT:
oprintf(fp, "\n");
print_obdevs_ext(shp, sp->smbstr_id, fp);
break;
case SUN_OEM_EXT_PROCESSOR:
oprintf(fp, "\n");
print_extprocessor(shp, sp->smbstr_id, fp);
break;
case SUN_OEM_EXT_PORT:
oprintf(fp, "\n");
print_extport(shp, sp->smbstr_id, fp);
break;
case SUN_OEM_PCIEXRC:
oprintf(fp, "\n");
print_pciexrc(shp, sp->smbstr_id, fp);
break;
case SUN_OEM_EXT_MEMARRAY:
oprintf(fp, "\n");
print_extmemarray(shp, sp->smbstr_id, fp);
break;
case SUN_OEM_EXT_MEMDEVICE:
oprintf(fp, "\n");
print_extmemdevice(shp, sp->smbstr_id, fp);
break;
default:
hex++;
}
if (hex)
print_bytes(sp->smbstr_data, sp->smbstr_size, fp);
else
oprintf(fp, "\n");
return (0);
}
//unsigned long long fm_elim(int rows, int cols, int** A, int* c)
unsigned long long fm_elim(Arena* arena, int rows, int cols, fix_p** A, fix_p* c)
{
//1
int r;
int s;
fix_p** t;
fix_p* q;
int n1;
int n2;
int i;
int j;
long br;
long Br;
int qj_lt_0;
int s_p;
fix_p** old_t;
fix_p* old_q;
int k;
int l;
int curr_row;
fix_p tjr;
fix_p* qj;
fix_p* tj;
r = cols;
s = rows;
t = check_out_matrix_copy(arena, A, rows, cols);
q = check_out_vector_copy(arena, c, rows);
printf("\n\nNew system\n");
// print_system(s, r, t, q);
// printf("\n");
while(1){
//2
sort_matrix(s, r-1, &n1, &n2, t, q);
printf("s: %d\nn1: %d\nn2: %d\n", s, n1, n2);
printf("\n");
printf("After sort:\n");
print_system(s, r, t, q);
printf("\n");
// 3
qj = q;
for(j = 0; j < n2; j++){
tjr = fix_p_div(65536, t[j][r-1]); //65536 = 1
*qj = fix_p_mul(*qj, tjr);
qj++;
tj = t[j];
for(i = 0; i < r; i++){
*tj = fix_p_mul(*tj, tjr);
tj++;
}
}
printf("After div:\n");
print_system(s, r, t, q);
printf("\n");
// printf("br: %f\tBr: %f\n", fix_p2double(br), fix_p2double(Br));
// printf("r == %d\n", r);
// 5
if(r == 1){
// printf("r == 1\n");
// 4
br = 0;
// printf("brs:\n");
if(n2 > n1){
for(j = n1; j < n2; j++){
if(q[j] > br){
br = q[j];
}
}
}else{
br = LONG_MIN;
}
Br = LONG_MAX;
// printf("\nBrs:\n");
if(n1 > 0){
for(j = 0; j < n1; j++){
if(q[j] < Br){
Br = q[j];
}
}
}else{
Br = LONG_MAX;
}
qj_lt_0 = 0;
for(i = n2; i < s; i++){
if(q[i] < 0){
qj_lt_0 = 1;
break;
}
}
// printf("br > Br: %d\nqj_lt_0: %d\n", br > Br, qj_lt_0);
if(br > Br || qj_lt_0){
// printf("br > Br || qj_lt_0\n");
hand_back_matrix(arena, &t);
hand_back_vector(arena, &q);
return 0;
}else{
// printf("not br > Br || qj_lt_0\n");
hand_back_matrix(arena, &t);
hand_back_vector(arena, &q);
return 1;
}
}
// 6
s_p = s - n2 + n1 * (n2 - n1);
if(s_p == 0){
// printf("s_p == 0\n");
// print_system(s, r, t, q);
for(j = 0; j < n1; j++){
fix_p sum = 0;
for(i = 0; i < r; i++){
sum += t[j][i];
}
if(sum != q[j]){
// printf("i:%d j:%d sum:%f q:%f\n", i,j,fix_p2double(sum),fix_p2double(q[j]));
// free_up_t_q(s,t,q);
hand_back_matrix(arena, &t);
hand_back_vector(arena, &q);
return 0;
}
// printf("+ %f\n",fix_p2double(q[j]));
}
hand_back_matrix(arena, &t);
hand_back_vector(arena, &q);
return 1;
}
// printf("\n");
// 7
old_t = t;
old_q = q;
// t = init_matrix(s_p, r - 1);
// q = init_vector(s_p);
t = check_out_matrix(arena, s_p);
q = check_out_vector(arena, s_p);
// printf("s_p: %d\n", s_p);
// printf("\n");
// print_system(s, r, old_t, old_q);
// printf("\n");
curr_row = 0;
fix_p old_qk;
fix_p* old_tk;
fix_p* old_tl;
for(k = 0; k < n1; k++){
old_qk = old_q[k];
old_tk = old_t[k];
for(l = n1; l < n2; l++){
old_tl = old_t[l];
for(i = 0; i < r-1; i++){
// printf("%ld\n",t[curr_row][i]);
// printf("k:%d i:%d l:%d\n", k ,i, l);
t[curr_row][i] = old_tk[i] - old_tl[i];
}
q[curr_row] = old_qk - old_q[l];
curr_row++;
}
}
for(j = n2; j < s; j++){
for(i = 0; i < r-1; i++){
t[curr_row][i] = old_t[j][i];
}
q[curr_row] = old_q[j];
curr_row++;
}
hand_back_matrix(arena, &old_t);
hand_back_vector(arena, &old_q);
r = r - 1;
s = s_p;
// printf("\n");
// print_system(s, r, t, q);
// printf("\n");
}
}
