gdpvect.imp

Gambit 是一个游戏库理论软件

//
// $Source: /home/gambit/CVS/gambit/sources/math/gdpvect.imp,v $
// $Date: 2002/08/26 05:50:02 $
// $Revision: 1.3 $
//
// DESCRIPTION:
// Implementation of doubly-partitioned vector class
//
// This file is part of Gambit
// Copyright (c) 2002, The Gambit Project
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//

#include "math/gdpvect.h"

//--------------------------------------------------------------------------
//          gDPVector<T>: Private and protected member functions
//--------------------------------------------------------------------------

template <class T>
int gDPVector<T>::sum(int part, const gPVector<int> &v) const
{
  int s = 0;

  gArray<int> len(v.Lengths());
  for (int j = 1; j <= len[part]; j++)
    s += v(part, j);

  return s;
}

template <class T> void gDPVector<T>::setindex(void)
{
  int index = 1;
  
  for (int i = 1; i <= dvlen.Length(); i++)  {
    dvptr[i] = svptr + index - 1;
    dvidx[i] = index;
    index += dvlen[i];
  }
}

template <class T> bool gDPVector<T>::Check(const gDPVector<T> &v) const
{
  for (int i = 1; i <= dvlen.Length(); i++)
    if (dvlen[i] != v.dvlen[i])   return false;
  return true;
}
    
//--------------------------------------------------------------------------
//    gDPVector<T>: Constructors, destructor, and constructive operators
//--------------------------------------------------------------------------

template <class T> gDPVector<T>::gDPVector(void) : dvptr(0)
{ }

template <class T> gDPVector<T>::gDPVector(const gPVector<int> &sig)
  : gPVector<T>((gArray<int>)sig), dvlen(sig.Lengths().Length()),
    dvidx(sig.Lengths().Length())
{
  dvptr = new T **[dvlen.Length()];
  dvptr -= 1;

  for (int i = 1; i <= dvlen.Length(); i++)
    dvlen[i] = sig.Lengths()[i];

  setindex();
}

template <class T> gDPVector<T>::gDPVector(const gVector<T> &val,
					   const gPVector<int> &sig)
  : gPVector<T>(val, sig), dvlen(sig.Lengths().Length()),
    dvidx(sig.Lengths().Length())
{
  dvptr = new T **[dvlen.Length()];
  dvptr -= 1;

  for (int i = 1; i <= dvlen.Length(); i++)
    dvlen[i] = sig.Lengths()[i];

  setindex();
}

template <class T> gDPVector<T>::gDPVector(const gDPVector<T> &v)
  : gPVector<T>(v), dvlen(v.dvlen), dvidx(v.dvidx)
{
  dvptr = new T **[dvlen.Length()];
  dvptr -= 1;

  setindex();
}

template <class T> gDPVector<T>::~gDPVector()
{
  if (dvptr)  delete [] (dvptr + 1);
}

template <class T> gDPVector<T> &gDPVector<T>::operator=(const gDPVector<T> &v)
{
  if (!Check(v))   throw BadDim();

  gPVector<T>::operator=(v);
  return *this;
}

template <class T> gDPVector<T> &gDPVector<T>::operator=(const gPVector<T> &v)
{
  gPVector<T>::operator=(v);
  return *this;
}

template <class T> gDPVector<T> &gDPVector<T>::operator=(const gVector<T> &v)
{
  gPVector<T>::operator=(v);
  return *this;
}

template <class T> gDPVector<T> &gDPVector<T>::operator=(T c)
{
  gPVector<T>::operator=(c);
  return *this;
}



//--------------------------------------------------------------------------
//                    gDPVector<T>: Operator definitions
//--------------------------------------------------------------------------

template <class T> T &gDPVector<T>::operator()(int a, int b, int c)
{
  if (dvlen.First() > a || a > dvlen.Last())    throw BadIndex();
  if (1 > b || b > dvlen[a])                    throw BadIndex();
  if (1 > c || c > svlen[dvidx[a] + b - 1])     throw BadIndex();
  return dvptr[a][b][c];
}

