Index.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_EXPRESSION_INDEX_H
#define MYRAMATH_EXPRESSION_INDEX_H

#include <myramath/MYRAMATH_EXPORT.h>

#ifdef MYRAMATH_ENABLE_CPP11
#include <initializer_list>
#endif

namespace myra {

template<int N> class Index
  {
  public:

    // Default constructor, fills with zeros.
    Index()
      { 
      for (int n = 0; n < N; ++n) 
        contents[n] = 0; 
      }

    // Fill constructor, copies N int's from pointer p.
    Index(const int* p)
      { 
      for (int n = 0; n < N; ++n) 
        contents[n] = *p++; 
      }

#ifdef MYRAMATH_ENABLE_CPP11
    
    // Fill constructor, from std::initializer_list<int>
    Index(std::initializer_list<int> list)
      {
      for (int n = 0; n < N; ++n) 
        contents[n] = *(list.begin()+n);
      }

#endif
    
    // Accessing/mutating contents.
    const int& operator [](int n) const 
      { return contents[n]; }
    int& operator [](int n)       
      { return contents[n]; }

    // Raw access to contiguous data.
    const int* data() const
      { return contents; }
    int* data()
      { return contents; }

    // Const range over contents.
    const int* begin() const 
      { return contents+0; }
    const int* end() const
      { return contents+N; }

    // Mutable range over contents.
    int* begin()
      { return contents+0; }
    int* end()
      { return contents+N; }

    // Returns first F values. Example usage: index.first<2>() returns the 0'th and 1'st values, etc.
    template<int F> Index<F> first() const
      { return Index<F>(this->begin()); }

    // Returns last L values. Example usage: index.last<2>() returns the N-2'th and N-1'th values, etc.
    template<int L> Index<L> last() const
      { return Index<L>(this->begin()+N-L); }

  private:

    // Internal contents.
    int contents[N];
    
  };

template<int N> bool operator == (const Index<N>& a, const Index<N>& b)
  {
  for (int n = 0; n < N; ++n)
    if (a[n] != b[n])
      return false;
  return true;
  }

template<int N> bool operator != (const Index<N>& a, const Index<N>& b)
  { return !(a==b); }

template<int N1, int N2> Index<N1+N2> concatenate(const Index<N1>& i1, const Index<N2>& i2)
  {
  Index<N1+N2> i;
  for (int n = 0; n < N1; ++n)
    i[n] = i1[n];
  for (int n = 0; n < N2; ++n)
    i[n+N1] = i2[n];
  return i;
  }

MYRAMATH_EXPORT Index<1> make_Index(int i);
MYRAMATH_EXPORT Index<2> make_Index(int i, int j);
MYRAMATH_EXPORT Index<3> make_Index(int i, int j, int k);

} // namespace myra

#endif