Array2.h

Go to the documentation of this file.

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

#ifndef MYRAMATH_UTILITY_ARRAY2_H
#define MYRAMATH_UTILITY_ARRAY2_H

#include <myramath/utility/detail/ssize.h>

// Serialization interface.
#include <myramath/io/Streams.h>
#include <myramath/io/ReaderWriter.h>
#include <myramath/io/detail/vector.h>

// Custom exceptions.
#include <myramath/utility/eprintf.h>

#include <vector>
#include <iostream>

namespace myra {

template<class T> class Array2
  {
  public:

    Array2()
      { I = J = 0; }
  
    Array2(int in_I, int in_J, T filler)
      { 
      I = in_I;
      J = in_J;
      contents.resize(I*J,filler); 
      }

#ifdef MYRAMATH_ENABLE_CPP11

    Array2(int II, int JJ, std::initializer_list<T> list)
      {
      I = II;
      J = JJ;
      int IJ = ssize(list);
      if (I*J != IJ)
        throw eprintf("Array2(I,J,initializer_list<T>), size mismatch I*J != size [%d*%d != %d]", I, J, IJ);
      contents.resize(IJ,T());
      const T* p = list.begin();
      for (int i = 0; i < I; ++i)
        for (int j = 0; j < J; ++j)
          (*this)(i,j) = *p++;
      }

#endif

    explicit Array2(InputStream& in)
      { in >> I >> J >> contents; }

    void write(OutputStream& out) const
      { out << I << J << contents; }

    const T& operator () (int i, int j) const
      { return contents[offset(i,j)]; }
    T& operator () (int i, int j)
      { return contents[offset(i,j)]; }

    void swap(Array2& that)
      {
      std::swap(this->I, that.I);
      std::swap(this->J, that.J);
      this->contents.swap(that.contents);
      }

    std::pair<int,int> size() const
      { return std::pair<int,int>(I,J); }
      
  private:
  
    // Defines internal layout.
    int offset(int i, int j) const
      { return j*I+i; }

    // Size.
    int I;
    int J;

    // Numeric data.
    typedef std::vector<T> Contents;
    Contents contents;

  };

template<class T> std::ostream& operator << (std::ostream& out, const Array2<T>& a)
  {
  int I = a.size().first;
  int J = a.size().second;
  out << I << " by " << J << ":" << std::endl;
  for (int i = 0; i < I; ++i)
    {
    out << "[ ";
    for (int j = 0; j < J; ++j)
      out << a(i,j) << " ";
    out << "]" << std::endl;
    }
  return out;
  }

} // namespace myra

#endif