template <class T> const T &gDPVector<T>::operator()(int a, int b, int c) const
{
  if (dvlen.First() > a || a > dvlen.Last())    throw BadIndex();
  if (1 > b || b > dvlen[a])                    throw BadIndex();
  if (1 > c || c > svlen[dvidx[a] + b - 1])     throw BadIndex();
  return dvptr[a][b][c];
}

template <class T>
gDPVector<T> gDPVector<T>::operator+(const gDPVector<T> &v) const
{
  if (!Check(v))   throw BadDim();

  gDPVector<T> tmp(*this);
  tmp.gPVector<T>::operator+=(v);
  return tmp;
}

template <class T>
gDPVector<T> &gDPVector<T>::operator+=(const gDPVector<T> &v)
{
  if (!Check(v))   throw BadDim();
  gPVector<T>::operator+=(v);
  return *this;
}

template <class T> gDPVector<T> gDPVector<T>::operator-(void) const
{
  gDPVector<T> tmp(*this);
  for (int i = First(); i <= Last(); i++)
    tmp[i] = -tmp[i];
  return tmp;
}

template <class T>
gDPVector<T> gDPVector<T>::operator-(const gDPVector<T> &v) const
{
  if (!Check(v))   throw BadDim();
  gDPVector<T> tmp(*this);
  tmp.gPVector<T>::operator-=(v);
  return tmp;
}

template <class T>
gDPVector<T> &gDPVector<T>::operator-=(const gDPVector<T> &v)
{
  if (!Check(v))   throw BadDim();
  gPVector<T>::operator-=(v);
  return *this;
}

template <class T> T gDPVector<T>::operator*(const gDPVector<T> &v) const
{
  if (!Check(v))   throw BadDim();
  return (*this).gPVector<T>::operator*(v);
}

template <class T> gDPVector<T> &gDPVector<T>::operator*=(const T &c)
{
  gPVector<T>::operator*=(c);
  return *this;
}

template <class T> gDPVector<T> gDPVector<T>::operator/(const T &c) const
{
  gDPVector<T> tmp(*this);
  tmp = tmp.gPVector<T>::operator/(c);
  return tmp;
}

template <class T> bool gDPVector<T>::operator==(const gDPVector<T> &v) const
{
  if (!Check(v))   throw BadDim();
  return gPVector<T>::operator==(v);
}

template <class T> bool gDPVector<T>::operator!=(const gDPVector<T> &v) const
{
  return !(*this == v);
}

//-------------------------------------------------------------------------
//                 gDPVector<T>: General data access
//-------------------------------------------------------------------------

template <class T>
void gDPVector<T>::CopySubRow(int row, int col, const gDPVector<T> &v)
{
  if (!Check(v))   throw BadDim();
  if (dvlen.First() > row || row > dvlen.Last())   throw BadIndex();
  if (1 > col || col > dvlen[row])                 throw BadIndex();

  for (int i = 1; i <= svlen[dvidx[row]+col-1]; i++)
    dvptr[row][col][i] = v.dvptr[row][col][i];
}



template <class T> const gArray<int> &gDPVector<T>::DPLengths(void) const
{
  return dvlen;
}

//--------------------------------------------------------------------------
//                      gDPVector<T>: Output functions
//--------------------------------------------------------------------------

template <class T> void gDPVector<T>::Dump(gOutput &f) const
{
  for (int i = 1; i <= dvlen.Length(); i++)  {
    f << "{ ";
    for (int j = 1; j <= dvlen[i]; j++)  {
      f << "{ ";
      for (int k = 1; k <= svlen[dvidx[i] + j - 1]; k++)
	f << (*this)(i, j, k) << ' ';
      f << "}";
    }
    f << " }";
  }
}

template <class T> gOutput &operator<<(gOutput &f, const gDPVector<T> &v)
{
  v.Dump(f);  return f;
}