TVec_decl.h

Go to the documentation of this file.

// -*- C++ -*-

// PLearn (A C++ Machine Learning Library)
// Copyright (C) 1998 Pascal Vincent
// Copyright (C) 1999-2002 Pascal Vincent, Yoshua Bengio and University of Montreal
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
// 
//  2. Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
// 
//  3. The name of the authors may not be used to endorse or promote
//     products derived from this software without specific prior written
//     permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// This file is part of the PLearn library. For more information on the PLearn
// library, go to the PLearn Web site at www.plearn.org


 

/* *******************************************************      
 * $Id: TVec_decl.h,v 1.16 2004/08/11 07:18:45 chapados Exp $
 * AUTHORS: Pascal Vincent & Yoshua Bengio
 * This file is part of the PLearn library.
 ******************************************************* */


#ifndef TVec_decl_INC
#define TVec_decl_INC

#include <iterator>
#include <numeric>
#include <functional>
#include <strstream>

#include <plearn/base/general.h>
#include <plearn/base/Storage.h>
#include <plearn/base/Range.h>
#include <plearn/io/plstreams.h>

namespace PLearn {
using namespace std;

// predeclarations
template<class T> class TMat;
class Variable;
class VarArray;
class QRchunker;
class QCchunker;

template <class T>
class TVec
{
  friend class TMat<T>;

  friend class Variable; 
  friend class VarArray; 

  friend class QRchunker;
  friend class QCchunker;

protected:
  int      length_;  
  int      offset_;  
  PP< Storage<T> > storage; 
public:

  typedef T value_type;
  typedef int size_type;
  typedef T* iterator;
  typedef const T* const_iterator;

  inline iterator begin() const 
    { 
      if (storage.isNull()) return 0;
      return storage->data+offset_; 
    }

  inline iterator end() const 
    { return begin()+length(); }

  // norman: added explicit cast before vec.size()
  //         but beware if you're creating a constructor for storage that takes size_type
  //         because int could be different from size_type!
  inline TVec(const vector<T> & vec)
    :length_((int)vec.size()), offset_(0),
     storage(new Storage<T>((int)vec.size()))
    {
      for(int i=0;i<length_;i++)
        (*this)[i]=vec[i];
    }

  inline TVec() 
    :length_(0),offset_(0)
    {}

  inline explicit TVec(int the_length) 
    :length_(the_length), offset_(0),
     storage(new Storage<T>(the_length))
    {}

  inline TVec(int the_length, const T& init_value) 
    :length_(the_length), offset_(0),
     storage(new Storage<T>(the_length))
    { fill(init_value); }

  TVec(const T& start, const T& stop, const T& step);

  inline TVec(int the_length, T* the_data)
    :length_(the_length), offset_(0),
     storage(new Storage<T>(the_length, the_data))
    {}

  inline TVec(const TVec<T>& other)
    :length_(other.length()), offset_(other.offset()),
     storage(other.storage)
    {}

  inline const TVec<T>& operator=(const TVec<T>& other)
    {
      storage = other.storage;
      length_ = other.length_;
      offset_ = other.offset_;
      return *this;
    }

  operator vector<T>() const
    {    
      int n = length_;
      vector<T> res(n);
      if(n>0)
      {
        T* ptr = data();
        for(int i=0; i<n; i++)
          res[i] = *ptr++;
      }
      return res;
    }

  bool hasMissing() const
    {
      iterator it = begin();
      iterator itend = end();
      for(; it!=itend; ++it)
        if(is_missing(*it))
          return true;
      return false;
    }

  inline int size() const { return length_; }
  inline int length() const { return length_; }
  inline int capacity() const { return storage.isNotNull() ? storage->length()-offset_ : 0; }
  inline int offset() const { return offset_; }

  inline PP< Storage<T> > getStorage() const { return storage; }

  void compact()
    {
      if(storage && storage->length() != length())
      {
        if(storage->usage()>1)
          PLERROR("IN Mat::compact() compact operation not allowed when matrix storage is shared (for obvious reasons)");
        operator=(copy());
      }
    }

  inline operator char*() const { if(isNull()) return 0; else return (char*)data(); }

  // norman: removed const. With inline is useless (and .NET doesn't like it)
  // Old code:
  //inline const size_t byteLength() const { return length()*sizeof(T); }
  inline size_t byteLength() const { return length()*sizeof(T); }

