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 <array>
#include <climits>
#include <iomanip>
#include <iostream>
#include <vector>
 
#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;
struct 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<ArrayOfTensor5> ArrayOfArrayOfTensor5;
 
typedef Array<Tensor6> ArrayOfTensor6;
 
typedef Array<ArrayOfTensor6> ArrayOfArrayOfTensor6;
 
typedef Array<Tensor7> ArrayOfTensor7;
 
typedef Array<ArrayOfTensor7> ArrayOfArrayOfTensor7;
 
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. */
  }
  Array(Array<base>&& A) noexcept
      : std::vector<base>(std::move(A)) { /* Nothing to do here. */
  }
  Array(std::initializer_list<base> init)
      : std::vector<base>(init) { /* Nothing to do here. */
  }
  template <class base2, size_t N> explicit Array(const std::array<base2, N>& input)
      : std::vector<base>(input.begin(), input.end()) {
    static_assert(std::is_convertible<base, base2>::value, "Must be convertible");
  }
  Array(std::vector<base> x) : std::vector<base>(std::move(x)) {}
 
  // Assignment operators:
  Array& operator=(base x);
  Array& operator=(const Array<base>& A);
  Array& operator=(Array<base>&& A) noexcept;
 
  // Number of elements:
  [[nodiscard]] Index nelem() const ARTS_NOEXCEPT;
 
  // Index operators:
  const base& operator[](const Index n) const;
  base& operator[](const Index n);
 
  // Helper functions
  void push_back_n(const base& elem, const Index n);
 
  virtual ~Array() = default;
};
 
// Member functions for Array:
 
template <class base>
inline Array<base>::Array(Index n, const base& fillvalue)
    : std::vector<base>(n) {
  // Use fill to fill.
  std::fill(this->begin(), this->end(), fillvalue);
}
 
template <class base>
inline Array<base>& Array<base>::operator=(base x) {
  std::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());
  std::copy(A.begin(), A.end(), this->begin());
  return *this;
}
 
template <class base>
inline Array<base>& Array<base>::operator=(Array<base>&& A) noexcept {
  std::vector<base>::operator=(std::move(A));
  return *this;
}
 
template <class base>
inline Index Array<base>::nelem() const ARTS_NOEXCEPT {
  size_t s = this->size();
  ARTS_ASSERT(s < LONG_MAX);
  return static_cast<Index>(s);
}
 
template <class base>
inline const base& Array<base>::operator[](const Index n) const {
  ARTS_ASSERT(0 <= n);
  ARTS_ASSERT(n < nelem());
  return std::vector<base>::operator[](n);
}
 
template <class base>
inline base& Array<base>::operator[](const Index n) {
  ARTS_ASSERT(0 <= n);
  ARTS_ASSERT(n < nelem());
  return std::vector<base>::operator[](n);
}
 
template <class base>
inline void Array<base>::push_back_n(const base& elem, const Index n) {
  for (Index i = 0; i < n; i++) std::vector<base>::push_back(elem);
}
 
// 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);
}
 
class CmpArrayOfNumeric {
 public:
  CmpArrayOfNumeric(const ArrayOfNumeric& vec) : values(vec) {}
  bool operator()(const int& a, const int& b) const {
    return values[a] < values[b];
  }
 
  const ArrayOfNumeric& values;
};
 
template <class base>
Index TotalNumberOfElements(const Array<Array<base> >& aa) {
  Index N_aa = 0;
  for (Index i = 0; i < aa.nelem(); i++) {
    N_aa += aa[i].nelem();
  }
 
  return N_aa;
}
 
template <class base>
Index FlattenedIndex(const Array<Array<base> >& aa,
                     Index outer,
                     Index inner = 0) {
  ARTS_ASSERT(outer < aa.nelem());
  ARTS_ASSERT(inner < aa[outer].nelem());
 
  Index N = 0;
  for (Index i = 0; i < outer; i++) {
    N += aa[i].nelem();
  }
 
  return N + inner;
}
 
// 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.
 
template <typename T, typename ... Ts>
constexpr std::array<T, 1 + sizeof...(Ts)> stdarrayify(const T& first, const Ts&... the_rest)
{
  return {first, T(the_rest)...};
}
 
template <typename T>
std::string stringify(const Array<T>& list, const char * const sep=" ", const char * const beg="") {
  std::ostringstream os;
  for (auto& x: list) os << beg << x << sep;
  return os.str();
}
 
#endif  // array_h