vector/Vector2.cxx

// Copyright (C) 2010, INRIA
// Author(s): Marc Fragu, Vivien Mallet
//
// This file is part of the linear-algebra library Seldon,
// http://seldon.sourceforge.net/.
//
// Seldon is free software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 2.1 of the License, or (at your option)
// any later version.
//
// Seldon 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 Lesser General Public License for
// more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Seldon. If not, see http://www.gnu.org/licenses/.


#ifndef SELDON_FILE_VECTOR_VECTOR2_CXX


#include "Vector2.hxx"


namespace Seldon
{


  // VECTOR2 //


  /***************
   * CONSTRUCTOR *
   ***************/



  template <class T, class Allocator0, class Allocator1>
  Vector2<T, Allocator0, Allocator1>::Vector2()
  {
  }



  template <class T, class Allocator0, class Allocator1>
  Vector2<T, Allocator0, Allocator1>::Vector2(int length)
  {
    data_.Reallocate(length);
  }



  template <class T, class Allocator0, class Allocator1>
  Vector2<T, Allocator0, Allocator1>::Vector2(const Vector<int>& length)
  {
    data_.Clear();
    int m = length.GetSize();
    data_.Reallocate(m);
    for(int i = 0; i < m; i++)
      data_(i).Reallocate(length(i));
  }


  /**************
   * DESTRUCTOR *
   **************/


  template <class T, class Allocator0, class Allocator1>
  Vector2<T, Allocator0, Allocator1>::~Vector2()
  {
  }


  /*****************************
   * MANAGEMENT OF THE VECTORS *
   *****************************/



  template <class T, class Allocator0, class Allocator1>
  bool Vector2<T, Allocator0, Allocator1>::IsEmpty() const
  {
    for (int i = 0; i < GetLength(); i++)
      if (GetLength(i) > 0)
        return false;
    return true;
  }



  template <class T, class Allocator0, class Allocator1>
  int Vector2<T, Allocator0, Allocator1>::GetSize() const
  {
    return data_.GetSize();
  }



  template <class T, class Allocator0, class Allocator1>
  int Vector2<T, Allocator0, Allocator1>::GetLength() const
  {
    return data_.GetLength();
  }



  template <class T, class Allocator0, class Allocator1>
  int Vector2<T, Allocator0, Allocator1>::GetSize(int i) const
  {
    return data_(i).GetSize();
  }



  template <class T, class Allocator0, class Allocator1>
  int Vector2<T, Allocator0, Allocator1>::GetLength(int i) const
  {
    return data_(i).GetLength();
  }



  template <class T, class Allocator0, class Allocator1>
  int Vector2<T, Allocator0, Allocator1>::GetNelement() const
  {
    int total = 0;
    for (int i = 0; i < GetLength(); i++)
      total += GetLength(i);
    return total;
  }



  template <class T, class Allocator0, class Allocator1>
  int Vector2<T, Allocator0, Allocator1>::GetNelement(int beg, int end) const
  {
    if (beg > end)
      throw WrongArgument("Vector2::GetNelement(int beg, int end)",
                          "The lower bound of the range of inner vectors, ["
                          + to_str(beg) + ", " + to_str(end)
                          + "[, is strictly greater than its upper bound.");
    if (beg < 0 || end > GetLength())
      throw WrongArgument("Vector2::GetNelement(int beg, int end)",
                          "The inner-vector indexes should be in [0,"
                          + to_str(GetLength()) + "] but [" + to_str(beg)
                          + ", " + to_str(end) + "[ was provided.");

    int total = 0;
    for (int i = beg; i < end; i++)
      total += GetLength(i);
    return total;
  }



