VectorCollection.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_VECTORCOLLECTION_CXX
 
 
#include "VectorCollection.hxx"
 
 
namespace Seldon
{
 
 
  // VECTORCOLLECTION //
 
 
  /**************
   * DESTRUCTOR *
   **************/
 
 
 
  template <class T, class Allocator >
  Vector<T, Collection, Allocator>::~Vector()
  {
    for (int i = 0; i < Nvector_; i++)
      vector_(i).Nullify();
    label_map_.clear();
    label_vector_.clear();
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>::Clear()
  {
    for (int i = 0; i < Nvector_; i++)
      vector_(i).Nullify();
    vector_.Clear();
    length_sum_.Clear();
    length_.Clear();
    Nvector_ = 0;
    this->m_ = 0;
    label_map_.clear();
    label_vector_.clear();
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>::Reallocate(int i)
  {
    Clear();
    vector_type v;
    v.Reallocate(i);
    AddVector(v);
    v.Nullify();
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>::Deallocate()
  {
    for (int i = 0; i < Nvector_; i++)
      vector_(i).Clear();
    vector_.Clear();
    length_sum_.Clear();
    length_.Clear();
    Nvector_ = 0;
    this->m_ = 0;
    label_map_.clear();
    label_vector_.clear();
  }
 
 
  /**********************
   * VECTORS MANAGEMENT *
   **********************/
 
 
 
  template <class T, class Allocator >
  int Vector<T, Collection, Allocator>
  ::GetVectorIndex(string name) const
  {
    map<string,int>::const_iterator label_iterator = label_map_.find(name);
    if (label_iterator == label_map_.end())
      throw WrongArgument("VectorCollection::GetVectorIndex(string name)",
                          "Unknown vector name: \"" + name + "\".");
    return label_iterator->second;
  }
 
 
  template <class T, class Allocator >
  int Vector<T, Collection, Allocator>::GetIndex(string name) const
  {
    map<string,int>::const_iterator label_iterator = label_map_.find(name);
    if (label_iterator == label_map_.end())
      throw WrongArgument("VectorCollection::GetIndex(string name)",
                          string("Unknown vector name: \"") + name + "\".");
    return (label_iterator->second == 0) ?
      0 : length_sum_(label_iterator->second - 1);
  }
 
 
 
  template <class T, class Allocator >
  typename
  Vector<T, Collection, Allocator>::const_vector_reference
  Vector<T, Collection, Allocator>::GetVector(string name) const
  {
    map<string,int>::const_iterator label_iterator;
    label_iterator = label_map_.find(name);
    if (label_iterator == label_map_.end())
      throw WrongArgument("VectorCollection::SetVector(string name)",
                          string("Unknown vector name: \"") + name + "\".");
    return GetVector(label_iterator->second);
  }
 
 
 
  template <class T, class Allocator >
  typename Vector<T, Collection, Allocator>::vector_reference
  Vector<T, Collection, Allocator>::GetVector(string name)
  {
    map<string,int>::iterator label_iterator;
    label_iterator = label_map_.find(name);
    if (label_iterator == label_map_.end())
      throw WrongArgument("VectorCollection::SetVector(string name)",
                          string("Unknown vector name: \"") + name + "\".");
    return GetVector(label_iterator->second);
  }
 
 
  /*********************************
   * ELEMENT ACCESS AND ASSIGNMENT *
   *********************************/
 
 
 
  template <class T, class Allocator >
  typename Vector<T, Collection, Allocator>::reference
  Vector<T, Collection, Allocator>::operator() (int i)
  {
#ifdef SELDON_CHECK_BOUNDS
    if (i < 0 || i >= this->m_)
      throw WrongIndex("VectorCollection::operator()",
                       string("Index should be in [0, ")
                       + to_str(this->m_ - 1)
                       + "], but is equal to " + to_str(i) + ".");
#endif
 
    int j = 0;
    while (i >= length_sum_(j))
      j++;
    return (j == 0) ? vector_(j)(i) : vector_(j)(i - length_sum_(j - 1));
  }
 
 
 
  template <class T, class Allocator >
  typename Vector<T, Collection, Allocator>::const_reference
  Vector<T, Collection, Allocator>::operator() (int i) const
  {
#ifdef SELDON_CHECK_BOUNDS
    if (i < 0 || i >= this->m_)
      throw WrongIndex("VectorCollection::operator()",
                       string("Index should be in [0, ")
                       + to_str(this->m_ - 1)
                       + "], but is equal to " + to_str(i) + ".");
#endif
 
    int j = 0;
    while (i >= length_sum_(j))
      j++;
    return (j == 0) ? vector_(j)(i) : vector_(j)(i - length_sum_(j - 1));
  }
 
 
 
  template <class T, class Allocator >
  Vector<T, Collection, Allocator>&
  Vector<T, Collection, Allocator>::operator=
  (const Vector<T, Collection, Allocator>& X)
  {
    this->Copy(X);
    return *this;
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>
  ::Copy(const Vector<T, Collection, Allocator>& X)
  {
    Clear();
    for (int i = 0; i < X.GetNvector(); i++)
      AddVector(X.GetVector(i));
    label_map_.insert(X.label_map_.begin(), X.label_map_.end());
    label_vector_.assign(X.label_vector_.begin(), X.label_vector_.end());
  }
 
 
 
  template <class T, class Allocator >
  template <class T0, class Allocator0>
  void Vector<T, Collection, Allocator>
  ::Copy(const Vector<T0, VectFull, Allocator0>& X)
  {
#ifdef SELDON_CHECK_BOUNDS
    if (this->m_ != X.GetM())
      throw WrongIndex("VectorCollection::Copy(X)",
                       string("The size of X should be equal to ")
                       + to_str(this->m_ - 1)
                       + ", but is equal to " + to_str(X.GetM()) + ".");
#endif
 
    for (int i = 0; i < X.GetM(); i++)
      (*this)(i) = X(i);
  }
 
 
 
  template <class T, class Allocator >
  template <class T0, class Storage0, class Allocator0>
  void Vector<T, Collection, Allocator>
  ::AddVector(const Vector<T0,
              Storage0, Allocator0>& vector)
  {
    Nvector_++;
    length_.PushBack(0);
    length_sum_.PushBack(this->m_);
 
    // Resizes 'vector_'.
    collection_type new_vector(Nvector_);
    for (int i = 0; i < Nvector_ - 1; i++)
      {
        new_vector(i).SetData(vector_(i));
        vector_(i).Nullify();
      }
    vector_.Clear();
    vector_.SetData(new_vector);
    new_vector.Nullify();
 
    // Adds the new vector.
    SetVector(Nvector_ - 1, vector);
  }
 
 
 
  template <class T, class Allocator >
  template <class T0, class Storage0, class Allocator0>
  void Vector<T, Collection, Allocator>
  ::AddVector(const Vector<T0,
              Storage0, Allocator0>& vector,
              string name)
  {
    AddVector(vector);
    SetName(Nvector_ - 1, name);
  }
 
 
 
  template <class T, class Allocator >
  template <class T0, class Storage0, class Allocator0>
  void Vector<T, Collection, Allocator>
  ::SetVector(int i, const Vector<T0,
              Storage0, Allocator0>& vector)
  {
    int size_difference;
    size_difference = vector.GetM() - vector_(i).GetM();
    this->m_ += size_difference;
    length_(i) = vector.GetM();
    for (int k = i; k < Nvector_; k++)
      length_sum_(k) += size_difference;
 
    vector_(i).Nullify();
    vector_(i).SetData(vector);
  }
 
 
 
  template <class T, class Allocator >
  template <class T0, class Storage0, class Allocator0>
  void Vector<T, Collection, Allocator>
  ::SetVector(int i, const Vector<T0, Storage0, Allocator0>& vector,
              string name)
  {
    SetVector(i, vector);
    SetName(i, name);
  }
 
 
 
  template <class T, class Allocator >
  template <class T0, class Storage0, class Allocator0>
  void Vector<T, Collection, Allocator>
  ::SetVector(string name, const Vector<T0,
              Storage0, Allocator0>& vector)
  {
    map<string,int>::iterator label_iterator;
    label_iterator = label_map_.find(name);
    if (label_iterator == label_map_.end())
      throw WrongArgument("VectorCollection::SetVector(string name, Vector)",
                          string("Unknown vector name: \"") + name + "\".");
    SetVector(label_iterator->second, vector);
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>
  ::SetName(int i, string name)
  {
 
#ifdef SELDON_CHECK_BOUNDS
    if (i < 0 || i >= Nvector_)
      throw WrongIndex("VectorCollection::SetName(int i, string name)",
                       string("Index should be in [0, ")
                       + to_str(Nvector_ - 1)
                       + "], but is equal to " + to_str(i) + ".");
#endif
 
    if (i >= int(label_vector_.size()))
      label_vector_.resize(Nvector_, "");
 
    if (label_vector_[i] != "")
      label_map_.erase(label_vector_[i]);
 
    label_vector_[i] = name;
    label_map_[name] = i;
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>
  ::SetData(const Vector<T, Collection, Allocator>& X)
  {
    Clear();
    for (int i = 0; i < X.GetNvector(); i++)
      AddVector(X.GetVector(i));
    label_map_.insert(X.label_map_.begin(), X.label_map_.end());
    label_vector_.assign(X.label_vector_.begin(), X.label_vector_.end());
  }
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>::Nullify()
  {
    for (int i = 0; i < Nvector_; i++)
      vector_(i).Nullify();
    for (int i = 0; i < Nvector_; i++)
      length_(i) = length_sum_(i) = 0;
  }
 
  
  // CONVENIENT METHOD //
 
 
 
  template <class T, class Allocator>
  template <class T0>
  void Vector<T, Collection, Allocator>::Fill(const T0& x)
  {
    for (int i = 0; i < Nvector_; i++)
      vector_(i).Fill(x);
  }
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>::Print() const
  {
    for (int i = 0; i < GetNvector(); i++)
      {
        if (i < int(label_vector_.size()) && label_vector_[i] != "")
          cout << label_vector_[i] << ":" << endl;
        else
          cout << "(noname):" << endl;
        vector_(i).Print();
      }
    cout << endl;
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>
  ::Write(string FileName, bool with_size) const
  {
    ofstream FileStream;
    FileStream.open(FileName.c_str(), ofstream::binary);
 
#ifdef SELDON_CHECK_IO
    // Checks if the file was opened.
    if (!FileStream.is_open())
      throw IOError("Vector<Collection>::Write(string FileName)",
                    string("Unable to open file \"") + FileName + "\".");
#endif
 
    this->Write(FileStream, with_size);
 
    FileStream.close();
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>
  ::Write(ostream& FileStream, bool with_size) const
  {
 
#ifdef SELDON_CHECK_IO
    // Checks if the stream is ready.
    if (!FileStream.good())
      throw IOError("Vector<Collection>::Write(ostream& FileStream)",
                    "The stream is not ready.");
#endif
    if (with_size)
      FileStream
        .write(reinterpret_cast<char*>(const_cast<int*>(&this->m_)),
               sizeof(int));
 
    for (int i = 0; i < GetNvector(); i++)
      vector_(i).Write(FileStream, false);
 
#ifdef SELDON_CHECK_IO
    // Checks if data was written.
    if (!FileStream.good())
      throw IOError("Vector<Collection>::Write(ostream& FileStream)",
                    "Output operation failed.");
#endif
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>
  ::WriteText(string FileName) const
  {
    ofstream FileStream;
    FileStream.precision(cout.precision());
    FileStream.flags(cout.flags());
    FileStream.open(FileName.c_str());
 
#ifdef SELDON_CHECK_IO
    // Checks if the file was opened.
    if (!FileStream.is_open())
      throw IOError("Vector<Collection>::WriteText(string FileName)",
                    string("Unable to open file \"") + FileName + "\".");
#endif
 
    this->WriteText(FileStream);
 
    FileStream.close();
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>
  ::WriteText(ostream& FileStream) const
  {
 
#ifdef SELDON_CHECK_IO
    // Checks if the stream is ready.
    if (!FileStream.good())
      throw IOError("Vector<Collection>::Write(ostream& FileStream)",
                    "The stream is not ready.");
#endif
 
    for (int i = 0; i < GetNvector(); i++)
      vector_(i).WriteText(FileStream);
 
#ifdef SELDON_CHECK_IO
    // Checks if data was written.
    if (!FileStream.good())
      throw IOError("Vector<Collection>::Write(ostream& FileStream)",
                    "Output operation failed.");
#endif
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>::Read(string FileName)
  {
    ifstream FileStream;
    FileStream.open(FileName.c_str(), ifstream::binary);
 
#ifdef SELDON_CHECK_IO
    // Checks if the file was opened.
    if (!FileStream.is_open())
      throw IOError("Vector<Collection>::Read(string FileName)",
                    string("Unable to open file \"") + FileName + "\".");
#endif
 
    Vector<int> length;
    length.Read(FileStream);
 
    this->Read(FileStream, length);
 
    FileStream.close();
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>
  ::Read(string FileName, Vector<int, VectFull, MallocAlloc<int> >& length)
  {
    ifstream FileStream;
    FileStream.open(FileName.c_str(), ifstream::binary);
 
#ifdef SELDON_CHECK_IO
    // Checks if the file was opened.
    if (!FileStream.is_open())
      throw IOError("Vector<Collection>::Read(string FileName)",
                    string("Unable to open file \"") + FileName + "\".");
#endif
 
    this->Read(FileStream, length);
 
    FileStream.close();
  }
 
 
 
  template <class T, class Allocator >
  void Vector<T, Collection, Allocator>
  ::Read(istream& FileStream,
         Vector<int, VectFull, MallocAlloc<int> >& length)
  {
 
#ifdef SELDON_CHECK_IO
    // Checks if the stream is ready.
    if (!FileStream.good())
      throw IOError("Vector<Collection>::Read(istream& FileStream)",
                    "The stream is not ready.");
#endif
 
    T working_vector;
    working_vector.Read(FileStream);
 
    Vector<int, VectFull, MallocAlloc<int> > length_sum;
    int Nvector;
 
    Clear();
    Nvector = length.GetSize();
    length_sum.Reallocate(Nvector);
    length_sum(0) = length(0);
    for (int i = 1; i < Nvector; i++)
      length_sum(i) = length_sum(i - 1) + length(i);
 
    T U, V;
    U.SetData(length(0), &working_vector.GetData()[0]);
    V.Copy(U);
    AddVector(V);
    U.Nullify();
    V.Nullify();
    for (int i = 1; i < Nvector; i++)
      {
        U.SetData(length(i), &working_vector.GetData()[length_sum(i - 1)]);
        V.Copy(U);
        AddVector(V);
        U.Nullify();
        V.Nullify();
      }
 
#ifdef SELDON_CHECK_IO
    // Checks if data was read.
    if (!FileStream.good())
      throw IOError("Vector<Collection>::Read(istream& FileStream)",
                    "Input operation failed.");
#endif
 
  }
 
 
 
  template <class T, class Allocator>
  ostream&  operator <<
  (ostream& out, const Vector<T, Collection, Allocator>& V)
  {
    for (int i = 0; i < V.GetNvector() - 1; i++)
      out << V.GetVector(i) << '\t';
    if (V.GetNvector() != 0)
      out << V.GetVector(V.GetNvector() - 1);
    return out;
  }
 
 
} // namespace Seldon.
 
 
#define SELDON_FILE_VECTOR_VECTORCOLLECTION_CXX
#endif