seqform.c

/* seqform.c
 * 27 Apr 2000
 */

#include <stdio.h>
#include <stdlib.h>
	/* free()       */
#include "alloc.h"
	/* CALLOC(n,s), TALLOC(n,type), T2ALLOC(ptr,nrows,ncols,type)   */
	/* FREE2(ptr,nrows)                                             */
#include "col.h"
#include "rat.h"
	/* typedef Rat                  */
	/* ratadd, ratfromi, ratmult    */
#include "lemke.h"
#include "treedef.h"
#include "sfnf.h"

#include "seqform.h"

/* global variables for sequence form   */

Payvec **sfpay;
int **sfconstr[PLAYERS];

void allocsf(void)
{
    static int oldnseqs1 = 0;
    static int oldconstrows[PLAYERS] = {0, 0, 0};
    int pl, i, j;
    int nrows;
    
    /* payoff matrices, two players only here, init to pay 0        */
    FREE2(sfpay, oldnseqs1);
    oldnseqs1 = nseqs[1];
    T2ALLOC (sfpay, nseqs[1], nseqs[2], Payvec);
    for (i=0; i<nseqs[1]; i++)
	for (j=0; j<nseqs[2]; j++)
	    for (pl=1; pl < PLAYERS; pl++)
		sfpay[i][j][pl-1] = ratfromi(0);
    /* constraint matrices, any number of players           */
    /* sfconstr[0] stays unused                             */
    for (pl=1; pl < PLAYERS; pl++)
	{
	FREE2(sfconstr[pl], oldconstrows[pl]);
	oldconstrows[pl] = nrows = nisets[pl]+1;   /* extra row for seq 0  */
	T2ALLOC (sfconstr[pl], nrows, nseqs[pl], int);
	}
}       /* end of allocsf()     */

void gensf(void)
{
    int pl, i, j;
    Outcome z;
    allocsf();
    
    behavtorealprob(0);     /* get realization probabilities of leaves      */
    
    /* sf payoff matrices                   */
    for (z=outcomes; z < lastoutcome; z++)
	{
	Node u = z->whichnode;
	i = u->defseq[1] - firstmove[1];
	j = u->defseq[2] - firstmove[2];
	for (pl=1; pl < PLAYERS; pl++)
	    sfpay[i][j][pl-1] = ratadd(sfpay[i][j][pl-1],
		    ratmult(u->defseq[0]->realprob, z->pay[pl-1]) );
	}
    /* sf constraint matrices, sparse fill  */
    for (pl=1; pl < PLAYERS; pl++)
	{
	sfconstr[pl][0][0] = 1;     /* empty sequence                       */
	for (i=0; i < nisets[pl]; i++)
	    sfconstr[pl][i+1][(firstiset[pl]+i)->seqin - firstmove[pl]] = -1;
	for (j=1; j < nseqs[pl]; j++)
	    sfconstr[pl][(firstmove[pl]+j)->atiset - firstiset[pl]+1][j] = 1;
	}
}       /* end of  gensf()              */



void sflcp(void)
{
    int i;

    gensf();
    setlcp( nseqs[1] + nisets[2]+1 + nseqs[2] + nisets[1]+1 );
    /* fill  M  */
    /* -A       */
    payratmatcpy(sfpay, 0, 1, 0, nseqs[1], nseqs[2], 
	lcpM, 0, nseqs[1] + nisets[2]+1);
    /* -E\T     */
    intratmatcpy(sfconstr[1], 1, 1, nisets[1]+1, nseqs[1], 
	lcpM, 0, nseqs[1] + nisets[2]+1 + nseqs[2]);
    /* F        */
    intratmatcpy(sfconstr[2], 0, 0, nisets[2]+1, nseqs[2], 
	lcpM, nseqs[1], nseqs[1] + nisets[2]+1 );

    /* -B\T     */
    payratmatcpy(sfpay, 1, 1, 1, nseqs[1], nseqs[2], 
	lcpM, nseqs[1] + nisets[2]+1, 0);
    /* -F\T     */
    intratmatcpy(sfconstr[2], 1, 1, nisets[2]+1, nseqs[2], 
	lcpM, nseqs[1] + nisets[2]+1, nseqs[1] );
    /* E        */
    intratmatcpy(sfconstr[1], 0, 0, nisets[1]+1, nseqs[1], 
	lcpM, nseqs[1] + nisets[2]+1 + nseqs[2], 0 );
    /* define RHS q,  using special shape of SF constraints RHS e,f     */
    for (i = 0; i < lcpdim; i++)
	rhsq[i] = ratfromi(0);
    rhsq[ nseqs[1] ] = ratneg(ratfromi(1));
    rhsq[ nseqs[1]  + nisets[2]+1 + nseqs[2] ] = ratneg(ratfromi(1));
} 

