array.h

Go to the documentation of this file.

/* Copyright (C) 2001-2012 Stefan Buehler <sbuehler@ltu.se>

   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. */

#ifndef array_h
#define array_h

#include <vector>
#include <iostream>
#include <iomanip>
#include <cassert>
#include <climits>
#include "matpack.h"


// Declare the existance of class Array:
template<class base>
class Array;

typedef Array<Index> ArrayOfIndex;

typedef Array<ArrayOfIndex> ArrayOfArrayOfIndex;

typedef Array<Numeric> ArrayOfNumeric;

// Declare the existance of Vector/Matrix/Tensor classes:
class Vector;
class Matrix;
class Sparse;
class Tensor3;
class Tensor4;
class Tensor5;
class Tensor6;
class Tensor7;

typedef Array<Vector> ArrayOfVector;

typedef Array<ArrayOfVector> ArrayOfArrayOfVector;

typedef Array<Matrix> ArrayOfMatrix;

typedef Array<ArrayOfMatrix> ArrayOfArrayOfMatrix;

typedef Array<Sparse> ArrayOfSparse;

typedef Array<Tensor3> ArrayOfTensor3;

typedef Array<ArrayOfTensor3> ArrayOfArrayOfTensor3;

typedef Array<Tensor4> ArrayOfTensor4;

typedef Array<ArrayOfTensor4> ArrayOfArrayOfTensor4;

typedef Array<Tensor5> ArrayOfTensor5;

typedef Array<Tensor6> ArrayOfTensor6;

typedef Array<ArrayOfTensor6> ArrayOfArrayOfTensor6;

typedef Array<Tensor7> ArrayOfTensor7;


template<class base>
class Array : public std::vector<base>
{
public:
  // Constructors:
  Array()                     : std::vector<base>()  { /* Nothing to do here. */ }
  explicit Array(Index n)     : std::vector<base>(n) { /* Nothing to do here. */ }
  Array(Index n, const base& fillvalue);
  Array(const Array<base>& A) : std::vector<base>(A) { /* Nothing to do here. */ }

  // Assignment operators:
  Array& operator=(base x);
  Array& operator=(const Array<base>& A);

  // Number of elements:
  Index nelem() const;

  // Index operators:
  const base& operator[](Index n) const;
  base& operator[](Index n);
};



// Member functions for Array:

template<class base>
inline Array<base>::Array(Index n, const base& fillvalue) :
  std::vector<base>(n)
{
  // Use fill to fill.
  fill(this->begin(),this->end(),fillvalue);
}


template<class base>
inline Array<base>& Array<base>::operator=(base x) 
{
  fill(this->begin(),this->end(),x);
  return *this;
}


template<class base>
inline Array<base>& Array<base>::operator=(const Array<base>& A)
{
  //  cout << "size this / A = " << size() << " / " << A.size() << "\n";
  this->resize(A.size());
  copy( A.begin(), A.end(), this->begin() );
  return *this;
}

template<class base>
inline Index Array<base>::nelem() const
{ 
  size_t s = this->size();
  assert(s<LONG_MAX);
  return static_cast<long>(s);
}

template<class base>
inline const base& Array<base>::operator[](Index n) const
{
  assert(0<=n);
  assert(n<nelem());
  return std::vector<base>::operator[](n);
}

template<class base>
inline base& Array<base>::operator[](Index n)
{
  assert(0<=n);
  assert(n<nelem());
  return std::vector<base>::operator[](n);
}


// Non-member functions:

template<class base>
inline std::ostream& operator<<(std::ostream& os, const Array<base>& v)
{
  typename Array<base>::const_iterator         i = v.begin();
  const typename Array<base>::const_iterator end = v.end();

  if ( i!=end )
    {
      os << std::setw(3) << *i;
      ++i;
    }

  for ( ; i!=end; ++i )
    {
      os << " " << std::setw(3) << *i;
    }

  return os;
}

template<class base>
inline base max(const Array<base>& x)
{ 
  // Initial value for max:
  base max = x[0];

  typename Array<base>::const_iterator       xi = x.begin();
  const typename Array<base>::const_iterator xe = x.end();

  for ( ; xi!=xe ; ++xi )
    {
      if ( *xi > max )
        max = *xi;
    }

  return max;
}

template<class base>
inline base min(const Array<base>& x)
{ 
  // Initial value for min:
  base min = x[0];

  typename Array<base>::const_iterator       xi = x.begin();
  const typename Array<base>::const_iterator xe = x.end();

  for ( ; xi!=xe ; ++xi )
    {
      if ( *xi < min )
        min = *xi;
    }

  return min;
}



template <class base>
Index find_first( const Array<base>& x,
                  const base& w )
{
  for ( Index i=0; i<x.nelem(); ++i )
    if ( w == x[i] )
      return i;

  return -1;
}


template <class base>
void find_all( ArrayOfIndex&      pos,
               const Array<base>& x,
               const base&        w )
{
  pos.resize(0);
  for ( Index i=0; i<x.nelem(); ++i )
    if ( w == x[i] )
      pos.push_back(i);
}



// It is not a good idea to put all the predefined array types in one
// place. If I do this than a file cannot use one without defining all
// the others.

#endif  // array_h