FixedArray.h

Go to the documentation of this file.

// -*- C++ -*-

// CONTINUE: If I make most of the functions free, I could remove the class
// specializations for 1, 2 and 3.  I would just keep specializations of
// the free functions.

#if !defined(__FixedArray_h__)
#define __FixedArray_h__

#if defined(DEBUG_ads) && !defined(DEBUG_FixedArray)
#define DEBUG_FixedArray
#endif

#include "ArrayTypes.h"

#include "../algorithm/is_sorted.h"

#include "../../third-party/loki/static_check.h"

#include <iostream>
#include <functional>
#include <algorithm>
#include <limits>
#include <numeric>
#include <cmath>

#include <cassert>

BEGIN_NAMESPACE_ADS

template<int N, typename T = double, bool A = true>
class Array;


template<int N, typename T = double>
class FixedArray {
  //
  // Private types.
  //

private:

  typedef ArrayTypes<T> Types;

  //
  // Public types.
  //

public:

  //--------------------------------------------------------------------------
  // @{

  typedef typename Types::value_type value_type;
  typedef typename Types::parameter_type parameter_type;
  typedef typename Types::pointer pointer;
  typedef typename Types::const_pointer const_pointer;
  typedef typename Types::iterator iterator;
  typedef typename Types::const_iterator const_iterator;
  typedef typename Types::reference reference;
  typedef typename Types::const_reference const_reference;

  typedef typename Types::size_type size_type;
  typedef typename Types::difference_type difference_type;


private:

  //
  // Data
  //

  value_type _data[N];

public:

  //--------------------------------------------------------------------------
  // @{

  FixedArray() {
    LOKI_STATIC_CHECK(N > 3, dimension_greater_than_3);
  }

  ~FixedArray() {
    LOKI_STATIC_CHECK(N > 3, dimension_greater_than_3);
  }

  FixedArray(const FixedArray& x) {
    LOKI_STATIC_CHECK(N > 3, dimension_greater_than_3);
    std::copy(x.begin(), x.end(), _data);
  }

  template<typename T2> 
  FixedArray(const FixedArray<N,T2>& x) {
    LOKI_STATIC_CHECK(N > 3, dimension_greater_than_3);
    for (int n = 0; n != N; ++n) {
      _data[n] = static_cast<value_type>(x[n]);
    }
  }

  explicit 
  FixedArray(parameter_type x);

  explicit
  FixedArray(const const_pointer p) {
    copy(p, p + N);
  }

  FixedArray(const void* p) {
    copy(static_cast<const_pointer>(p), 
         static_cast<const_pointer>(p) + N);
  }


  FixedArray(parameter_type x0, parameter_type x1);
  // This function is intentionally left undefined for the general case.
  // It is only defined in the specialization for N == 2.


  FixedArray(parameter_type x0, parameter_type x1, 
             parameter_type x2);
  // This function is intentionally left undefined for the general case.
  // It is only defined in the specialization for N == 3.


  FixedArray(parameter_type x0, parameter_type x1, 
             parameter_type x2, parameter_type x3);


  FixedArray(parameter_type x0, parameter_type x1, 
             parameter_type x2, parameter_type x3, 
             parameter_type x4);


  FixedArray(parameter_type x0, parameter_type x1, 
             parameter_type x2, parameter_type x3, 
             parameter_type x4, parameter_type x5);


  FixedArray(parameter_type x0, parameter_type x1, 
             parameter_type x2, parameter_type x3, 
             parameter_type x4, parameter_type x5, 
             parameter_type x6);


  FixedArray(parameter_type x0, parameter_type x1, 
             parameter_type x2, parameter_type x3, 
             parameter_type x4, parameter_type x5, 
             parameter_type x6, parameter_type x7);

  // @}
  //--------------------------------------------------------------------------
  // @{

  FixedArray& 
  operator=(const FixedArray& x);

  template<typename T2> 
  FixedArray& 
  operator=(const FixedArray<N,T2>& x);

  template<typename T2, bool A>
  FixedArray& 
  operator=(const Array<1, T2, A>& x);

  FixedArray& 
  operator=(parameter_type x);

  // @}
  //--------------------------------------------------------------------------
  // @{

  static
  size_type
  size() { 
    return N; 
  }

