array.hpp

/*
 * array.hpp
 *
 * Created on: 23 Jan 2007
 * Author: Holger Schmitz
 * Email: holger@notjustphysics.com
 *
 * Copyright 2012 Holger Schmitz
 *
 * This file is part of Schnek.
 *
 * Schnek 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 3 of the License, or
 * (at your option) any later version.
 *
 * Schnek 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 Schnek.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCHNEK_ARRAY_HPP_
#define SCHNEK_ARRAY_HPP_

#include "arraycheck.hpp"
namespace schnek {

template<class Operator, int Length>
class ArrayExpression;


template<
  class T, 
  int length, 
  template<int> class CheckingPolicy = ArrayNoArgCheck
>
class Array :
    public CheckingPolicy<length>
{
  private:
    T data[length];

    typedef Array<T,length,CheckingPolicy> ThisType;
  public:
    typedef T value_type;
    enum {Length = length};
    
    Array();
    template<template<int> class CheckingPolicy2>
    Array(const Array<T, length, CheckingPolicy2> &);

    template<class Operator>
    Array(const ArrayExpression<Operator, length> &);

    Array(const T&);
    Array(const T&, const T&);
    Array(const T&, const T&, const T&);
    Array(const T&, const T&, const T&, const T&);
    Array(const T&, const T&, const T&, const T&, const T&);
    Array(const T&, const T&, const T&, const T&, const T&, 
               const T&);
    Array(const T&, const T&, const T&, const T&, const T&, 
               const T&, const T&);
    Array(const T&, const T&, const T&, const T&, const T&, 
               const T&, const T&, const T&);
    Array(const T&, const T&, const T&, const T&, const T&, 
               const T&, const T&, const T&, const T&);
    Array(const T&, const T&, const T&, const T&, const T&, 
               const T&, const T&, const T&, const T&, const T&);

    ~Array() {}

    T& operator[](int);
    T operator[](int) const;

    T& at(int);
    T at(int) const;

  public:
    template<class T2, template <int> class CheckingPolicy2>
    Array<T,length,CheckingPolicy> &operator=(const Array<T2,length,CheckingPolicy2>&);

    template<class Operator>
    Array<T,length,CheckingPolicy> &operator=(const ArrayExpression<Operator, length> &);

    template<class T2, template <int> class CheckingPolicy2>
    Array<T,length,CheckingPolicy> &operator+=(const Array<T2,length,CheckingPolicy2>&);

    template<class T2, template <int> class CheckingPolicy2>
    Array<T,length,CheckingPolicy> &operator*=(const Array<T2,length,CheckingPolicy2>&);

    template<class T2, template <int> class CheckingPolicy2>
    Array<T,length,CheckingPolicy> &operator/=(const Array<T2,length,CheckingPolicy2>&);

    template<class T2, template <int> class CheckingPolicy2>
    Array<T,length,CheckingPolicy> &operator-=(const Array<T2,length,CheckingPolicy2>&);

    template<typename T2>
    Array<T,length,CheckingPolicy> &operator+=(const T2);

    template<typename T2>
    Array<T,length,CheckingPolicy> &operator-=(const T2);

    template<typename T2>
    Array<T,length,CheckingPolicy> &operator*=(const T2);

    template<typename T2>
    Array<T,length,CheckingPolicy> &operator/=(const T2);


    template<class Operator>
    Array<T,length,CheckingPolicy> &operator+=(const ArrayExpression<Operator, length> &);

    template<class Operator>
    Array<T,length,CheckingPolicy> &operator-=(const ArrayExpression<Operator, length> &);

    template<class Operator>
    Array<T,length,CheckingPolicy> &operator*=(const ArrayExpression<Operator, length> &);

    template<class Operator>
    Array<T,length,CheckingPolicy> &operator/=(const ArrayExpression<Operator, length> &);

  public:
    Array<T,length,CheckingPolicy>& clear();
    Array<T,length,CheckingPolicy>& fill(const T&);
    
    template<int destLength>
    Array<T,destLength,CheckingPolicy> project() const;

    Array<T,length-1,CheckingPolicy> projectDim(int dim) const;


    static Array<T,length,CheckingPolicy> Zero();
    
    static Array<T,length,CheckingPolicy> Ones();

    T product() const;

    T sum() const;

    T sqr() const;
};



} // namespace

template<
  class T1, class T2,
  int length, 
  template<int> class CheckingPolicy1, template<int> class CheckingPolicy2
>
bool operator==(
  const schnek::Array<T1,length,CheckingPolicy1>&,
  const schnek::Array<T2,length,CheckingPolicy2>&
);

template<
  class T1, class T2,
  int length, 
  template<int> class CheckingPolicy1, template<int> class CheckingPolicy2
>
bool operator!=(
  const schnek::Array<T1,length,CheckingPolicy1>&,
  const schnek::Array<T2,length,CheckingPolicy2>&
);

template<
  class T1, class T2,
  int length, 
  template<int> class CheckingPolicy1, template<int> class CheckingPolicy2
>
bool operator<(
  const schnek::Array<T1,length,CheckingPolicy1>&,
  const schnek::Array<T2,length,CheckingPolicy2>&
);

template<
  class T1, class T2,
  int length, 
  template<int> class CheckingPolicy1, template<int> class CheckingPolicy2
>
bool operator<=(
  const schnek::Array<T1,length,CheckingPolicy1>&,
  const schnek::Array<T2,length,CheckingPolicy2>&
);


#include "array.t"

#endif // SCHNEK_ARRAY_HPP_