JArray.hh

Go to the documentation of this file.

#ifndef __JTOOLS__JARRAY__
#define __JTOOLS__JARRAY__
 
#include <cstddef>
#include <istream>
#include <ostream>
#include <array>
#include <algorithm>
#include <type_traits>
 
#include "JIO/JSerialisable.hh"
#include "JTools/JMultiKey.hh"
#include "JMath/JMath.hh"
#include "JLang/JAssert.hh"
#include "JLang/JClass.hh"
#include "JLang/JEquals.hh"
#include "JLang/JManip.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }
 
namespace JTOOLS {
 
  using JIO::JReader;
  using JIO::JWriter;
  using JMATH::JMath;
  using JLANG::JEquals;
 
 
  /**
   * Wrapper data structure around std::array.
   */
  template<unsigned int N, class T>
  struct JArray :
    public std::array<T, N>,
    public JMath  < JArray<N,T> >,
    public JEquals< JArray<N,T> >
  {
  public:
 
    typedef  std::array<T, N>  array_type;
 
    using    typename array_type::value_type;
    using    typename array_type::size_type;
    using    typename array_type::difference_type;
    using    typename array_type::reference;
    using    typename array_type::const_reference;
    using    typename array_type::pointer;
    using    typename array_type::const_pointer;
    using    typename array_type::iterator;
    using    typename array_type::const_iterator;
    using    typename array_type::reverse_iterator;
    using    typename array_type::const_reverse_iterator;
 
    typedef  typename JClass<T>::argument_type  argument_type;
 
    typedef  typename std::conditional<std::is_const<T>::value,
                                       typename std::remove_const<T>::type,
                                       typename std::add_const   <T>::type>::type  U;   // opposite constness
 
 
    /**
     * Default constructor.
     */
    JArray() :
      std::array<T, N>()
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  array            array
     */
    template<unsigned int M>
    JArray(const JArray<M, T>& array) :
      std::array<T, N>(match(array))
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  array            array
     */
    template<unsigned int M>
    JArray(const JArray<M, U>& array) :
      std::array<T, N>(match(convert(array)))
    {}
 
    
    /**
     * Assemble constructor.
     *
     * \param  value            value
     * \param  args             argument list
     */
    template<class ...Args>
    JArray(argument_type value, const Args& ...args) :
      std::array<T, N>({value, args...})
    {}
 
 
    /**
     * Multi-copy constructor.
     *
     * \param  p                pointer to data
     */
    JArray(const T* p)
    {
      std::copy_n(p, N, this->data());
    }
 
 
    /**
     * Combine constructor.
     *
     * \param  first            first  array
     * \param  second           second array
     */
    template<size_t M>
    JArray(const std::array<T, M>& first, const std::array<T, N-M>& second) :
      std::array<T, N>(combine(first, second))
    {}
 
 
    /**
     * Copy and assemble constructor.
     *
     * \param  array            array
     * \param  value            value
     * \param  args             argument list
     */
    template<size_t M, class ...Args>
    JArray(const std::array<T, M>& array, argument_type value, const Args& ...args) :
      JArray(array, std::array<T, N-M>({value, args...}))
    {}
 
 
    /**
     * Copy and assemble constructor.
     *
     * \param  array            array
     * \param  value            value
     * \param  args             argument list
     */
    template<size_t M, class ...Args>
    JArray(const std::array<U, M>& array, argument_type value, const Args& ...args) :
      JArray(convert(array), std::array<T, N-M>({value, args...}))
    {}
 
 
    /**
     * Convert constructor.
     *
     * \param  key              key
     */
    JArray(const JMultiKey<N, T>& key) :
      std::array<T, N>(key)
    {}
 
 
    /**
     * Convert constructor.
     *
     * \param  key              key
     */
    JArray(const JMultiKey<N, U>& key) :
      std::array<T, N>(convert((std::array<U, N>) key))
    {}
 
 
    /**
     * Convert and combine constructor.
     *
     * \param  key              key
     * \param  array            array
     */
    template<unsigned int M>
    JArray(const JMultiKey<M, T>& key, const std::array<std::remove_const_t<T>, N-M>& array) :
      JArray((std::array<T, M>) key, array)
    {}
 
 
    /**
     * Convert and combine constructor.
     *
     * \param  key              key
     * \param  array            array
     */
    template<unsigned int M>
    JArray(const JMultiKey<M, U>& key, const std::array<std::remove_const_t<T>, N-M>& array) :
      JArray(convert((std::array<U, M>) key), array)
    {}
 
 
    /**
     * Convert and assemble constructor.
     *
     * \param  key              key
     * \param  value            value
     * \param  args             argument list
     */
    template<unsigned int M, class ...Args>
    JArray(const JMultiKey<M, T>& key, argument_type value, const Args& ...args) :
      JArray(key, std::array<T, N-M>({value, args...}))
    {}
 
 
    /**
     * Convert and assemble constructor.
     *
     * \param  key              key
     * \param  value            value
     * \param  args             argument list
     */
    template<unsigned int M, class ...Args>
    JArray(const JMultiKey<M, U>& key, argument_type value, const Args& ...args) :
      JArray(key, std::array<T, N-M>({value, args...}))
    {}
 
 
    /**
     * Make a copy in which the first element is removed.
     *
     * \return                  array
     */
    JArray<N-1, T> pop_front() const
    {
      return pop_front(std::make_index_sequence<N>{});
    }
 
 
    /**
     * Make a copy in which the last element is removed.
     *
     * \return                  array
     */
    JArray<N-1, T> pop_back() const
    {
      return pop_back(std::make_index_sequence<N-1>{});
    }
 
 
    /**
     * Make a copy and push back value.
     *
     * \param  value            value
     * \return                  array
     */
    JArray<N+1, T> push_back(argument_type value) const
    {
      return push_back(value, std::make_index_sequence<N>{});
    }
 
 
    /**
     * Negate array.
     *
     * \return                  this array
     */
    JArray& negate()
    {
      for (int i = 0; i != N; ++i) {
        (*this)[i] = -(*this)[i];
      }
 
      return *this;
    }
 
 
    /**
     * Add array.
     *
     * \param  array            array
     * \return                  this array
     */
    JArray& add(const JArray& array)
    {
      for (int i = 0; i != N; ++i) {
        (*this)[i] += array[i];
      }
 
      return *this;
    }
 
 
    /**
     * Subtract array.
     *
     * \param  array            array
     * \return                  this array
     */
    JArray& sub(const JArray& array)
    {
      for (int i = 0; i != N; ++i) {
        (*this)[i] -= array[i];
      }
 
      return *this;
    }
 
 
    /**
     * Scale array.
     *
     * \param  factor           multiplication factor
     * \return                  this array
     */
    JArray& mul(const double factor)
    {
      for (int i = 0; i != N; ++i) {
        (*this)[i] *= factor;
      }
 
      return *this;
    }
 
 
    /**
     * Scale array.
     *
     * \param  factor           division factor
     * \return                  this array
     */
    JArray& div(const double factor)
    {
      for (int i = 0; i != N; ++i) {
        (*this)[i] /= factor;
      }
 
      return *this;
    }
 
 
    /** 
     * Check equality.
     *
     * \param  array            array
     * \return                  true if arrays are equal; else false
     */
    bool equals(const JArray<N, T>& array) const
    {
      for (int i = 0; i != N; ++i) {
        if ((*this)[i] != array[i]) {
          return false;
        }
      }
 
      return true;
    }
 
 
    /**
     * Read array from input stream.
     *
     * \param  in               input stream
     * \param  array            array
     * \return                  input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JArray& array)
    {
      for (iterator i = array.begin(); i != array.end(); ++i) {
        in >> *i;
      }
 
      return in;
    }
 
 
    /**
     * Write array to output stream.
     *
     * \param  out              output stream
     * \param  array            array
     * \return                  output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JArray& array)
    {
      const JFormat format(out, getFormat<JArray>(JFormat_t(10, 3, std::ios::fixed | std::ios::showpos)));
 
      for (const_iterator i = array.begin(); i != array.end(); ++i) {
        out << ' ' << format << *i;
      }
 
      return out;
    }
 
 
    /**
     * Read array from input.
     *
     * \param  in               reader
     * \param  buffer           array
     * \return                  reader
     */
    friend inline JReader& operator>>(JReader& in, JArray& buffer)
    {
      for (iterator i = buffer.begin(); i != buffer.end(); ++i) {
        in >> *i;
      }
 
      return in;
    }
 
 
    /**
     * Write array to output.
     *
     * \param  out              writer
     * \param  buffer           array
     * \return                  writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JArray& buffer)
    {
      for (const_iterator i = buffer.begin(); i != buffer.end(); ++i) {
        out << *i;
      }
 
      return out;
    }
 
  protected:
    /**
     * Auxiliary method to match array.
     *
     * \param  array            array
     * \param  ls               indices of array
     * \return                  array
     */
    template<size_t M, size_t ...i>
    static std::array<T, N> match(const std::array<T, M>& array, const std::index_sequence<i...>& ls)
    {
      return {array[i]...};
    };
 
 
    /**
     * Match array.
     *
     * \param  array            array
     * \return                  array
     */
    template<size_t M>
    static std::array<T, N> match(const std::array<T, M>& array)
    {
      return match(array, std::make_index_sequence<N>{});
    };
 
 
    /**
     * Auxiliary method to convert array.
     *
     * \param  array            array
     * \param  ls               indices of array
     * \return                  array
     */
    template<size_t ...i>
    static std::array<T, sizeof...(i)> convert(const std::array<U, sizeof...(i)>& array, const std::index_sequence<i...>& ls)
    {
      return {array[i]...};
    };
 
 
    /**
     * Convert array.
     *
     * \param  array            array
     * \return                  array
     */
    template<size_t M>
    static std::array<T, M> convert(const std::array<U, M>& array)
    {
      return convert(array, std::make_index_sequence<M>{});
    };
 
 
    /**
     * Auxiliary method combine arrays.
     *
     * \param  v                first  array
     * \param  lv               indices of first  array
     * \param  w                second array
     * \param  lw               indices of second array
     */
    template<size_t ...iv, size_t ...iw>
    static std::array<T, N> combine(const std::array<T, sizeof...(iv)>& v, const std::index_sequence<iv...>& lv,
                                    const std::array<T, sizeof...(iw)>& w, const std::index_sequence<iw...>& lw)
    {
      return { v[iv]..., w[iw]... };
    };
 
 
    /**
     * Combine two arrays.
     *
     * \param  first            first  array
     * \param  second           second array
     * \return                  array
     */
    template<size_t M>
    static std::array<T, N> combine(const std::array<T, M>& first, const std::array<T, N-M>& second)
    {
      return combine(first,  std::make_index_sequence< M >{},
                     second, std::make_index_sequence<N-M>{});
    }
 
 
    /**
     * Auxiliary method to pop back array.
     *
     * \param  ls               indices of array
     * \return                  array
     */
    template<size_t ...i>
    JArray<sizeof...(i), T> pop_back(const std::index_sequence<i...>& ls) const
    {
      return {(*this)[i]...};
    };
 
 
    /**
     * Auxiliary method to pop front array.
     *
     * \param  value            value
     * \param  args             argument list
     * \return                  array
     */
    template<class ...Args>
    static JArray<N-1, T> pop_front(argument_type value, const Args& ...args)
    {
      return {args...};
    };
 
 
    /**
     * Auxiliary method to pop front array.
     *
     * \param  ls               indices of array
     * \return                  array
     */
    template<size_t ...i>
    JArray<N-1, T> pop_front(const std::index_sequence<i...>& ls) const
    {
      return pop_front((*this)[i]...);
    };
 
 
    /**
     * Push back array.
     *
     * \param  value            value
     * \param  ls               indices of array
     * \return                  array
     */
    template<size_t ...i>
    JArray<N + 1, T> push_back(argument_type value, const std::index_sequence<i...>& ls) const
    {
      return {value, (*this)[i]...};
    };
  };
}
 
#endif