int maxMatching(){
fillb(used, n1, false);
fill(matching, n2, -1);
for(int res = 0;;){
bfs();
fillb(vis, n1, false);
int f = 0;
for(int u = 0; u < n1; ++u)
if(!used[u] && dfs(u))
++f;
if(!f)
return res;
res += f;
}
}
//prints the stacks on the screen
void printStacks(){
int j;
emptyArrays();
filla(headA); //first convert eack stack into its
fillb(headB); //corresponding array
fillc(headC);
for(j=0;j<10;j++){ //then use the for loop to print the values in the arrays
disp(a[j]);
disp(b[j]);
disp(c[j]);
printf("\n");
}
printf("*************\t\t*************\t\t*************\nStack A\t\t\tStack B\t\t\tStack C\n");
}
long solve(void) {
int i;
int iter;
double *dx, *ds, *dy, *dz;
double minval;
double alpha;
work.converged = 0;
setup_pointers();
pre_ops();
#ifndef ZERO_LIBRARY_MODE
if (settings.verbose)
printf("iter objv gap |Ax-b| |Gx+s-h| step\n");
#endif
fillq();
fillh();
fillb();
if (settings.better_start)
better_start();
else
set_start();
for (iter = 0; iter < settings.max_iters; iter++) {
for (i = 0; i < 84; i++) {
work.s_inv[i] = 1.0 / work.s[i];
work.s_inv_z[i] = work.s_inv[i]*work.z[i];
}
work.block_33[0] = 0;
fill_KKT();
ldl_factor();
/* Affine scaling directions. */
fillrhs_aff();
ldl_solve(work.rhs, work.lhs_aff);
refine(work.rhs, work.lhs_aff);
/* Centering plus corrector directions. */
fillrhs_cc();
ldl_solve(work.rhs, work.lhs_cc);
refine(work.rhs, work.lhs_cc);
/* Add the two together and store in aff. */
for (i = 0; i < 294; i++)
work.lhs_aff[i] += work.lhs_cc[i];
/* Rename aff to reflect its new meaning. */
dx = work.lhs_aff;
ds = work.lhs_aff + 114;
dz = work.lhs_aff + 198;
dy = work.lhs_aff + 282;
/* Find min(min(ds./s), min(dz./z)). */
minval = 0;
for (i = 0; i < 84; i++)
if (ds[i] < minval*work.s[i])
minval = ds[i]/work.s[i];
for (i = 0; i < 84; i++)
if (dz[i] < minval*work.z[i])
minval = dz[i]/work.z[i];
/* Find alpha. */
if (-0.99 < minval)
alpha = 1;
else
alpha = -0.99/minval;
/* Update the primal and dual variables. */
for (i = 0; i < 114; i++)
work.x[i] += alpha*dx[i];
for (i = 0; i < 84; i++)
work.s[i] += alpha*ds[i];
for (i = 0; i < 84; i++)
work.z[i] += alpha*dz[i];
for (i = 0; i < 12; i++)
work.y[i] += alpha*dy[i];
work.gap = eval_gap();
work.eq_resid_squared = calc_eq_resid_squared();
work.ineq_resid_squared = calc_ineq_resid_squared();
#ifndef ZERO_LIBRARY_MODE
if (settings.verbose) {
work.optval = eval_objv();
printf("%3d %10.3e %9.2e %9.2e %9.2e % 6.4f\n",
iter+1, work.optval, work.gap, sqrt(work.eq_resid_squared),
sqrt(work.ineq_resid_squared), alpha);
}
#endif
/* Test termination conditions. Requires optimality, and satisfied */
/* constraints. */
if ( (work.gap < settings.eps)
&& (work.eq_resid_squared <= settings.resid_tol*settings.resid_tol)
&& (work.ineq_resid_squared <= settings.resid_tol*settings.resid_tol)
) {
work.converged = 1;
work.optval = eval_objv();
return iter+1;
}
}
return iter;
}
int lalr1::parse()
{
char *token = new char[4096];
int lapg_head = 0, group = 0, lapg_i, lapg_size, chr;
lapg_symbol *lapg_m = new lapg_symbol[512];
lapg_symbol lapg_n = { NULL, -1, 0 };
lapg_place lapg_current = { 1, 1 };
lapg_m[0].state = 0;
chr = *l++;if( l == end ) fillb();
do {
lapg_n.pos = lapg_current;
for( lapg_size = 0, lapg_i = group; lapg_i >= 0; ) {
if( lapg_size < 4096-1 ) token[lapg_size++] = chr;
lapg_i = lapg_lexem[lapg_i][lapg_char2no[chr]];
if( lapg_i >= -1 && chr ) {
lapg_current.column++;
if( chr == '\n' ) lapg_current.column = 1, lapg_current.line++;
chr = *l++;if( l == end ) fillb();
}
}
token[lapg_size] = 0;
if( lapg_i == -1 ) {
error( 0, "invalid lexem at line %i, column %i: `%s`, skipped\n", lapg_n.pos.line, lapg_n.pos.column, token );
continue;
}
token[lapg_size-1] = 0;
lapg_n.lexem = -lapg_i-2;
lapg_n.sym = NULL;
switch( lapg_n.lexem ) {
case 1: {
#line 30 "syntax"
*(char* *)&lapg_n.sym = _strdup(token);
} break;
case 2: {
#line 31 "syntax"
*(char* *)&lapg_n.sym = strstrip(token);
} break;
case 3: {
#line 32 "syntax"
*(char* *)&lapg_n.sym = _strdup(token+1);
} break;
case 4: {
#line 33 "syntax"
*(char* *)&lapg_n.sym = _strdup(token+3);
} break;
case 5: {
#line 34 "syntax"
*(char* *)&lapg_n.sym = strstrip(token);
} break;
case 6: {
#line 35 "syntax"
*(char* *)&lapg_n.sym = strstrip(token);
} break;
case 7: {
#line 36 "syntax"
*(char* *)&lapg_n.sym = strstrip(token);
} break;
case 8: {
#line 37 "syntax"
*(int *)&lapg_n.sym = strtol(token,NULL,10);
} break;
case 10: {
#line 40 "syntax"
continue;
} break;
}
do {
lapg_i = lapg_next( lapg_m[lapg_head].state, lapg_n.lexem );
if( lapg_i >= 0 ) {
lapg_symbol lapg_gg={(lapg_rlen[lapg_i])?lapg_m[lapg_head+1-lapg_rlen[lapg_i]].sym:NULL,lapg_rlex[lapg_i],0 };
#ifdef DEBUG_syntax
fprintf( stdout, "reduce to %s\n", lapg_syms[lapg_rlex[lapg_i]] );
#endif
lapg_gg.pos = (lapg_rlen[lapg_i])?lapg_m[lapg_head+1-lapg_rlen[lapg_i]].pos:lapg_n.pos;
switch( lapg_i ) {
case 2: {
#line 64 "syntax"
lapg_gg.pos.line++;
} break;
case 4: {
#line 68 "syntax"
lapg_gg.sym = concat( NULL, ((char*)lapg_m[lapg_head-0].sym), sourcename, lapg_m[lapg_head-0].pos.line );
} break;
case 5: {
#line 70 "syntax"
lapg_gg.sym = concat( *(char* *)&lapg_gg.sym, ((char*)lapg_m[lapg_head-0].sym), sourcename, (lapg_m[lapg_head-1].pos.line+1!=lapg_m[lapg_head-0].pos.line)?lapg_m[lapg_head-0].pos.line:-1 );
lapg_gg.pos = lapg_m[lapg_head-0].pos;
} break;
case 8: {
#line 78 "syntax"
process_directive( ((char*)lapg_m[lapg_head-1].sym), ((char*)lapg_m[lapg_head-0].sym), lapg_m[lapg_head-2].pos.line, lapg_m[lapg_head-2].pos.column );
delete[] ((char*)lapg_m[lapg_head-1].sym);
} break;
case 9: {
#line 82 "syntax"
process_directive( ((char*)lapg_m[lapg_head-1].sym), ((int)lapg_m[lapg_head-0].sym), lapg_m[lapg_head-2].pos.line, lapg_m[lapg_head-2].pos.column );
delete[] ((char*)lapg_m[lapg_head-1].sym);
} break;
case 14: {
#line 88 "syntax"
if( ((int)lapg_m[lapg_head-0].sym) < 0 || ((int)lapg_m[lapg_head-0].sym) >= BITS ) *(int *)&lapg_gg.sym = 0; else *(int *)&lapg_gg.sym = 1 << ((int)lapg_m[lapg_head-0].sym);
} break;
case 16: {
#line 89 "syntax"
*(int *)&lapg_gg.sym |= ((int)lapg_m[lapg_head-0].sym);
} break;
case 17: {
#line 90 "syntax"
lb.currentgroups = ((int)lapg_m[lapg_head-1].sym);
} break;
case 18: {
#line 94 "syntax"
gb.terminal(((char*)lapg_m[lapg_head-1].sym)); delete[] ((char*)lapg_m[lapg_head-1].sym);
} break;
case 19: {
#line 97 "syntax"
gb.terminal(((char*)lapg_m[lapg_head-2].sym),((char*)lapg_m[lapg_head-1].sym)); delete[] ((char*)lapg_m[lapg_head-2].sym); delete[] ((char*)lapg_m[lapg_head-1].sym);
} break;
case 22: {
#line 100 "syntax"
lb.lexem( gb.terminal(((char*)lapg_m[lapg_head-4].sym)), ((char*)lapg_m[lapg_head-2].sym), ((char*)lapg_m[lapg_head-4].sym), ((char*)lapg_m[lapg_head-0].sym), ((int)lapg_m[lapg_head-1].sym) );
delete[] ((char*)lapg_m[lapg_head-4].sym); delete[] ((char*)lapg_m[lapg_head-2].sym); delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
case 23: {
#line 104 "syntax"
lb.lexem( gb.terminal(((char*)lapg_m[lapg_head-3].sym)), ((char*)lapg_m[lapg_head-1].sym), ((char*)lapg_m[lapg_head-3].sym), NULL, ((int)lapg_m[lapg_head-0].sym) );
delete[] ((char*)lapg_m[lapg_head-3].sym); delete[] ((char*)lapg_m[lapg_head-1].sym);
} break;
case 24: {
#line 108 "syntax"
lb.lexem( gb.terminal(((char*)lapg_m[lapg_head-5].sym), ((char*)lapg_m[lapg_head-4].sym)), ((char*)lapg_m[lapg_head-2].sym), ((char*)lapg_m[lapg_head-5].sym), ((char*)lapg_m[lapg_head-0].sym), ((int)lapg_m[lapg_head-1].sym) );
delete[] ((char*)lapg_m[lapg_head-5].sym); delete[] ((char*)lapg_m[lapg_head-4].sym); delete[] ((char*)lapg_m[lapg_head-2].sym); delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
case 25: {
#line 112 "syntax"
lb.lexem( gb.terminal(((char*)lapg_m[lapg_head-4].sym), ((char*)lapg_m[lapg_head-3].sym)), ((char*)lapg_m[lapg_head-1].sym), ((char*)lapg_m[lapg_head-4].sym), NULL, ((int)lapg_m[lapg_head-0].sym) );
delete[] ((char*)lapg_m[lapg_head-4].sym); delete[] ((char*)lapg_m[lapg_head-3].sym); delete[] ((char*)lapg_m[lapg_head-1].sym);
} break;
case 31: {
#line 121 "syntax"
gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 0, NULL, gb.symbol( ((char*)lapg_m[lapg_head-2].sym), 0 ) );
delete[] ((char*)lapg_m[lapg_head-2].sym);
delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
case 32: {
#line 125 "syntax"
gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 0, NULL, -1 );
delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
case 43: {
#line 146 "syntax"
if( !strcmp(((char*)lapg_m[lapg_head-0].sym),"left")) lapg_gg.sym = (void*)1;
else if( !strcmp(((char*)lapg_m[lapg_head-0].sym),"right")) lapg_gg.sym = (void*)2;
else if( !strcmp(((char*)lapg_m[lapg_head-0].sym),"nonassoc")) lapg_gg.sym = (void*)3;
else { error(0,"wrong priority declaration: %%%s",((char*)lapg_m[lapg_head-0].sym));lapg_gg.sym = 0; }
delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
case 45: {
#line 153 "syntax"
gb.addprio(((char*)lapg_m[lapg_head-0].sym),((int)lapg_m[lapg_head-1].sym),0);
} break;
case 46: {
#line 153 "syntax"
gb.addprio(((char*)lapg_m[lapg_head-0].sym),((int)lapg_m[lapg_head-2].sym),1);
} break;
case 47: {
#line 156 "syntax"
*(int *)&lapg_gg.sym = gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 0 ); delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
case 48: {
#line 157 "syntax"
*(int *)&lapg_gg.sym = -1;
} break;
case 49: {
#line 161 "syntax"
gb.rule( length, ((int)lapg_m[lapg_head-1].sym), ((char*)lapg_m[lapg_head-0].sym), rule, lapg_gg.pos.line );
} break;
case 50: {
#line 164 "syntax"
gb.rule( length, ((int)lapg_m[lapg_head-0].sym), NULL, rule, lapg_gg.pos.line );
} break;
case 51: {
#line 167 "syntax"
gb.rule( 0, ((int)lapg_m[lapg_head-0].sym), ((char*)lapg_m[lapg_head-1].sym), rule, lapg_gg.pos.line );
} break;
case 52: {
#line 170 "syntax"
gb.rule( 0, ((int)lapg_m[lapg_head-0].sym), NULL, rule, lapg_gg.pos.line );
} break;
case 55: {
#line 175 "syntax"
if( ((char*)lapg_m[lapg_head-1].sym) ) {
length += 2;
rule[length] = gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 0 );
rule[length-1] = gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 2, NULL, rule[length] );
gb.rule( 0, -1, ((char*)lapg_m[lapg_head-1].sym), rule+length-1, lapg_m[lapg_head-2].pos.line );
} else rule[++length] = gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 0 );
delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
case 56: {
#line 184 "syntax"
length = 0;
if( ((char*)lapg_m[lapg_head-1].sym) ) {
length += 2;
rule[length] = gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 0 );
rule[length-1] = gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 2, NULL, rule[length] );
gb.rule( 0, -1, ((char*)lapg_m[lapg_head-1].sym), rule+length-1, lapg_m[lapg_head-1].pos.line );
} else rule[++length] = gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 0 );
delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
case 57: {
#line 196 "syntax"
rule[0] = gb.symbol( ((char*)lapg_m[lapg_head-0].sym), 1 );
delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
case 58: {
#line 200 "syntax"
rule[0] = gb.symbol( ((char*)lapg_m[lapg_head-1].sym), 1, ((char*)lapg_m[lapg_head-0].sym) );
delete[] ((char*)lapg_m[lapg_head-1].sym);
delete[] ((char*)lapg_m[lapg_head-0].sym);
} break;
}
lapg_head -= lapg_rlen[lapg_i];
lapg_m[++lapg_head] = lapg_gg;
lapg_m[lapg_head].state = lapg_state_sym( lapg_m[lapg_head-1].state, lapg_gg.lexem );
} else if( lapg_i == -1 ) {
lapg_m[++lapg_head] = lapg_n;
lapg_m[lapg_head].state = lapg_state_sym( lapg_m[lapg_head-1].state, lapg_n.lexem );
#ifdef DEBUG_syntax
fprintf( stdout, "shift: %s (%s)\n", lapg_syms[lapg_n.lexem], token );
#endif
}
} while( lapg_i >= 0 && lapg_m[lapg_head].state != -1 );
if( (lapg_i == -2 || lapg_m[lapg_head].state == -1) && lapg_n.lexem != 0 ) {
break;
}
} while( lapg_n.lexem );
if( lapg_m[lapg_head].state == 91-1 ) lapg_i = 1; else lapg_i = 0;
delete[] lapg_m;
delete[] token;
if( !lapg_i ) error( 0, "syntax error before line %i, column %i\n", lapg_n.pos.line, lapg_n.pos.column );
return lapg_i;
}
