ArrayBase.h

Go to the documentation of this file.

// -*- c++ -*-
/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010, 2011 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program 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.
 * 
 * This program 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 LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef NDARRAY_ArrayBase_h_INCLUDED
#define NDARRAY_ArrayBase_h_INCLUDED

#include <boost/iterator/counting_iterator.hpp>

#include "ndarray/ExpressionBase.h"
#include "ndarray/Vector.h"
#include "ndarray/detail/Core.h"
#include "ndarray/detail/NestedIterator.h"
#include "ndarray/detail/StridedIterator.h"
#include "ndarray/detail/ArrayAccess.h"
#include "ndarray/detail/ViewBuilder.h"
#include "ndarray/ArrayTraits.h"
#include "ndarray/eigen_fwd.h"

namespace ndarray {

template <typename Derived>
class ArrayBase : public ExpressionBase<Derived> {
protected:
    typedef ExpressionTraits<Derived> Traits;
    typedef typename Traits::Core Core;
    typedef typename Traits::CorePtr CorePtr;
public:
    typedef typename Traits::Element Element;
    typedef typename Traits::Iterator Iterator;
    typedef typename Traits::Reference Reference;
    typedef typename Traits::Value Value;
    typedef typename Traits::ND ND;
    typedef typename Traits::RMC RMC;
    typedef Vector<int,ND::value> Index;
    typedef ArrayRef<Element,ND::value,-RMC::value> FullTranspose;
    typedef ArrayRef<Element,ND::value,0> Transpose;
    typedef Array<Element,ND::value,RMC::value> Shallow;
    typedef ArrayRef<Element,ND::value,RMC::value> Deep;

    Reference operator[](int n) const {
        return Traits::makeReference(
            this->_data + n * this->template getStride<0>(),
            this->_core
        );
    }

    Element & operator[](Index const & i) const {
        return *(this->_data + this->_core->template computeOffset(i));
    }

    Iterator begin() const {
        return Traits::makeIterator(
            this->_data,
            this->_core,
            this->template getStride<0>()
        );
    }

    Iterator end() const {
        return Traits::makeIterator(
            this->_data + this->template getSize<0>() * this->template getStride<0>(), 
            this->_core,
            this->template getStride<0>()
        );
    }

    Element * getData() const { return _data; }
    
    bool isEmpty() const { return _data == 0; }

    Manager::Ptr getManager() const { return this->_core->getManager(); }

    template <int P> int getSize() const {
        return detail::getDimension<P>(*this->_core).getSize();
    }

    template <int P> int getStride() const {
        return detail::getDimension<P>(*this->_core).getStride();
    }

    Index getShape() const { Index r; this->_core->fillShape(r); return r; }

    Index getStrides() const { Index r; this->_core->fillStrides(r); return r; }

    int getNumElements() const { return this->_core->getNumElements(); }

    FullTranspose transpose() const {
        Index shape = getShape();
        Index strides = getStrides();
        for (int n=0; n < ND::value / 2; ++n) {
            std::swap(shape[n], shape[ND::value-n-1]);
            std::swap(strides[n], strides[ND::value-n-1]);
        }
        return FullTranspose(
            getData(),
            Core::create(shape, strides, getManager())
        );
    }

    Transpose transpose(Index const & order) const {
        Index newShape;
        Index newStrides;
        Index oldShape = getShape();
        Index oldStrides = getStrides();
        for (int n=0; n < ND::value; ++n) {
            newShape[n] = oldShape[order[n]];
            newStrides[n] = oldStrides[order[n]];
        }
        return Transpose(
            getData(), 
            Core::create(newShape, newStrides, getManager())
        );
    }

    Shallow const shallow() const { return Shallow(this->getSelf()); }

    Deep const deep() const { return Deep(this->getSelf()); }
    

    template <typename XprKind, int Rows, int Cols>
    EigenView<Element,ND::value,RMC::value,XprKind,Rows,Cols> asEigen() const;

    template <typename XprKind>
    EigenView<Element,ND::value,RMC::value,XprKind> asEigen() const;

    template <int Rows, int Cols>
    EigenView<Element,ND::value,RMC::value,Eigen::MatrixXpr,Rows,Cols> asEigen() const;

    EigenView<Element,ND::value,RMC::value,Eigen::MatrixXpr> asEigen() const;

    template <typename View_>
    struct ResultOf {
        typedef Element Element_;
        typedef typename detail::ViewTraits<ND::value, RMC::value, typename View_::Sequence>::ND ND_;
        typedef typename detail::ViewTraits<ND::value, RMC::value, typename View_::Sequence>::RMC RMC_;
        typedef ArrayRef<Element_,ND_::value,RMC_::value> Type;
        typedef Array<Element_,ND_::value,RMC_::value> Value;
    };

    template <typename Seq>
    typename ResultOf< View<Seq> >::Type
    operator[](View<Seq> const & def) const {
        return detail::buildView(this->getSelf(), def._seq);
    }

protected:
    template <typename T_, int N_, int C_> friend class Array;
    template <typename T_, int N_, int C_> friend class ArrayRef;
    template <typename T_, int N_, int C_> friend struct ArrayTraits;
    template <typename T_, int N_, int C_> friend class detail::NestedIterator;
    template <typename Derived_> friend class ArrayBase;
    template <typename Array_> friend class detail::ArrayAccess;

    Element * _data;
    CorePtr _core;

    void operator=(ArrayBase const & other) {
        _data = other._data;
        _core = other._core;
    }

    ArrayBase(Element * data, CorePtr const & core) : _data(data), _core(core) {}
};

} // namespace ndarray

#endif // !NDARRAY_ArrayBase_h_INCLUDED