vector/Vector2.cxx

// Copyright (C) 2010, INRIA
// Author(s): Marc Fragu, Vivien Mallet
// Copyright (C) 2011, 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>
  Vector<T, VectFull, Allocator0>
  Vector2<T, Allocator0, Allocator1>::Flatten() const
  {
    Vector<T, VectFull, Allocator0> data(GetNelement());
    int i, j, n(0);
    for (i = 0; i < GetLength(); i++)
      for (j = 0; j < GetLength(i); j++)
        data(n++) = data_(i)(j);
    return data;
  }



  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);
  }



  template <class T, class Allocator0, class Allocator1>
  Vector2<T, Allocator0, Allocator1>
  Vector2<T, Allocator0, Allocator1>::Copy() const
  {
    Vector2<T, Allocator0, Allocator1> output;
    output.Copy(*this);
    return output;
  }


  /*********************************
   * 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();
      }
  }


  /**************************
   * INPUT/OUTPUT FUNCTIONS *
   **************************/



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::Write(string file_name, bool with_size) const
  {
    ofstream file_stream;
    file_stream.open(file_name.c_str());

#ifdef SELDON_CHECK_IO
    // Checks if the file was opened.
    if (!file_stream.is_open())
      throw IOError("Vector2::Write(string file_name, bool with_size)",
                    string("Unable to open file \"") + file_name + "\".");
#endif

    this->Write(file_stream, with_size);

    file_stream.close();
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::Write(ostream& stream, bool with_size) const
  {

#ifdef SELDON_CHECK_IO
    // Checks if the stream is ready.
    if (!stream.good())
      throw IOError("Vector2::Write(ostream& stream, bool with_size)",
                    "The stream is not ready.");
#endif

    if (with_size)
      {
        int m = GetLength();
        stream.write(reinterpret_cast<char*>(const_cast<int*>(&m)),
                     sizeof(int));
      }

    for (int i = 0; i < GetLength(); i++)
      data_(i).Write(stream, with_size);

#ifdef SELDON_CHECK_IO
    // Checks if data was written.
    if (!stream.good())
      throw IOError("Vector2::Write(ostream& stream, bool with_size)",
                    "Output operation failed.");
#endif

  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::Read(string file_name, bool with_size)
  {
    ifstream file_stream;
    file_stream.open(file_name.c_str());

#ifdef SELDON_CHECK_IO
    // Checks if the file was opened.
    if (!file_stream.is_open())
      throw IOError("Vector2::Read(string file_name, bool with_size)",
                    string("Unable to open file \"") + file_name + "\".");
#endif

    this->Read(file_stream, with_size);

    file_stream.close();
  }



  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::Read(istream& stream, bool with_size)
  {

#ifdef SELDON_CHECK_IO
    // Checks if the stream is ready.
    if (!stream.good())
      throw IOError("Vector2::Read(istream& stream, bool with_size)",
                    "The stream is not ready.");
#endif

    if (with_size)
      {
        int new_size;
        stream.read(reinterpret_cast<char*>(&new_size), sizeof(int));
        this->Reallocate(new_size);
      }

    for (int i = 0; i < GetLength(); i++)
      data_(i).Read(stream, with_size);

#ifdef SELDON_CHECK_IO
    // Checks if data was read.
    if (!stream.good())
      throw IOError("Vector2::Read(istream& stream, bool with_size)",
                    "Output operation failed.");
#endif

  }


} // namespace Seldon.


#define SELDON_FILE_VECTOR_VECTOR2_CXX
#endif