  static
  bool
  empty() { 
    // I do this because there is a specialization for N = 0.
    return false;
  }

  static
  size_type
  max_size() { 
    return std::numeric_limits<int>::max() / sizeof(value_type); 
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  const_iterator 
  begin() const { 
    return _data; 
  }

  const_iterator 
  end() const { 
    return _data + N; 
  }

  const_pointer 
  data() const { 
    return _data; 
  }

  parameter_type
  operator()(const int i) const {
#ifdef DEBUG_FixedArray
    assert(0 <= i && i < N);
#endif
    return _data[i];
  }

  parameter_type
  operator[](const int i) const {
#ifdef DEBUG_FixedArray
    assert(0 <= i && i < N);
#endif
    return _data[i];
  }


  template<typename EqualityComparable>
  const_iterator
  find(const EqualityComparable& x) const {
    return std::find(begin(), end(), x);
  }


  template<typename EqualityComparable>
  int
  find_index(const EqualityComparable& x) const {
    return int(find(x) - begin());
  }

  template<typename EqualityComparable>
  bool
  has(const EqualityComparable& x) const {
    return find(x) != end();
  }

  bool
  is_sorted() const;

  template<class StrictWeakOrdering>
  bool
  is_sorted(StrictWeakOrdering comp) const;

  int
  min_index() const;

  template<class StrictWeakOrdering>
  int
  min_index(StrictWeakOrdering comp) const;

  int
  max_index() const;

  template<class StrictWeakOrdering>
  int
  max_index(StrictWeakOrdering comp) const;

  // @}
  //--------------------------------------------------------------------------
  // @{

  iterator 
  begin() { 
    return _data; 
  }

  iterator 
  end() { 
    return _data + N; 
  }

  pointer 
  data() { 
    return _data; 
  }

  reference
  operator()(const int i) { 
#ifdef DEBUG_FixedArray
    assert(0 <= i && i < N);
#endif
    return _data[i];
  }

  reference
  operator[](const int i) {
#ifdef DEBUG_FixedArray
    assert(0 <= i && i < N);
#endif
    return _data[i];
  }

  void
  swap(FixedArray& x) {
    std::swap_ranges(begin(), end(), x.begin());
  }


  template<typename EqualityComparable>
  iterator
  find(const EqualityComparable& x) {
    return std::find(begin(), end(), x);
  }

  void
  negate();

  void
  fill(parameter_type value);

  template<typename InputIterator>
  void
  copy(InputIterator start, InputIterator finish);
    
  void
  sort();

  template<class StrictWeakOrdering>
  void
  sort(StrictWeakOrdering comp);

  // @}
  //--------------------------------------------------------------------------
  // @{

  FixedArray& 
  operator+=(parameter_type x);

  FixedArray& 
  operator-=(parameter_type x);

  FixedArray& 
  operator*=(parameter_type x);

  FixedArray& 
  operator/=(parameter_type x);

  FixedArray& 
  operator%=(parameter_type x);

  FixedArray& 
  operator<<=(int offset);

  FixedArray& 
  operator>>=(int offset);

  // @}
  //--------------------------------------------------------------------------
  // @{

  template<typename T2>
  FixedArray& 
  operator+=(const FixedArray<N,T2> & x);

  template<typename T2>
  FixedArray& 
  operator-=(const FixedArray<N,T2> & x);

  template<typename T2>
  FixedArray& 
  operator*=(const FixedArray<N,T2> & x);

  template<typename T2>
  FixedArray& 
  operator/=(const FixedArray<N,T2> & x);

  template<typename T2>
  FixedArray& 
  operator%=(const FixedArray<N,T2> & x);

  // @}
};

//
// Unary Operators
//


template<int N, typename T>
inline
FixedArray<N,T>&
operator+(FixedArray<N,T>& x) {
  return x;
}
    

template<int N, typename T>
FixedArray<N,T>
operator-(const FixedArray<N,T>& x) {
  FixedArray<N,T> a(x);
  a.negate();
  return a;
}


//
// Binary Operators
//


template<int N, typename T>
inline
FixedArray<N,T>
operator+(const FixedArray<N,T>& x, 
          const typename FixedArray<N,T>::parameter_type value) {
  FixedArray<N,T> result(x);
  return result += value;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator+(const typename FixedArray<N,T>::parameter_type value, 
          const FixedArray<N,T>& x) {
  return x + value;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator+(const FixedArray<N,T>& x, const FixedArray<N,T>& y) {
  FixedArray<N,T> result(x);
  return result += y;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator-(const FixedArray<N,T>& x, 
          const typename FixedArray<N,T>::parameter_type value) {
  FixedArray<N,T> result(x);
  return result -= value;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator-(const typename FixedArray<N,T>::parameter_type value, 
          const FixedArray<N,T>& x) {
  return -(x - value);
}


template<int N, typename T>
inline
FixedArray<N,T>
operator-(const FixedArray<N,T>& x, const FixedArray<N,T>& y) {
  FixedArray<N,T> result(x);
  return result -= y;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator*(const FixedArray<N,T>& x, 
          const typename FixedArray<N,T>::parameter_type value) {
  FixedArray<N,T> result(x);
  return result *= value;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator*(const typename FixedArray<N,T>::parameter_type value, 
          const FixedArray<N,T>& x) {
  return x * value;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator*(const FixedArray<N,T>& x, const FixedArray<N,T>& y) {
  FixedArray<N,T> result(x);
  return result *= y;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator/(const FixedArray<N,T>& x, 
          const typename FixedArray<N,T>::parameter_type value) {
  FixedArray<N,T> result(x);
  return result /= value;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator/(const typename FixedArray<N,T>::parameter_type value, 
          const FixedArray<N,T>& x) {
  FixedArray<N,T> result(value);
  return result /= x;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator/(const FixedArray<N,T>& x, const FixedArray<N,T>& y) {
  FixedArray<N,T> result(x);
  return result /= y;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator%(const FixedArray<N,T>& x, 
          const typename FixedArray<N,T>::parameter_type value) {
  FixedArray<N,T> result(x);
  return result %= value;
}


template<int N, typename T>
FixedArray<N,T>
operator%(const typename FixedArray<N,T>::parameter_type value, 
          const FixedArray<N,T>& x) {
  FixedArray<N,T> result(value);
  return result %= x;
}


template<int N, typename T>
inline
FixedArray<N,T>
operator%(const FixedArray<N,T>& x, const FixedArray<N,T>& y) {
  FixedArray<N,T> result(x);
  return result %= y;
}


//
// Mathematical Functions
//


template<int N, typename T>
T
computeSum(const FixedArray<N,T>& x);
    

template<int N, typename T>
T
computeProduct(const FixedArray<N,T>& x);


template<int N, typename T>
T
computeMinimum(const FixedArray<N,T>& x);
    

template<int N, typename T>
T
computeMaximum(const FixedArray<N,T>& x);





//
// Element-wise functions.
//


template<int N, typename T>
inline
FixedArray<N,T>
computeMaximum(const FixedArray<N,T>& x, const FixedArray<N,T>& y) {
  FixedArray<N,T> z;
  for (int n = 0; n != N; ++n) {
    z[n] = std::max(x[n], y[n]);
  }
  return z;
}



template<int N, typename T>
inline
FixedArray<N,T>
computeMinimum(const FixedArray<N,T>& x, const FixedArray<N,T>& y) {
  FixedArray<N,T> z;
  for (int n = 0; n != N; ++n) {
    z[n] = std::min(x[n], y[n]);
  }
  return z;
}





//---------------------------------------------------------------------------
// Apply the standard math functions.
//---------------------------------------------------------------------------


template<int N, typename T>
inline
void
applyAbs(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::abs(*i);
  }
}


template<int N, typename T>
inline
void
applyAcos(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::acos(*i);
  }
}


template<int N, typename T>
inline
void
applyAsin(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::asin(*i);
  }
}


template<int N, typename T>
inline
void
applyAtan(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::atan(*i);
  }
}


template<int N, typename T>
inline
void
applyCeil(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::ceil(*i);
  }
}


template<int N, typename T>
inline
void
applyCos(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::cos(*i);
  }
}


template<int N, typename T>
inline
void
applyCosh(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::cosh(*i);
  }
}


template<int N, typename T>
inline
void
applyExp(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::exp(*i);
  }
}


template<int N, typename T>
inline
void
applyFloor(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::floor(*i);
  }
}


template<int N, typename T>
inline
void
applyLog(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::log(*i);
  }
}


template<int N, typename T>
inline
void
applyLog10(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::log10(*i);
  }
}


template<int N, typename T>
inline
void
applySin(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::sin(*i);
  }
}