void realplanfromprob(int pl, Rat *rplan)
{
    int i;

    for (i = 0; i < nseqs[pl]; i++)
         rplan[i] = (firstmove[pl] + i)->realprob;
}

Bool iseqrealplantoprob(int pl, Rat *rplan, Bool bcomplain)
{
    int i;
    char s[MAXSTRL];
    Bool isok=1;

    for (i = 0; i < nseqs[pl]; i++)
        if (! ratiseq(rplan[i], (firstmove[pl] + i)->realprob))
	    {
	    isok = 0;
            if (bcomplain)
                {
                seqtoa(firstmove[pl] + i, pl, s);
                printf ("Player %d, move %s has realprob ", pl, s);
                rattoa( (firstmove[pl] + i)->realprob, s);
                printf ("%s", s);
                rattoa( rplan[i], s);
                printf (", but should be %s\n", s);
                }
            else
                break;
            }
    return isok ;
}

int  propermixisets(int pl, Rat *rplan)
{
    int mix = 0;
    int i;
    Move c;
    Iset h;

    for (h = firstiset[pl]; h < firstiset[pl+1]; h++)
        for (c = h->move0, i=0; i < h->nmoves; c++, i++)
            if ( rplan[ c - firstmove[pl] ].num != 0  &&
                !ratiseq( rplan[ c - firstmove[pl] ],
                          rplan[ h->seqin - firstmove[pl]]) )
                {
                mix++ ;
                break ;
                }
    return mix;
}

void outrealplan(int pl, Rat *rplan)
{
    int i;
    char s[MAXSTRL];

    colset(nseqs[pl]) ;
    for (i = 0; i < nseqs[pl]; i++)
        {
        seqtoa(firstmove[pl] + i, pl, s);
        colpr(s);
        }
    for (i = 0; i < nseqs[pl]; i++)
        {
        rattoa(rplan[i], s);
        colpr(s);
        }
   colout();
}

void outbehavstrat(int pl, Rat *rplan, Bool bnewline)
{
    char s[MAXSTRL];
    int i;
    Move c;
    Iset h;
    Rat rprob, bprob;

    for (h = firstiset[pl]; h < firstiset[pl+1]; h++)
        for (c = h->move0, i=0; i < h->nmoves; c++, i++)
            {
            rprob = rplan[ c - firstmove[pl] ];
            if ( rprob.num != 0)
                {
                movetoa(c, pl, s);
                printf(" %s", s);
                bprob = ratdiv( rprob, rplan[ h->seqin - firstmove[pl]]);
                if (!ratiseq(bprob, ratfromi(1) ) )
                    {
                    rattoa(bprob, s);
                    printf(":%s", s);
                    }
                }
            }
    if (bnewline)
        printf("\n");
}

void sfprint(void)
{
    char s[MAXSTRL];
    int i, j, k;
    printf("SF payoffs and constraints:\n");
    
    colset(nseqs[2]+2+nisets[1]);
    colleft(0);
    colpr("pay1");
    for (j=0; j<nseqs[2]; j++)
	{
        seqtoa(firstmove[2] + j, 2, s);    colpr(s);
	}
    colnl();
    colpr("pay2");
    for (j=0; j<nseqs[2]; j++)
	colpr(" ");
    colpr("cons1");
    for (k=1; k<=nisets[1]; k++)
	/* headers for constraint matrix pl1, printed on right of payoffs   */
	colpr((firstiset[1]+k-1)->name);
    for (i=0; i<nseqs[1]; i++)
	{
	/* payoffs player 1 */
	seqtoa(firstmove[1] + i, 1, s);    colpr(s);
	for (j=0; j<nseqs[2]; j++)
	    {
	    rattoa(sfpay[i][j][0], s);     colpr(s);
	    }
	colnl();
	/* payoffs player 2 */
	colpr("");
	for (j=0; j<nseqs[2]; j++)
	    {
	    rattoa(sfpay[i][j][1], s);     colpr(s);
	    }
	/* constraints player 1 */
	for (k=0; k<=nisets[1]; k++)
	    colipr(sfconstr[1][k][i]);    
	colnl();
	}
    /* constraints player 2 */
    for (k=0; k<=nisets[2]; k++)
	{
	colnl();
	if (k==0)
	    colpr("cons2");
	else
	    colpr((firstiset[2]+k-1)->name);
	for (j=0; j<nseqs[2]; j++)
	    colipr(sfconstr[2][k][j]);
	colnl();
	}
    colout();
}       /* end of  sfprint()            */