FArray1D.h

Go to the documentation of this file.

#ifndef CLASSIC_FArray1D_HH
#define CLASSIC_FArray1D_HH
 
// ------------------------------------------------------------------------
// $RCSfile: FArray1D.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1.2.3 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: FArray1D<T,N>
//
// ------------------------------------------------------------------------
// Class category: FixedAlgebra
// ------------------------------------------------------------------------
//
// $Date: 2004/11/18 22:18:06 $
// $Author: jsberg $
//
// ------------------------------------------------------------------------
 
#include "Utilities/CLRangeError.h"
#include "Utilities/SizeError.h"
#include <algorithm>
#include <initializer_list>
#include <ostream>
 
 
// Template class FArray1D<T,N>
// ------------------------------------------------------------------------
//  This version has fixed dimensions.
//  It implements array access, but contains no arithmetic operations.
//  The destructor generated by the compiler performs the correct operation.
//  For speed reasons it is not implemented.
 
template<class T, int N>
class FArray1D {
 
public:
 
    typedef T value_type;
 
    typedef T *iterator;
 
    typedef const T *const_iterator;
 
    //  Constructs a zero array.
    FArray1D();
 
    //  Set all array elements to [b]t[/b].
    explicit FArray1D(const T &t);
 
    FArray1D(const FArray1D &);
 
    FArray1D(const std::initializer_list<T>&);
    
    const FArray1D &operator=(const FArray1D &);
 
    //  Return a reference to element [b]n[/b].
    //  Throw RangeError, if [b]n[/b] is out of range.
    T &operator()(int n);
 
    //  Return a constant reference to element [b]n[/b].
    //  Throw RangeError, if [b]n[/b] is out of range.
    const T &operator()(int n) const;
 
    //  Return a reference to element [b]n[/b].
    //  Result is undefined, if [b]n[/b] is out of range.
    T &operator[](int n);
 
    //  Return a reference to element [b]n[/b].
    //  Result is undefined, if [b]n[/b] is out of range.
    const T &operator[](int n) const;
 
    //  Version for non-constant array.
    iterator begin();
 
    //  Version for non-constant array.
    iterator end();
 
    //  Version for constant array.
    const_iterator begin() const;
 
    //  Version for constant array.
    const_iterator end() const;
 
    int size() const;
 
protected:
 
    // The array data.
    T data[N];
};
 
 
// Template function implementation.
// ------------------------------------------------------------------------
 
template<class T, int N>
FArray1D<T, N>::FArray1D() {
    std::fill(begin(), end(), T(0));
}
 
 
template<class T, int N>
FArray1D<T, N>::FArray1D(const FArray1D &rhs) {
    std::copy(rhs.begin(), rhs.end(), begin());
}
 
 
template<class T, int N>
FArray1D<T, N>::FArray1D(const T &val) {
    std::fill(begin(), end(), val);
}
 
#include <iostream>
 
template<class T, int N>
FArray1D<T, N>::FArray1D(const std::initializer_list<T>& init) {
    
    
    if (init.size() > N) {
        throw SizeError("FArray1D<T,N>(const std::initializer_list<T>&)","Size exceeds array dimension.");
    }
    
    // copy list to array
    std::copy(init.begin(), init.end(), begin());
    
    // if initializer list smaller than array dimension, fill rest with zero
    if (init.size() < N) {
        std::fill(begin()+init.size(), end(), T(0));
    }
}
 
template<class T, int N>
const FArray1D<T, N> &FArray1D<T, N>::operator=(const FArray1D &rhs) {
    std::copy(rhs.begin(), rhs.end(), begin());
    return *this;
}
 
 
template<class T, int N> inline
T &FArray1D<T, N>::operator[](int i) {
    return data[i];
}
 
 
template<class T, int N> inline
const T &FArray1D<T, N>::operator[](int i) const {
    return data[i];
}
 
 
template<class T, int N>
T &FArray1D<T, N>::operator()(int i) {
    if(i >= N) {
        throw CLRangeError("FArray1D::operator()", "Index out of range.");
    }
    return data[i];
}
 
 
template<class T, int N>
const T &FArray1D<T, N>::operator()(int i) const {
    if(i >= N) {
        throw CLRangeError("FArray1D::operator()", "Index out of range.");
    }
    return data[i];
}
 
 
template<class T, int N> inline
typename FArray1D<T, N>::iterator FArray1D<T, N>::begin() {
    return data;
}
 
 
template<class T, int N> inline
typename FArray1D<T, N>::iterator FArray1D<T, N>::end() {
    return data + N;
}
 
 
template<class T, int N> inline
typename FArray1D<T, N>::const_iterator FArray1D<T, N>::begin() const {
    return data;
}
 
 
template<class T, int N> inline
typename FArray1D<T, N>::const_iterator FArray1D<T, N>::end() const {
    return data + N;
}
 
 
template<class T, int N> inline
int FArray1D<T, N>::size() const {
    return N;
}
 
 
template <class T, int N>
std::ostream &operator<<(std::ostream &os, const FArray1D<T, N> &v) {
    for(int i = 0; i < N; ++i) {
        os << v[i] << " ";
    }
 
    os << std::endl;
    return os;
}
 
#endif // CLASSIC_FArray1D_HH