  inline void resize(int newlength, int extrabytes=0)
    {
#ifdef BOUNDCHECK
      if (newlength<0 || extrabytes<0)
        PLERROR("IN TVec::resize(int newlength)\nInvalid argument (<0)");
#endif
      if (newlength == length_) {
        // No need to do anything.
        return;
      }
      if (storage.isNull() && newlength>0)
      {
        offset_ = 0;
        length_ = newlength;
        Storage<T>* s = new Storage<T>(newlength + extrabytes);          
        storage = s;
      }
      else
      {
        if (storage.isNotNull() && (newlength > capacity()))
          storage->resize (offset_ + newlength + extrabytes);
        length_ = newlength;
      }
    }

  void write(PStream& out) const
    {
      const TVec<T>& v = *this; // simple alias
      if(storage && 
         ( out.implicit_storage 
           || out.outmode==PStream::raw_ascii
           || out.outmode==PStream::raw_binary
           || out.outmode==PStream::pretty_ascii ) )
        writeSequence(out,v);
      else // write explicit storage
      {
        out.write("TVec("); 
        out << v.length();
        out << v.offset();
        out << v.getStorage();
        out.write(")\n");
      }
    }

  void read(PStream& in)
    {
      TVec<T>& v = *this; // simple alias
      switch(in.inmode)
      {
      case PStream::raw_ascii:
      case PStream::raw_binary:      
        readSequence(in, v);

      case PStream::plearn_ascii:
      case PStream::plearn_binary:
      {
        in.skipBlanksAndComments();
        int c = in.peek();
        if(c!='T') // implicit storage
          readSequence(in,v);
        else // explicit storage
        {
          char word[6];
          // !!!! BUG: For some reason, this hangs!!!
          // in.read(word,5);
          for(int i=0; i<5; i++)
            in.get(word[i]);
          word[5]='\0';
          if(strcmp(word,"TVec(")!=0)
            PLERROR("In operator>>(PStream&, TVec&) '%s' not a proper header for a TVec!",word);
          // v.storage = 0;
          in.skipBlanksAndCommentsAndSeparators();
          in >> v.length_;
          in.skipBlanksAndCommentsAndSeparators();
          in >> v.offset_;
          in.skipBlanksAndCommentsAndSeparators();
          in >> v.storage;
          in.skipBlanksAndCommentsAndSeparators();
          int c = in.get(); // skip ')'
          if(c!=')')
            PLERROR("In operator>>(PStream&, TVec&) expected a closing parenthesis, found '%c'",c);
        }
      }
      break;
      
      default:
        PLERROR("In TVec<T>::read(PStream& in)  unknown inmode!!!!!!!!!");
        break;
      }
    }

  // The following methods are deprecated, and just call corresponding functions.
  // Please call those functions directly in new code
  void save(const string& filename) const { savePVec(filename, *this); }
  void load(const string& filename) { loadPVec(filename, *this); }
    
  TVec<T> subVec(int newstart, int newlength) const
    {
#ifdef BOUNDCHECK
      if(newstart+newlength>length() || newlength<0)
        PLERROR("TVec::subVec(int newstart, int newlength) OUT OF BOUNDS OR <0 length()"
                " length()=%d; newstart=%d; newlength=%d.", length(), newstart, newlength);
#endif
      TVec<T> subv = *this;
      subv.length_ = newlength;
      subv.offset_ += newstart;
      return subv;
    }

  void makeDeepCopyFromShallowCopy(map<const void*, void*>& copies);

  TVec<T> deepCopy(map<const void*, void*>& copies) const;


  inline TVec<T> subVec(Range r) { return subVec(r.start, r.length); }
    
  void concat(const TVec<T>& input1, const TVec<T>& input2)
    {  
      int l1 = input1.length();
      int l2 = input2.length();
      resize(l1+l2);
      for(int i=0;i<l1;i++) (*this)[i] = input1[i];
      for(int i=0;i<l2;i++) (*this)[l1+i] = input2[i];
    }

  void concat(const TVec<T>& input1, const TVec<T>& input2, const TVec<T>& input3)
    {
      int l1 = input1.length();
      int l2 = input2.length();
      int l3 = input3.length();
      resize(l1+l2+l3);
      for(int i=0;i<l1;i++) (*this)[i] = input1[i];
      for(int i=0;i<l2;i++) (*this)[l1+i] = input2[i];
      for(int i=0;i<l3;i++) (*this)[l1+l2+i] = input3[i];
    }

  void concat(const TVec<T>& input1, const TVec<T>& input2, const TVec<T>& input3, const TVec<T>& input4)
    {
      int l1 = input1.length();
      int l2 = input2.length();
      int l3 = input3.length();
      int l4 = input4.length();
      resize(l1+l2+l3+l4);
      for(int i=0;i<l1;i++) (*this)[i] = input1[i];
      for(int i=0;i<l2;i++) (*this)[l1+i] = input2[i];
      for(int i=0;i<l3;i++) (*this)[l1+l2+i] = input3[i];
      for(int i=0;i<l4;i++) (*this)[l1+l2+l3+i] = input4[i];
    }

