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;
}
