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(long length)
  {
    data_.Reallocate(length);
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  Vector2<T, Allocator0, Allocator1>::Vector2(const Vector<long>& length)
  {
    data_.Clear();
    long m = length.GetSize();
    data_.Reallocate(m);
    for(long 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 (long i = 0; i < GetLength(); i++)
      if (GetLength(i) > 0)
        return false;
    return true;
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  long Vector2<T, Allocator0, Allocator1>::GetSize() const
  {
    return data_.GetSize();
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  long Vector2<T, Allocator0, Allocator1>::GetLength() const
  {
    return data_.GetLength();
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  long Vector2<T, Allocator0, Allocator1>::GetSize(long i) const
  {
    return data_(i).GetSize();
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  size_t Vector2<T, Allocator0, Allocator1>::GetMemorySize() const
  {
    size_t total = sizeof(*this) + sizeof(pointer)*GetLength();
    for (long i = 0; i < GetLength(); i++)
      total += data_(i).GetMemorySize();
    
    return total;
  }
  
 
 
  template <class T, class Allocator0, class Allocator1>
  long Vector2<T, Allocator0, Allocator1>::GetLength(long i) const
  {
    return data_(i).GetLength();
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  long Vector2<T, Allocator0, Allocator1>::GetNelement() const
  {
    long total = 0;
    for (long i = 0; i < GetLength(); i++)
      total += GetLength(i);
    return total;
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  long Vector2<T, Allocator0, Allocator1>::GetNelement(long beg, long end) const
  {
    if (beg > end)
      throw WrongArgument("Vector2::GetNelement(long beg, long 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(long beg, long end)",
                          "The inner-vector indexes should be in [0,"
                          + to_str(GetLength()) + "] but [" + to_str(beg)
                          + ", " + to_str(end) + "[ was provided.");
 
    long total = 0;
    for (long i = beg; i < end; i++)
      total += GetLength(i);
    return total;
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  Vector<long> Vector2<T, Allocator0, Allocator1>::GetShape() const
  {
    Vector<long> shape(GetLength());
    for (long 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<long>& shape) const
  {
    shape.Reallocate(GetLength());
    for (long i = 0; i < GetLength(); i++)
      shape(i) = GetLength(i);
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Reallocate(long M)
  {
    data_.Reallocate(M);
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Reallocate(long i, long N)
  {
    data_(i).Reallocate(N);
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>
  ::Reallocate(const Vector<long>& length)
  {
    long m = length.GetSize();
    data_.Reallocate(m);
    for(long i = 0; i < m; i++)
      data_(i).Reallocate(length(i));
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Select(long beg, long end)
  {
    if (beg > end)
      throw WrongArgument("Vector2::SelectInnerVector(long beg, long 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(long beg, long 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 (long i = 0; i < end - beg; i++)
        data_(i) = data_(beg + i);
 
    data_.Resize(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());
    long 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());
    long 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(long beg, long end, Vector<Td, VectFull, Allocatord>& data) const
  {
    if (beg > end)
      throw WrongArgument("Vector2::Flatten(long beg, long 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(long beg, long 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));
    long 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(long 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 (long i = 0; i < V.GetM(); 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(long i)
  {
    data_(i).Clear();
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  void Vector2<T, Allocator0, Allocator1>::Fill(const T& x)
  {
    for (long i = 0; i < data_.GetM(); 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(long i)
  {
    return data_(i);
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  const Vector<T, VectFull, Allocator0>&
  Vector2<T, Allocator0, Allocator1>::GetVector(long 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 (long 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() (long i) const
  {
    return data_(i);
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  Vector<T, VectFull, Allocator0>&
  Vector2<T, Allocator0, Allocator1>::operator() (long i)
  {
    return data_(i);
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  typename Vector2<T, Allocator0, Allocator1>::const_reference
  Vector2<T, Allocator0, Allocator1>::operator() (long i, long j) const
  {
    return data_(i)(j);
  }
 
 
 
  template <class T, class Allocator0, class Allocator1>
  typename Vector2<T, Allocator0, Allocator1>::reference
  Vector2<T, Allocator0, Allocator1>::operator() (long i, long 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 (long 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 (long i = 0; i < data_.GetM(); 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 (long 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 (long 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