epolenum.imp

Gambit 是一个游戏库理论软件

  catch (gSquareMatrix<gDouble>::MatrixSingular) {
    is_singular = true;
  }
  
  return quickie.RootList();
}

template <class T> int EfgPolEnumModule<T>::EfgPolEnum(gStatus &p_status)
{
  gPolyList<T> equations = NashOnSupportEquationsAndInequalities();

  // set up the rectangle of search
  gVector<T> bottoms(num_vars), tops(num_vars);
  bottoms = (T)0;
  tops = (T)1;
  gRectangle<T> Cube(bottoms, tops); 

  // timing
  gWatch watch;
  gWatch timer;
  timer.Start();

  gList<gVector<gDouble> > solutionlist = NashOnSupportSolnVectors(equations,
								   Cube,
								   timer,
								   p_status);

  int index = SaveNashSolutions(solutionlist, p_status);
  time = watch.Elapsed();
  return index;	 
}

template <class T> gPVector<double> 
EfgPolEnumModule<T>::SeqFormVectorFromSolFormVector(const gVector<gDouble> &v)
                                                                      const
{
  gPVector<double> x(SF.NumSequences());

  for (int i = 1; i <= EF.NumPlayers(); i++) 
    for (int j = 1; j <= SF.NumSequences()[i]; j++)
      x(i,j) = NumProbOfSequence(i,j,v);
  
  return x;
}

template <class T> bool 
EfgPolEnumModule<T>::ExtendsToANFNash(const BehavSolution &bs, 
				            gStatus &m_status) const
{
  algExtendsToAgentNash algorithm;
  return algorithm.ExtendsToAgentNash(bs, bs.Support(), bs.Support(),
				      m_status);
}

template <class T> int 
EfgPolEnumModule<T>::SaveANFNashSolutions(const gList<gVector<gDouble> > &list,
					  gStatus &p_status)
{
  int index=0;
  for (int k = 1; k <= list.Length(); k++) {
    gPVector<double> y = SeqFormVectorFromSolFormVector(list[k]);

    BehavSolution sol(SF.ToBehav(y), "PolEnum[EFG]");

    if (ExtendsToNash(sol,p_status)) { 
      index = solutions.Append(sol);
      solutions[index].SetEpsilon(0);
      //    solutions[index].SetIsNash(triTRUE);
    }
  }
  return index;
}

template <class T> bool 
EfgPolEnumModule<T>::ExtendsToNash(const BehavSolution &bs, 
				            gStatus &m_status) const
{
  algExtendsToNash algorithm;
  return algorithm.ExtendsToNash(bs, bs.Support(), bs.Support(), m_status);
}

template <class T> int 
EfgPolEnumModule<T>::SaveNashSolutions(const gList<gVector<gDouble> > &list,
				       gStatus &p_status)
{
  int index=0;
  for (int k = 1; k <= list.Length(); k++) {
    gPVector<double> y = SeqFormVectorFromSolFormVector(list[k]);

    BehavSolution sol(SF.ToBehav(y), "PolEnum[EFG]");

    if(ExtendsToNash(sol,p_status)) { 
      index = solutions.Append(sol);
      solutions[index].SetEpsilon(0);
    }
  }
  return index;
}


template <class T> long EfgPolEnumModule<T>::NumEvals(void) const
{
  return nevals;
}

template <class T> double EfgPolEnumModule<T>::Time(void) const
{
  return time;
}

template <class T> bool EfgPolEnumModule<T>::IsSingular(void) const
{
  return is_singular;
}

template <class T> EfgPolEnumParams &EfgPolEnumModule<T>::Parameters(void)
{
  return params;
}

template <class T>
const gList<BehavSolution> &EfgPolEnumModule<T>::GetSolutions(void) const
{
  return solutions;
}

template <class T> double EfgPolEnumModule<T>::
NumProbOfSequence(int p,int seq, const gVector<gDouble> &x) const
{
  int j = 0;
  double value=0;

  int isetrow = SF.InfosetRowNumber(p,seq);
  int act  = SF.ActionNumber(p,seq);
  int varno = (*(var[p]))[seq];

  if(seq==1)
    return (double)1;
  else if(act<support.NumActions(SF.GetInfoset(p,seq)))
    return x[varno].ToDouble();
  else {    
    for(j=1;j<seq;j++) {
      if((SF.Constraints(p))(isetrow,j)==-(gNumber)1)
	value-=NumProbOfSequence(p,j,x);
      if((SF.Constraints(p))(isetrow,j)==(gNumber)1)
	value+=NumProbOfSequence(p,j,x);
    }
    return value;
  }
}