template<int N, typename T>
inline
void
applySinh(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::sinh(*i);
  }
}


template<int N, typename T>
inline
void
applySqrt(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::sqrt(*i);
  }
}


template<int N, typename T>
inline
void
applyTan(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::tan(*i);
  }
}


template<int N, typename T>
inline
void
applyTanh(FixedArray<N,T>* x) {
  for (typename FixedArray<N,T>::iterator i = x->begin(); i != x->end(); 
       ++i) {
    *i = std::tanh(*i);
  }
}



//----------------------------------------------------------------------------
// Standard math functions.
//----------------------------------------------------------------------------


template<int N, typename T>
inline
FixedArray<N,T>
abs(FixedArray<N,T> x) {
  applyAbs(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
acos(FixedArray<N,T> x) {
  applyAcos(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
asin(FixedArray<N,T> x) {
  applyAsin(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
atan(FixedArray<N,T> x) {
  applyAtan(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
ceil(FixedArray<N,T> x) {
  applyCeil(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
cos(FixedArray<N,T> x) {
  applyCos(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
cosh(FixedArray<N,T> x) {
  applyCosh(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
exp(FixedArray<N,T> x) {
  applyExp(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
floor(FixedArray<N,T> x) {
  applyFloor(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
log(FixedArray<N,T> x) {
  applyLog(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
log10(FixedArray<N,T> x) {
  applyLog10(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
sin(FixedArray<N,T> x) {
  applySin(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
sinh(FixedArray<N,T> x) {
  applySinh(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
sqrt(FixedArray<N,T> x) {
  applySqrt(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
tan(FixedArray<N,T> x) {
  applyTan(&x);
  return x;
}


template<int N, typename T>
inline
FixedArray<N,T>
tanh(FixedArray<N,T> x) {
  applyTanh(&x);
  return x;
}


//----------------------------------------------------------------------------
// Equality Operators
//----------------------------------------------------------------------------


template<typename T1, typename T2, int N>
inline
bool
operator==(const FixedArray<N,T1>& a, const FixedArray<N,T2>& b);


template<typename T1, typename T2, int N>
inline
bool
operator!=(const FixedArray<N,T1>& a, const FixedArray<N,T2>& b)
{ 
  return !(a == b); 
}


//
// Comparison Operators
//


template<typename T1, typename T2, int N>
bool
operator<(const FixedArray<N,T1>& a, const FixedArray<N,T2>& b);


template<typename T1, typename T2, int N>
inline
bool
operator>(const FixedArray<N,T1>& a, const FixedArray<N,T2>& b)
{
  return b < a;
}


template<typename T1, typename T2, int N>
inline
bool
operator<=(const FixedArray<N,T1>& a, const FixedArray<N,T2>& b)
{
  return !(b < a);
}


template<typename T1, typename T2, int N>
inline
bool
operator>=(const FixedArray<N,T1>& a, const FixedArray<N,T2>& b)
{
  return !(a < b);
}


//
// File I/O
//


template<int N, typename T>
std::ostream&
operator<<(std::ostream& out, const FixedArray<N,T>& p);
    

template<int N, typename T>
std::istream&
operator>>(std::istream& in, FixedArray<N,T>& p);


template<int N, typename T>
void
write_elements_binary(std::ostream& out, const FixedArray<N,T>& x);
    

template<int N, typename T>
void
read_elements_binary(std::istream& in, FixedArray<N,T>& x);


END_NAMESPACE_ADS

#define __FixedArray_ipp__
#include "FixedArray.ipp"
#undef __FixedArray_ipp__

#define __FixedArray0_h__
#include "FixedArray0.h"
#undef __FixedArray0_h__

#define __FixedArray1_h__
#include "FixedArray1.h"
#undef __FixedArray1_h__

#define __FixedArray2_h__
#include "FixedArray2.h"
#undef __FixedArray2_h__

#define __FixedArray3_h__
#include "FixedArray3.h"
#undef __FixedArray3_h__

#endif

---