Vector.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2, 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 General Public License for more details.

//  You should have received a copy of the GNU 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.  

//  $Id: Vector.hpp,v 1.9 2007/05/20 23:02:48 delpinux Exp $


#ifndef VECTOR_HPP
#define VECTOR_HPP

// Include STD definitions to get same environment ...
#include <stddef.h>
#include <cstdlib>
#include <Assert.hpp>

#include <ZoneCopy.hpp>

#include <iostream>

#include <BaseVector.hpp>
#include <TermToTerm.hpp>

template <typename T>
class Vector
  : public BaseVector
{
public:
  typedef T ValueType;
protected:
  size_t __size;

  T* __restrict __values;

public:
  inline const size_t& size() const
  {
    return __size;
  }

  inline size_t number(T const& e) const
  {
    ASSERT ((&e >= __values)&&(static_cast<size_t>(&e-__values) < __size));
    return (&e-__values);
  }

  friend std::ostream& operator << (std::ostream& os, const Vector<T>& V)
  {
    for (size_t i=0; i<V.size(); ++i) {
      os << V[i] << '\n';
    }
    return os;
  }

  inline const T& operator[](const size_t& i) const
  {
    ASSERT (i<__size);
    return __values[i];
  }

  inline T& operator[](const size_t& i)
  {
    ASSERT (i<__size);
    return __values[i];
  }

  inline const T& operator()(const size_t& i) const
  {
    ASSERT (i<__size);
    return __values[i];
  }

  inline T& operator()(const size_t& i)
  {
    ASSERT (i<__size);
    return __values[i];
  }

  void resize(const size_t& newSize)
  {
    ASSERT (newSize>=0);

    if (newSize != __size) {
      if (__size!=0)    {               // Destroy previous vector
        delete [] __values;
      }
      __size = newSize;
      __values = new ValueType[__size];
    } else {
      ;                         // else do nothing
    }
  }

  inline const Vector<T>& operator=(const T& t)
  {
    for (size_t i=0; i<__size; ++i)
      __values[i] = t;
    return (*this);
  }

  inline const Vector<T>& operator=(const Vector<T>& V)
  {
    ASSERT (__size == V.__size);
    ZoneCopy(__values, V.__values, __size);

    return (*this);
  }


  inline Vector<T> operator*(const T& t) const
  {
    Vector<T> prod(*this);
    TermToTermProduct<T> tttp;
    for (size_t i=0; i<__size; ++i)
      prod.__values[i] = tttp(__values[i],t);
    return prod;
  }


  friend Vector<T> operator*(const T& t, const Vector<T>& V)
  {
    Vector<T> sum(V.__size);
    TermToTermProduct<T> tttp;
    for (size_t i=0; i<V.__size; ++i)
      sum.__values[i] = tttp(V.__values[i],t);

    return sum;
  }


  template <class T2>
  inline const Vector<T>& operator*=(const T2& t)
  {
    TermToTermProduct<T> tttp;
    for (size_t i=0; i<__size; ++i)
      __values[i] = tttp(__values[i],t);
    return *this;
  }

  inline Vector<T> operator+(const Vector<T>& V) const
  {
    ASSERT(__size==V.__size);
    Vector<T> W(__size);
    for (size_t i=0; i<__size; ++i)
      W.__values[i] = __values[i] + V.__values[i];
    return W;
  }

  inline Vector<T> operator-(const Vector<T>& V) const
  {
    ASSERT(__size==V.__size);

    Vector<T> W(__size);
    for (size_t i=0; i<__size; ++i) {
      W.__values[i] = __values[i] - V.__values[i];
    }

    return W;
  }


  inline const Vector<T>& operator+=(const Vector<T>& V)
  {
    ASSERT(__size==V.__size);

    for (size_t i=0; i<__size; ++i)
      __values[i] += V.__values[i];

    return *this;
  }

  inline const Vector<T>& operator+=(const T& t)
  {
    for (size_t i=0; i<__size; ++i)
      __values[i] += t;

    return *this;
  }

  inline const Vector<T>& operator-=(const Vector<T>& V)
  {
    ASSERT(__size==V.__size);

    for (size_t i=0; i<__size; ++i)
      __values[i] -= V.__values[i];

    return (*this);
  }
 
  inline real_t operator*(const Vector<T>& V) const
  {
    ASSERT(__size==V.__size);

    real_t t = 0;
    for (size_t i=0; i<__size; ++i)
      t += __values[i] * V.__values[i];

    return t;
  }

  inline friend real_t Norm(const Vector<T>& v)
  {
    return sqrt(v*v);
  }


  Vector()
    : __size(0)
  {
    ;
  }

  Vector(size_t size)
    : __size(size)
  {
    if (__size>0)
      __values = new T[__size];
  }

  Vector(const Vector<T>& V)
    : __size(V.__size)
  {
    if (__size>0)
      __values = new T[__size];
    ZoneCopy(__values,V.__values,__size);
  }

  ~Vector()
  {
    if (__size > 0)
      delete[] __values;
  }
};

#endif // VECTOR_HPP

---