//
// $Source: /cvsroot/gambit/gambit/sources/libgambit/pvector.imp,v $
// $Date: 2006/07/20 16:23:14 $
// $Revision: 1.3 $
//
// DESCRIPTION:
// Implementation of partitioned vector members
//
// 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 "pvector.h"

namespace Gambit {

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

template <class T> int PVector<T>::sum(const Array<int> &V) const
{
  int total = 0;
  for (int i = V.First(); i <= V.Last(); total += V[i++]);
  return total;
}

template <class T> void PVector<T>::setindex(void)
{
  int index = this->First();
  for(int i = 1; i <= svlen.Length(); i++)  {
    svptr[i] = this->data + index - 1;
    index += svlen[i];
  }
  //assert(index == this->Last() + 1);
}


template <class T> int PVector<T>::Check(const PVector<T> &v) const
{
  if (v.mindex == this->mindex && v.maxdex == this->maxdex)  {
    for (int i = 1; i <= svlen.Length(); i++)
      if (svlen[i] != v.svlen[i])   return 0;
    return 1;
  }
  return 0;
}

//-------------------------------------------------------------------------
//     PVector<T>: Constructors, destructor, and constructive operators
//-------------------------------------------------------------------------

template <class T> PVector<T>::PVector(void) : svptr(0)
{ }

template <class T> PVector<T>::PVector(const Array<int> &sig)
  : Vector<T>(sum(sig)), svlen(sig)
{
  svptr = new T *[sig.Last() - sig.First() + 1];
  svptr -= 1;    // align things correctly
  setindex();
}

template <class T> PVector<T>::PVector(const Vector<T> &val,
					 const Array<int> &sig)
  : Vector<T>(val), svlen(sig)
{
  //assert(sum(svlen) == val.Length());
  svptr = new T *[sig.Last() - sig.First() + 1];
  svptr -= 1;
  setindex();
}

template <class T> PVector<T>::PVector(const PVector<T> &v)
  : Vector<T>(v), svlen(v.svlen)
{
  svptr = new T *[v.svlen.Last() - v.svlen.First() + 1];
  svptr -= 1;
  setindex();
}

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

template <class T> PVector<T>& PVector<T>::operator=(const PVector<T> &v)
{
  if (!Check(v)) {
    throw DimensionException();
  }
  Vector<T>::operator=(v);
  return (*this);
}

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

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

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

template <class T> T& PVector<T>::operator()(int a, int b)
{
  if (svlen.First() > a || a > svlen.Last()) {
    throw IndexException();
  }
  if (1 > b || b > svlen[a]) {
    throw IndexException();
  }

  return svptr[a][b];
}

template <class T> const T& PVector<T>::operator()(int a, int b) const
{
  if (svlen.First() > a || a > svlen.Last()) {
    throw IndexException();
  }
  if (1 > b || b > svlen[a])  {
    throw IndexException();
  }
  return svptr[a][b];
}

template <class T>
PVector<T> PVector<T>::operator+(const PVector<T> &v) const
{
  if (!Check(v)) {
    throw DimensionException();
  }
  PVector<T> tmp(*this);
  tmp.Vector<T>::operator+=(v);
  return tmp;
}

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

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

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

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

template <class T> T PVector<T>::operator*(const PVector<T> &v) const
{
  if (!Check(v)) {
    throw DimensionException();
  }
  return (*this).Vector<T>::operator*(v);
}

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

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

template <class T> PVector<T> PVector<T>::operator/(T c)
{
  PVector<T> tmp(*this);
  tmp= tmp.Vector<T>::operator/(c);
  return tmp;
}

template <class T> bool PVector<T>::operator==(const PVector<T> &v) const
{
  if (!Check(v)) {
    throw DimensionException();
  }
  return (*this).Vector<T>::operator==(v);
}

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

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

template <class T> Vector<T> PVector<T>::GetRow(int row) const
{
  if (svlen.First() > row || row > svlen.Last())  {
    throw IndexException();
  }

  Vector<T> v(1, svlen[row]);

  for(int i=v.First(); i<=v.Last(); i++)
    v[i]= (*this)(row,i);
  return v;
}

template <class T> void PVector<T>::GetRow(int row, Vector<T> &v) const
{
  if (svlen.First() > row || row > svlen.Last()) {
    throw IndexException();
  }
  if (v.First() != 1 || v.Last() != svlen[row]) {
    throw DimensionException();
  }

  for(int i=v.First(); i<=v.Last(); i++)
    v[i]= (*this)(row,i);
}

template <class T> void PVector<T>::SetRow(int row, const Vector<T> &v)
{
  if (svlen.First() > row || row > svlen.Last()) {
    throw IndexException();
  }
  if (v.First() != 1 || v.Last() != svlen[row]) {
    throw DimensionException();
  }

  for(int i=v.First(); i<=v.Last(); i++)
    (*this)(row,i)= v[i];
}

template <class T> void PVector<T>::CopyRow(int row, const PVector<T> &v)
{
  if (!Check(v)) {
    throw DimensionException();
  }

  if (svlen.First() > row || row > svlen.Last()) {
    throw IndexException(); 
  }

  for (int i = 1; i <= svlen[row]; i++)
    svptr[row][i] = v.svptr[row][i];
}

template <class T> const Array<int> &PVector<T>::Lengths(void) const
{
  return svlen;
}

} // end namespace Gambit