template <class T> gPVector<double> 
EfgPolEnumModule<T>::SeqFormProbsFromSolVars(const gVector<gDouble> &v) const
{
  gPVector<double> x(SF.NumSequences());

  for(int pl=1;pl<=EF.NumPlayers();pl++) 
    for(int seq=1;seq<=SF.NumSequences()[pl];seq++)
      x(pl,seq) = NumProbOfSequence(pl,seq,v);

  return x;
}

template <class T> gVector<gDouble> 
EfgPolEnumModule<T>::SolVarsFromBehavProfile(const BehavProfile<gNumber> &sol)
  const
{
  int numvars(0);

  for (int pl = 1; pl <= EF.NumPlayers(); pl++) {
    EFPlayer *player = EF.Players()[pl];  
    for (int iset = 1; iset <= player->NumInfosets(); iset++) {
      const Infoset *infoset = player->GetInfoset(iset);
      if ( support.MayReach(infoset) )
	numvars += support.Actions(infoset).Length() - 1;
    }
  }

  gVector<gDouble> answer(numvars);
  int count(0);

  for (int pl = 1; pl <= EF.NumPlayers(); pl++) {
    EFPlayer *player = EF.Players()[pl];
    for (int iset = 1; iset <= player->NumInfosets(); iset++) {
      const Infoset *infoset = player->GetInfoset(iset);
      if ( support.MayReach(infoset) ) {
	const gArray<Action *> acts = support.Actions(infoset);
	for (int act = 1; act <= acts.Length() - 1; act++) {
	  count++;
	  answer[count] = (gDouble)sol.GetActionProb(acts[act]);
	}
      }
    }
  }

  return answer;
}

template <class T> gVector<gDouble> 
EfgPolEnumModule<T>::SolVarsFromSeqFormProbs(const gPVector<double> &x) const
{
  

  // Old version that doesn't work 
  int numvars = 0;
  for(int pl=1;pl<=EF.NumPlayers();pl++) 
    for(int seq=2;seq<=SF.NumSequences()[pl];seq++) {
      int act  = SF.ActionNumber(pl,seq);
      if(act<support.NumActions(SF.GetInfoset(pl,seq))) 
	numvars++;
    }
  gVector<gDouble> v(numvars);
  //  gVector<gDouble> v(SF.NumIndepVars());

  int count = 0;
  for(int pl=1;pl<=EF.NumPlayers();pl++) 
    for(int seq=2;seq<=SF.NumSequences()[pl];seq++) {
      int act  = SF.ActionNumber(pl,seq);
      if(act<support.NumActions(SF.GetInfoset(pl,seq))) {
	count++;
	int varno = (*(var[pl]))[seq];
	v[count] = (gDouble)x[varno];
      }
    }

  return v;
}

template <class T> 
const int EfgPolEnumModule<T>::PolishKnownRoot(gVector<gDouble> &point) const
{
  //DEBUG
  //  gout << "Prior to Polishing point is " << point << ".\n";

  if (point.Length() > 0) {
    int i,j;
    
    
    gWatch watch;
    gPolyList<T> equations(Space,Lex);
    
    // equations for equality of strat j to strat j+1
    
    int kk=0;
    for( i=1;i<=SF.NumPlayers();i++) {
      int n_vars=SF.NumSequences(i)-SF.NumInfosets(i)-1; 
      for(j=1;j<=n_vars;j++) 
	equations+=(Payoff(i)).PartialDerivative(kk+j);
      kk+=n_vars;
    }

    //DEBUG
    //    gout << "We are about to construct quickie with Dmnsn() = "
    //  << Space->Dmnsn() << " and equations = \n"
    //	 << equations << "\n";
    
    // start QuikSolv
    gNullStatus gstatus;
    QuikSolv<T> quickie(equations, gstatus);
    
    //DEBUG
    //    gout << "We constructed quickie.\n";
    
    try { 
      point = quickie.NewtonPolishedRoot(point);
    }
    catch (gSignalBreak &) { }
    catch (gSquareMatrix<gDouble>::MatrixSingular &) {
      return 0;
    }

    //DEBUG
    //    gout << "After Polishing point = " << point << ".\n";

  }

  return 1;	 
}

template <class T> BehavSolution 
EfgPolEnumModule<T>::ReturnPolishedSolution(const gVector<gDouble> &root) const
{
  gPVector<double> x(SF.NumSequences());

  for(int i=1;i<=EF.NumPlayers();i++) 
    for(int j=1;j<=SF.NumSequences()[i];j++) 
      x(i,j) = NumProbOfSequence(i,j,root);

  BehavSolution sol(SF.ToBehav(x), "Polish");
  return sol;
}