  inline TMat<T> toMat(int newlength, int newwidth) const;

  inline TVec<T> copy() const
    {
      TVec<T> freshcopy(length());
      freshcopy << *this;
      return freshcopy;
    }

  void copyFrom(const T* x, int n) const
    {  
#ifdef BOUNDCHECK
      if(n != length())
        PLERROR("IN TVec::copyFrom(T* x, int n)\nVecs do not have the same length()");
#endif
      T* v1 = data(); 
      for(int i=0; i<n; i++)
        v1[i] = x[i];
    }

  void copyTo(T* x) const
    {
      T* v1 = data(); // get data start
      for(int i=0; i<length(); i++)
        x[i] = v1[i];
    }

  void makeSharedValue(T* x, int n)
    {
#ifdef BOUNDCHECK
      if(n != length())
        PLERROR("IN TVec::makeSharedValue(T* x, int n)\nn(%d)!=length_(%d)",
                n,length());
#endif
      T* v = data(); 
      for(int i=0; i<n; i++)
        x[i] = v[i];
      storage->pointTo(n,x);
    }

  bool isNull() const 
    { return storage.isNull(); }

  bool isNotNull() const
    { return storage.isNotNull(); }

  bool isEmpty() const
    { return length_==0; }

  bool isNotEmpty() const
    { return length_!=0; }
      
  /*
  operator bool() const
  { return isNotEmpty(); }
  */
      
  bool operator!() const
    { return isEmpty(); }

  // for compatibility with Array
  TVec<T>* operator->()
    { return this; }

  inline void fill(const T& value) const
    {
      if (storage)
        fill_n(data(), length(), value);
    }

  void fill(const T& startval, const T& step)
    {
      iterator it = begin();
      iterator itend = end();
      for(T val=startval; it!=itend; ++it, val+=step)
        *it = val;
    }

  inline void operator=(const T& f) const
  { fill(f); }

  inline void clear() const
    { if(!isNull()) clear_n(data(),length()); }

  inline void insert(int position, T value)
    {
#ifdef BOUNDCHECK
      if(position<0 || position>length())
        PLERROR("OUT OF BOUNDS in TVec::insert");
#endif
      resize(length()+1);
      T* v = data();
      for(int i=length()-1; i>position; i--)
        v[i] = v[i-1];
      v[position] = value;
    }

  inline void remove(int position)
    {
#ifdef BOUNDCHECK
      if(position<0 || position>=length())
        PLERROR("OUT OF BOUNDS in Vec::remove");
#endif
      T* v = data();
      for(int i=position; i<length()-1; i++)
        v[i] = v[i+1];
      resize(length()-1);
    }

  int findSorted(T value)
    {
      if (isEmpty())
        return 0;
 
      pair<iterator, iterator> range =
        equal_range(begin(), end(), value);
        
      return int(range.first - begin());
    }
  
  inline void insertSorted(T value, bool uniq)
    {
      int i = findSorted(value);
      if(!uniq || i==length() || (*this)[i]!=value)
        insert(i,value);
    }

  inline void removeSorted(T value)
    {
      int i = findSorted(value);
      if(i<length() && (*this)[i]==value)
        remove(i);
    }


  inline void append(const T& newval)
    {
      resize(length()+1, length());
      lastElement() = newval;
    }

  void append(const vector<T>& newvec)
    {
      int currentsize = length();
      if (currentsize + newvec.size() == 0)
        return;
      resize(currentsize + newvec.size());
      T* v = data();
      for (unsigned int i=0; i<newvec.size(); ++i)
        v[currentsize+i] = newvec[i];
    }

  inline void appendIfNotThereAlready(const T& newval)
    {
      T* v = data();
      for (int i=0;i<length();i++)
        if (newval==v[i]) return;
      append(newval);
    }

  inline void push_back(const T& newval)
    { append(newval); }

  inline void pop_back()
    {
      if(length_ <= 0)
        PLERROR("In TVec::pop_back already empty!");
      length_ -= 1; 
    } 

  inline void push(const T& newval)
    { append(newval); }
    
  inline T pop()
    { T res = lastElement(); pop_back(); return res; }

  inline T& top() const
    { return lastElement(); }

  inline void append(const TVec<T>& values)
    {
      int oldLength = length();
      if (values.length() == 0)
        return;
      resize(oldLength+values.length());
      T* v = data()+oldLength;
      T* newv = values.data();
      for(int i=0; i<values.length(); i++)
        v[i] = newv[i];
    }

  inline T& operator[](int i) const
    {
#ifdef BOUNDCHECK
      if(i<0 || i>=length())
        PLERROR("OUT OF BOUND ACCESS %d IN TVec(%d)::operator[]",i,length());
#endif
      return storage->data[i+offset_]; 
    }

