STK_Vector.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2007  Serge Iovleff

    This program 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 of the
    License, or (at your option) any later version.

    This program 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 this program; if not, write to the
    Free Software Foundation, Inc.,
    59 Temple Place,
    Suite 330,
    Boston, MA 02111-1307
    USA

    Contact : Serge.Iovleff@stkpp.org
*/

/*
 * Project:  Astkpp::rrays
 * Purpose:  Define the Vector class.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/


#ifndef STK_VECTOR_H
#define STK_VECTOR_H

#include "../../STKernel/include/STK_Real.h"
#include "STK_Array1D.h"

namespace STK
{

typedef Array1D<Real> Vector;

template<>
class Array1D<Real> : public RecursiveArray1D< Real, Array1D<Real> >
{
  typedef AllocatorBase<Real*> _AllocatorBaseType_;
  typedef RecursiveArray1D<Real, Array1D<Real> > _RecArray1DType_;

  public:
    Array1D( Range const& I = Range())
          : _RecArray1DType_(I)
    { ;}

    Array1D( Range const& I, Real const& v)
           : _RecArray1DType_(I)
    {
      for (Integer i=first(); i<=last(); i++)
        setData(i, v);
    }

    Array1D( const Array1D &T, bool ref =false)
           : _RecArray1DType_(T, ref)
    {
      // check if we want just a reference
      if (!ref)
      {
        for (Integer j=first(); j<=last(); j++)
          setData(j, T.data(j));
      }
    }

    Array1D( Array1D const& T, Range const& I)
           : _RecArray1DType_(T, I)
    { ;}

    Array1D( Real* q, Range const& I, Integer const& index =0)
           : _RecArray1DType_(q, I, index)
    { ;}

     Array1D( const _AllocatorBaseType_& T, Range const& I, Integer const& index)
            : _RecArray1DType_(T.data(index), I, index)
    { ;}

    virtual ~Array1D() { ;}

    inline Real& elt(Integer const& pos)
    { return this->data(pos);}

    inline Real const& elt(Integer const& pos) const
    { return this->data(pos);}

    inline Array1D elt(Range const& J) const
    {
#ifdef STK_BOUNDS_CHECK
      if ((J.first()<this->first()))
      { throw out_of_range("Array1D::elt(J) "
                                "J.first()<this->first()");
      }
      if ((J.last()>this->last()))
      { throw out_of_range("Array1D::elt(J) "
                                "J.last()>this->last()");
      }
#endif
      return Array1D(*this, J);
    }

    inline Array1D& operator=(Array1D const& T)
    {
      // check size
      if (size()!=T.size()) resize(T.range());
      // copy without ovelapping.
      if (first() < T.first())
      { for (Integer i=first(), j=T.first(); j<=T.last(); i++, j++)
          setData(i, T.data(j));
      }
      else
      { for (Integer i=last(), j=T.last(); j>=T.first(); i--, j--)
          setData(i, T.data(j));
      }
      return *this;
    }

    inline Array1D& operator=(Real const& v)
    {
      for (Integer i=first(); i<=last(); i++)
        setData(i, v);
      return *this;
    }

    inline Array1D& operator+=(Real const& v)
    {
      for (Integer i=first(); i<=last(); i++)
        elt(i) += v;
      return *this;
    }

    inline Array1D& operator-=(Real const& v)
    {
      for (Integer i=first(); i<=last(); i++)
        elt(i) -= v;
      return *this;
    }

    inline Array1D& operator/=(Real const& v)
    {
      for (Integer i=first(); i<=last(); i++)
        elt(i) /= v;
      return *this;
    }

    inline Array1D& operator*=(Real const& v)
    {
      for (Integer i=first(); i<=last(); i++)
        elt(i) *= v;
      return *this;
    }

    template <class LEAF>
    inline Array1D& operator=(const ITContainer1D<Real, LEAF> &T)
    { // We have to resize if this and T does not have the same size
      // but if they have the same size, we don't scale the index
      if (size()!=T.size()) resize(T.range());

      // copy without ovelapping
      if (first() < T.first())
      { for (Integer j=first(), i=T.first(); i<=T.last(); j++, i++)
          setData(j, T[i]);
      }
      else
      { for (Integer j=last(), i=T.last(); i>=T.first(); j--, i--)
          setData(j, T[i]);
      }
      return *this;
    }

    template< class Exp>
    inline Array1D& operator=(const Exp& rhs)
    {
      for (Integer i=first(); i<=last(); i++)
        setData(i, rhs[i]);
      return *this;
    }

    template< class Exp>
    inline Array1D& operator+=(const Exp& rhs)
    {
      for (Integer i=first(); i<=last(); i++)
        elt(i) += rhs[i];
      return *this;
    }

    template< class Exp>
    inline Array1D& operator-=(const Exp& rhs)
    {
      for (Integer i=first(); i<=last(); i++)
        elt(i) -= rhs[i];
      return *this;
    }

    template< class Exp>
    inline Array1D& operator/=(const Exp& rhs)
    {
      for (Integer i=first(); i<=last(); i++)
        elt(i) /= rhs[i];
      return *this;
    }

    template< class Exp>
    inline Array1D& operator*=(const Exp& rhs)
    {
      for (Integer i=first(); i<=last(); i++)
        elt(i) *= rhs[i];
      return *this;
    }
};

} // namespace STK

#endif
// STK_VECTOR_H