  template <class T, class Allocator0, class Allocator1>
  Vector<int> Vector2<T, Allocator0, Allocator1>::GetShape() const
  {
    Vector<int> shape(GetLength());
    for (int i = 0; i < GetLength(); i++)
      shape(i) = GetLength(i);
    return shape;
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::GetShape(Vector<int>& shape) const
  {
    shape.Reallocate(GetLength());
    for (int i = 0; i < GetLength(); i++)
      shape(i) = GetLength(i);
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Reallocate(int M)
  {
    data_.Reallocate(M);
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Reallocate(int i, int N)
  {
    data_(i).Reallocate(N);
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::Reallocate(const Vector<int>& length)
  {
    int m = length.GetSize();
    data_.Reallocate(m);
    for(int i = 0; i < m; i++)
      data_(i).Reallocate(length(i));
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Select(int beg, int end)
  {
    if (beg > end)
      throw WrongArgument("Vector2::SelectInnerVector(int beg, int end)",
                          "The lower bound of the range of inner vectors, ["
                          + to_str(beg) + ", " + to_str(end)
                          + "[, is strictly greater than its upper bound.");
    if (beg < 0 || end > GetLength())
      throw WrongArgument("Vector2::SelectInnerVector(int beg, int end)",
                          "The inner-vector indexes should be in [0,"
                          + to_str(GetLength()) + "] but [" + to_str(beg)
                          + ", " + to_str(end) + "[ was provided.");

    if (beg > 0)
      for (int i = 0; i < end - beg; i++)
        data_(i) = data_(beg + i);
    data_.Reallocate(end - beg);
  }



  template <class T, class Allocator0, class Allocator1>
  template <class Td, class Allocatord>
  void Vector2<T, Allocator0, Allocator1>
  ::Flatten(Vector<Td, VectFull, Allocatord>& data) const
  {
    data.Reallocate(GetNelement());
    int i, j, n(0);
    for (i = 0; i < GetLength(); i++)
      for (j = 0; j < GetLength(i); j++)
        data(n++) = data_(i)(j);
  }



  template <class T, class Allocator0, class Allocator1>
  template <class Td, class Allocatord>
  void Vector2<T, Allocator0, Allocator1>
  ::Flatten(int beg, int end, Vector<Td, VectFull, Allocatord>& data) const
  {
    if (beg > end)
      throw WrongArgument("Vector2::Flatten(int beg, int end, Vector& data)",
                          "The lower bound of the range of inner vectors, ["
                          + to_str(beg) + ", " + to_str(end)
                          + "[, is strictly greater than its upper bound.");
    if (beg < 0 || end > GetLength())
      throw WrongArgument("Vector2::Flatten(int beg, int end, Vector& data)",
                          "The inner-vector indexes should be in [0,"
                          + to_str(GetLength()) + "] but [" + to_str(beg)
                          + ", " + to_str(end) + "[ was provided.");

    data.Reallocate(GetNelement(beg, end));
    int i, j, n(0);
    for (i = beg; i < end; i++)
      for (j = 0; j < GetLength(i); j++)
        data(n++) = data_(i)(j);
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::PushBack(int i, const T& x)
  {
    data_(i).PushBack(x);
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::PushBack(const Vector<T, VectFull, Allocator0>& X)
  {
    data_.PushBack(X);
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::PushBack(const Vector<Vector<T, VectFull, Allocator0>,
             VectFull, Allocator1>& V)
  {
    for (int i = 0; i < V.GetLength(); i++)
      data_.PushBack(V(i));
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::PushBack(const Vector2<T, Allocator0, Allocator1>& V)
  {
    PushBack(V.GetVector());
  }


  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Clear()
  {
    data_.Clear();
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Clear(int i)
  {
    data_(i).Clear();
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Fill(const T& x)
  {
    for (int i = 0; i < data_.GetLength(); i++)
      data_(i).Fill(x);
  }



  template <class T, class Allocator0, class Allocator1>
  Vector<Vector<T, VectFull, Allocator0>, VectFull, Allocator1>&
  Vector2<T, Allocator0, Allocator1>::GetVector()
  {
    return data_;
  }



  template <class T, class Allocator0, class Allocator1>
  const Vector<Vector<T, VectFull, Allocator0>, VectFull, Allocator1>
  Vector2<T, Allocator0, Allocator1>::GetVector() const
  {
    return data_;
  }



  template <class T, class Allocator0, class Allocator1>
  Vector<T, VectFull, Allocator0>&
  Vector2<T, Allocator0, Allocator1>::GetVector(int i)
  {
    return data_(i);
  }



  template <class T, class Allocator0, class Allocator1>
  const Vector<T, VectFull, Allocator0>&
  Vector2<T, Allocator0, Allocator1>::GetVector(int i) const
  {
    return data_(i);
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::Copy(const Vector2<T, Allocator0, Allocator1>& V)
  {
    Clear();
    Reallocate(V.GetLength());
    for (int i = 0; i < V.GetLength(); i++)
      data_(i) = V(i);
  }


  /*********************************
   * ELEMENT ACCESS AND ASSIGNMENT *
   *********************************/



  template <class T, class Allocator0, class Allocator1>
  const Vector<T, VectFull, Allocator0>&
  Vector2<T, Allocator0, Allocator1>::operator() (int i) const
  {
    return data_(i);
  }



  template <class T, class Allocator0, class Allocator1>
  Vector<T, VectFull, Allocator0>&
  Vector2<T, Allocator0, Allocator1>::operator() (int i)
  {
    return data_(i);
  }



  template <class T, class Allocator0, class Allocator1>
  typename Vector2<T, Allocator0, Allocator1>::const_reference
  Vector2<T, Allocator0, Allocator1>::operator() (int i, int j) const
  {
    return data_(i)(j);
  }



  template <class T, class Allocator0, class Allocator1>
  typename Vector2<T, Allocator0, Allocator1>::reference
  Vector2<T, Allocator0, Allocator1>::operator() (int i, int j)
  {
    return data_(i)(j);
  }


  /**********************
   * CONVENIENT METHODS *
   **********************/



  template <class T, class Allocator0, class Allocator1>
  template <class V2>
  bool Vector2<T, Allocator0, Allocator1>::HasSameShape(const V2& V) const
  {
    if (V.GetLength() != GetLength())
      return false;
    for (int i = 0; i < GetLength(); i++)
      if (V.GetLength(i) != GetLength(i))
        return false;
    return true;
  }


  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Print() const
  {
    for (int i = 0; i < data_.GetLength(); i++)
      {
        cout << "Vector " << i << ": ";
        data_(i).Print();
      }
  }


} // namespace Seldon.


#define SELDON_FILE_VECTOR_VECTOR2_CXX
#endif