  // norman: added operator[] for unsigned int
  inline T& operator[](unsigned int i) const
    {
#ifdef BOUNDCHECK
      // norman: added explicit cast
      if(i<0 || i>=(unsigned int)length())
        PLERROR("OUT OF BOUND ACCESS %d IN TVec(%d)::operator[]",i,length());
#endif
      return storage->data[i+offset_]; 
    }

  inline T& lastElement() const
    { return storage->data[offset_+length()-1]; }

  inline T& firstElement() const
    { return storage->data[offset_]; }

  inline T& front() const { return firstElement(); }
  inline T& back() const { return lastElement(); }

  // for compatibility with Array
  inline T& first() const { return firstElement(); }
  inline T& last() const { return lastElement(); }


  template<class I>
  inline void operator()(const TVec<I>& indices, TVec<T>& destination) const
    { selectElements(*this, indices, destination); }

  template<class I>
  inline TVec<T> operator()(const TVec<I>& indices) const
    {
      TVec<T> result(indices.length());
      selectElements(*this, indices, result);
      return result;
    }

  inline T* data() const
    {
#ifdef BOUNDCHECK
      if(storage.isNull())
        PLERROR("IN TVec::operator()\nAttempted to get a pointer to the data of an empty TVec");
#endif
      return storage->data+offset_; 
    }

  inline void swap()
    {
      int half = length()/2;
      T* ptr = data();
      for(int i=0; i<half; i++)
        std::swap(ptr[i],ptr[length()-i-1]);
    }

  TVec<bool> operator==(const T& value) const
    {
      TVec<bool> r(length(), false);
      //elementsEqualTo(*this,value,r);
      for (int i=0; i<length(); i++)
      {
        if ((*this)[i] == value) r[i] = true;
      }
      return r;
    }

  bool operator==(const TVec<T>& value) const
    {
      if (value.isEmpty() && isEmpty()) return true;
      if (value.length()!=length()) return false;
      T* x=data();
      T* y=value.data();
      for (int i=0;i<length();i++)
        if (x[i]!=y[i]) return false;
      return true;
    }
  bool operator!=(const TVec<T>& value) const { return !((*this)==value); }

  bool contains(const T& element) const
    {
      if (length()==0) return false;
      bool contained=false;
      T *v = data(); 
      for (int i=0; i<length() && !contained; i++)
        if (v[i]==element)
          contained=true;
      return contained;
    }

  TVec<T> findIndices(const T& element)
    {
      TVec<T> indices(0);
      if (!isEmpty())
      {
        T *v = data();
        for (int i=0; i<length(); i++)
          if (v[i]==element)
            indices.append(i);
      }
      return indices;
    }
 
  TVec<T> findIndices(const TVec<T>& elements)
    {
      TVec<T> indices(0);
      if (!isEmpty())
      {
        T *v = data();
        for (int i=0; i<length(); i++)
          for (int j=0, m=elements.length(); j<m; j++)
            if (v[i] == elements[j])
            {
              indices.append(i);
              break;
            }
      }
      return indices;
    }
 
  int find(const T& element, int start=0) const
    {
      if (length()==0) return -1;
      T *v = data();
      for (int i=start; i<length(); i++)
        if(v[i]==element)
          return i;
      return -1;
    }

  TVec<T> find(TVec<T> elements)
    {
      TVec<T> indices(elements.length(),-1);
      if (length()==0) return indices;
      T *v = data();
      for (int i=0, m=elements.length(); i<m; i++)
        for (int j=0; j<length(); j++)
          if (v[j] == elements[i])
          {
            indices[i] = j;
            break;
          }
      return indices;
    }

  void print(ostream& out = cout) const; 
  void println(ostream& out = cout) const { print(out); out<<endl; } 
  void printcol(ostream& out = cout) const; 
  void print(ostream& out, const string& separator) const; 

  void input(istream& in=cin) const;

  // calls print with cerr, usefull with gdb (> call obj.debugprint() )
  void debugPrint(){print(cerr);}


  void operator<<(const string& datastring) const
    {
      istrstream in(datastring.c_str());
      input(in);
    }

};

typedef TVec<real> Vec;

inline void operator<<(const Vec& v, real f)
{ v.fill(f); }

template<class T>
class TypeTraits< TVec<T> >
{
public:
  static inline string name()
    { return string("TVec< ") + TypeTraits<T>::name()+" >"; }

  static inline unsigned char little_endian_typecode()
    { return 0xFF; }

  static inline unsigned char big_endian_typecode()
    { return 0xFF; }
};


} // end of namespace PLearn


#endif

---