char *cprat (char name[], lrs_mp Nin, lrs_mp Din) { char *ret; unsigned long len; int i, offset=0; string s; const char *cstr; s = prat(name,Nin,Din); cstr = s.c_str(); len = strlen(cstr); ret = (char *)malloc(sizeof(char)*(len+1)); for (i=0; i+offset<len+1;) { if (cstr[i+offset]!=' ') { ret[i] = cstr[i+offset]; i++; } else /* skip whitespace */ offset++; } return ret; }
void* clithread (void* grej){ int n,test; char str[MAXSIZE],str2[MAXSIZE]; struct cli_param* cli = (struct cli_param*) grej; fflush(stdout); //test = close(cli->sockfd); assert(test == 0);// child doesn't need the listener printf("new_fd: %d\n",cli->fd); ///här händer de grejer int done = 0; //do{ //infinent loop strcpy(str," "); str[0]=0; //printf("Derp\n"); sprintf(str2, "%d", cli->player); send(cli->fd,str2,MAXSIZE,0); printf("sent:%s\n",str2); n = recv(cli->fd, str, MAXSIZE, 0); //tar imot skit if (n <= 0) { if (n < 0) perror("recv"); done = 1; } str[n]=0; printf("received:%s!\n",str); //strcmp(str,1) usleep(500); //}while(!done); //*/ for(;;){ char *skicka[]={"",cli->ip,mystruct.test}; int buf; printf("%s har anslutit tcp\n",cli->ip); //for(;;){ //} prat(skicka); buf=lyssna(); if(pthread_mutex_trylock(&mtest[cli->player])){ sprintf(mystruct.test, "%d", buf); pthread_mutex_unlock(&mtest[cli->player]); } printf("global struct contains:%s\n",mystruct.test); usleep(50); } //chop up buf //mutex_ptherad_trylock(test[cli->player]); //*/ }
//----------------------------------------------------------------------------------------// // This is a slightly modified version of main() in lpdemo.c int lp_solve (lpp *lp) { lrs_dic *P; /* structure for holding current dictionary and indices */ lrs_dat *Q; /* structure for holding static problem data */ lrs_mp_vector output; /* one line of output:ray,vertex,facet,linearity */ long col; /* output column index for dictionary */ // allocate and init structure for static problem data Q = lrs_alloc_dat ("LRS globals"); if (Q == NULL) return 1; Q->m = lp->dim[ROW]-1; // Rows, excluding the objective function Q->n = 1+lp->dim[COL]; // Columns, including RHS which goes in column 0 Q->lponly = TRUE; // we do not want all vertices generated! Q->maximize = TRUE; output = lrs_alloc_mp_vector (Q->n); P = lrs_alloc_dic (Q); // allocate and initialize lrs_dic if (P == NULL) return 1; // Build the LP representation in the format required by lrs buildLP(P,Q,lp); // Solve the LP if (!lrs_solve_lp(P,Q)) return 1; // Print output prat ("\nObjective value = ", P->objnum, P->objden); for (col = 0; col < Q->n; col++) if (lrs_getsolution (P, Q, output, col)) lrs_printoutput (Q, output); /* free space : do not change order of next lines! */ lrs_clear_mp_vector (output, Q->n); lrs_free_dic (P,Q); /* deallocate lrs_dic */ lrs_free_dat (Q); /* deallocate lrs_dat */ return 0; }
long lrs_nashoutput (lrs_dat * Q, lrs_mp_vector output, long player) { long i; long origin=TRUE; /* do not print the origin for either player */ for (i = 1; i < Q->n; i++) if(!zero(output[i])) origin=FALSE; if (origin) return FALSE; fprintf (lrs_ofp, "\n%ld ",player); for (i = 1; i < Q->n; i++) prat ("", output[i], output[0]); fflush(lrs_ofp); return TRUE; } /* end lrs_nashoutput */
int main (int argc, char *argv[]) { lrs_dic *P1,*P2; /* structure for holding current dictionary and indices */ lrs_dat *Q1,*Q2; /* structure for holding static problem data */ lrs_mp_vector output1; /* holds one line of output; ray,vertex,facet,linearity */ lrs_mp_vector output2; /* holds one line of output; ray,vertex,facet,linearity */ lrs_mp_matrix Lin; /* holds input linearities if any are found */ lrs_dic *P2orig; /* we will save player 2's dictionary in getabasis */ long col; /* output column index for dictionary */ long startcol = 0; long prune = FALSE; /* if TRUE, getnextbasis will prune tree and backtrack */ long numequilib=0; /* number of nash equilibria found */ long oldnum=0; /* global variables lrs_ifp and lrs_ofp are file pointers for input and output */ /* they default to stdin and stdout, but may be overidden by command line parms. */ if(argc <= 2 ) { printf("Usage: nash input1 input2 [outputfile] \n"); return 1; } /*************************************************** Step 0: Do some global initialization that should only be done once, no matter how many lrs_dat records are allocated. db ***************************************************/ if ( !lrs_init ("\n*nash:")) return 1; printf(AUTHOR); /*********************************************************************************/ /* Step 1: Allocate lrs_dat, lrs_dic and set up the problem */ /*********************************************************************************/ Q1 = lrs_alloc_dat ("LRS globals"); /* allocate and init structure for static problem data */ if (Q1 == NULL) return 1; Q1->nash=TRUE; if (!lrs_read_dat (Q1, argc, argv)) /* read first part of problem data to get dimensions */ return 1; /* and problem type: H- or V- input representation */ P1 = lrs_alloc_dic (Q1); /* allocate and initialize lrs_dic */ if (P1 == NULL) return 1; if (!lrs_read_dic (P1, Q1)) /* read remainder of input to setup P1 and Q1 */ return 1; output1 = lrs_alloc_mp_vector (Q1->n + Q1->m); /* output holds one line of output from dictionary */ fclose(lrs_ifp); /* allocate and init structure for player 2's problem data */ printf ("\n*Second input taken from file %s\n", argv[2]); Q2 = lrs_alloc_dat ("LRS globals"); if (Q2 == NULL) return 1; Q2->nash=TRUE; if (!lrs_read_dat (Q2, 2, argv)) /* read first part of problem data to get dimensions */ return 1; /* and problem type: H- or V- input representation */ if (Q2->nlinearity > 0) free(Q2->linearity); /* we will start again */ Q2->linearity = CALLOC ((Q2->m + 2), sizeof (long)); P2 = lrs_alloc_dic (Q2); /* allocate and initialize lrs_dic */ if (P2 == NULL) return 1; if (!lrs_read_dic (P2, Q2)) /* read remainder of input to setup P2 and Q2 */ return 1; output2 = lrs_alloc_mp_vector (Q1->n + Q1->m); /* output holds one line of output from dictionary */ P2orig = lrs_getdic(Q2); /* allocate and initialize lrs_dic */ if (P2orig == NULL) return 1; copy_dict(Q2,P2orig,P2); fprintf (lrs_ofp, "\n***** %ld %ld rational", Q1->n, Q2->n); /*********************************************************************************/ /* Step 2: Find a starting cobasis from default of specified order */ /* P1 is created to hold active dictionary data and may be cached */ /* Lin is created if necessary to hold linearity space */ /* Print linearity space if any, and retrieve output from first dict. */ /*********************************************************************************/ if (!lrs_getfirstbasis (&P1, Q1, &Lin, TRUE)) return 1; if (Q1->dualdeg) { printf("\n*Warning! Dual degenerate, ouput may be incomplete"); printf("\n*Recommendation: Add dualperturb option before maximize in first input file\n"); } if (Q1->unbounded) { printf("\n*Warning! Unbounded starting dictionary for p1, output may be incomplete"); printf("\n*Recommendation: Change/remove maximize option, or include bounds \n"); } /* Pivot to a starting dictionary */ /* There may have been column redundancy */ /* If so the linearity space is obtained and redundant */ /* columns are removed. User can access linearity space */ /* from lrs_mp_matrix Lin dimensions nredundcol x d+1 */ if (Q1->homogeneous && Q1->hull) startcol++; /* col zero not treated as redundant */ for (col = startcol; col < Q1->nredundcol; col++) /* print linearity space */ lrs_printoutput (Q1, Lin[col]); /* Array Lin[][] holds the coeffs. */ /*********************************************************************************/ /* Step 3: Terminate if lponly option set, otherwise initiate a reverse */ /* search from the starting dictionary. Get output for each new dict. */ /*********************************************************************************/ /* We initiate reverse search from this dictionary */ /* getting new dictionaries until the search is complete */ /* User can access each output line from output which is */ /* vertex/ray/facet from the lrs_mp_vector output */ /* prune is TRUE if tree should be pruned at current node */ do { prune=lrs_checkbound(P1,Q1); if (!prune && lrs_getsolution (P1, Q1, output1, col)) { oldnum=numequilib; nash2_main(argc,argv,P1,Q1,P2orig,Q2,&numequilib,output2); if (numequilib > oldnum || Q1->verbose) { if(Q1->verbose) prat(" \np2's obj value: ",P1->objnum,P1->objden); lrs_nashoutput (Q1, output1, 1L); fprintf (lrs_ofp, "\n"); } } } while (lrs_getnextbasis (&P1, Q1, prune)); fprintf(lrs_ofp,"\n*Number of equilibria found: %ld",numequilib); fprintf (lrs_ofp,"\n*Player 1: vertices=%ld bases=%ld pivots=%ld", Q1->count[1], Q1->count[2],Q1->count[3]); fprintf (lrs_ofp,"\n*Player 2: vertices=%ld bases=%ld pivots=%ld", Q2->count[1], Q2->count[2],Q2->count[3]); lrs_clear_mp_vector(output1, Q1->m + Q1->n); lrs_clear_mp_vector(output2, Q1->m + Q1->n); lrs_free_dic (P1,Q1); /* deallocate lrs_dic */ lrs_free_dat (Q1); /* deallocate lrs_dat */ /* 2006.10.10 not sure what is going on with three lines below - sometimes crashes */ /* Q2->Qhead = P2; */ /* reset this or you crash free_dic */ /* lrs_free_dic (P2,Q2); */ /* deallocate lrs_dic */ /* lrs_free_dat (Q2); */ /* deallocate lrs_dat */ lrs_close ("nash:"); return 0; }
long nash2_main (int argc, char *argv[], lrs_dic *P1, lrs_dat *Q1, lrs_dic *P2orig, lrs_dat *Q2, long *numequilib, lrs_mp_vector output) { lrs_dic *P2; /* This can get resized, cached etc. Loaded from P2orig */ lrs_mp_matrix Lin; /* holds input linearities if any are found */ long col; /* output column index for dictionary */ long startcol = 0; long prune = FALSE; /* if TRUE, getnextbasis will prune tree and backtrack */ long nlinearity; long *linearity; static long firstwarning=TRUE; /* FALSE if dual deg warning for Q2 already given */ static long firstunbounded=TRUE; /* FALSE if dual deg warning for Q2 already given */ long i,j; /* global variables lrs_ifp and lrs_ofp are file pointers for input and output */ /* they default to stdin and stdout, but may be overidden by command line parms. */ /*********************************************************************************/ /* Step 1: Allocate lrs_dat, lrs_dic and set up the problem */ /*********************************************************************************/ P2=lrs_getdic(Q2); copy_dict(Q2,P2,P2orig); /* Here we take the linearities generated by the current vertex of player 1*/ /* and append them to the linearity in player 2's input matrix */ /* next is the key magic linking player 1 and 2 */ /* be careful if you mess with this! */ linearity=Q2->linearity; nlinearity=0; for(i=Q1->lastdv+1;i <= P1->m; i++) { if (!zero(P1->A[P1->Row[i]][0])) { j = Q1->inequality[P1->B[i]-Q1->lastdv]; if (Q1->nlinearity ==0 || j < Q1->linearity[0]) linearity[nlinearity++]= j; } } /* add back in the linearity for probs summing to one */ if (Q1->nlinearity > 0) linearity[nlinearity++]= Q1->linearity[0]; /*sort linearities */ for (i = 1; i < nlinearity; i++) reorder (linearity, nlinearity); if(Q2->verbose) { fprintf(lrs_ofp,"\np2: linearities %ld",nlinearity); for (i=0;i < nlinearity; i++) fprintf(lrs_ofp," %ld",linearity[i]); } Q2->nlinearity = nlinearity; Q2->polytope = FALSE; /*********************************************************************************/ /* Step 2: Find a starting cobasis from default of specified order */ /* P2 is created to hold active dictionary data and may be cached */ /* Lin is created if necessary to hold linearity space */ /* Print linearity space if any, and retrieve output from first dict. */ /*********************************************************************************/ if (!lrs_getfirstbasis2 (&P2, Q2, P2orig, &Lin, TRUE)) goto sayonara; if (firstwarning && Q2->dualdeg) { firstwarning=FALSE; printf("\n*Warning! Dual degenerate, ouput may be incomplete"); printf("\n*Recommendation: Add dualperturb option before maximize in second input file\n"); } if (firstunbounded && Q2->unbounded) { firstunbounded=FALSE; printf("\n*Warning! Unbounded starting dictionary for p2, output may be incomplete"); printf("\n*Recommendation: Change/remove maximize option, or include bounds \n"); } /* Pivot to a starting dictionary */ /* There may have been column redundancy */ /* If so the linearity space is obtained and redundant */ /* columns are removed. User can access linearity space */ /* from lrs_mp_matrix Lin dimensions nredundcol x d+1 */ if (Q2->homogeneous && Q2->hull) startcol++; /* col zero not treated as redundant */ /* for (col = startcol; col < Q2->nredundcol; col++)*/ /* print linearity space */ /*lrs_printoutput (Q2, Lin[col]);*/ /* Array Lin[][] holds the coeffs. */ /*********************************************************************************/ /* Step 3: Terminate if lponly option set, otherwise initiate a reverse */ /* search from the starting dictionary. Get output for each new dict. */ /*********************************************************************************/ /* We initiate reverse search from this dictionary */ /* getting new dictionaries until the search is complete */ /* User can access each output line from output which is */ /* vertex/ray/facet from the lrs_mp_vector output */ /* prune is TRUE if tree should be pruned at current node */ do { prune=lrs_checkbound(P2,Q2); col=0; if (!prune && lrs_getsolution (P2, Q2, output, col)) { if (Q2->verbose) prat(" \np1's obj value: ",P2->objnum,P2->objden); if (lrs_nashoutput (Q2, output, 2L)) (*numequilib)++; } } while (lrs_getnextbasis (&P2, Q2, prune)); sayonara: lrs_free_dic(P2,Q2); return 0; }