initialization.h

Go to the documentation of this file.

// -*- c++ -*-
/*
 * Copyright (c) 2010-2012, Jim Bosch
 * All rights reserved.
 *
 * ndarray is distributed under a simple BSD-like license;
 * see the LICENSE file that should be present in the root
 * of the source distribution, or alternately available at:
 * https://github.com/ndarray/ndarray
 */
#ifndef NDARRAY_initialization_h_INCLUDED
#define NDARRAY_initialization_h_INCLUDED
 
#include "ndarray/Array.h"
#include "ndarray/ArrayRef.h"
#include "ndarray/Manager.h"
 
namespace ndarray {
namespace detail {
 
struct NullOwner {};
 
template <int N, typename Derived>
class Initializer {
public:
 
    template <typename T, int C>
    operator Array<T,N,C> () const {
        return static_cast<Derived const *>(this)->template apply< Array<T,N,C> >();
    }
 
    template <typename T, int C>
    operator ArrayRef<T,N,C> () const {
        return static_cast<Derived const *>(this)->template apply< ArrayRef<T,N,C> >();
    }
 
};
 
template <int N>
class SimpleInitializer : public Initializer< N, SimpleInitializer<N> > {
public:
 
    template <typename Target>
    Target apply() const {
        typedef detail::ArrayAccess< Target > Access;
        typedef typename Access::Core Core;
        typedef typename Access::Element Element;
        DataOrderEnum order = (ExpressionTraits< Target >::RMC::value < 0) ? COLUMN_MAJOR : ROW_MAJOR;
        Size total = _shape.product();
        std::pair<Manager::Ptr,Element*> p = SimpleManager<Element>::allocate(total);
        return Access::construct(p.second, Core::create(_shape, order, p.first));
    }
 
    explicit SimpleInitializer(Vector<Size,N> const & shape) : _shape(shape) {}
 
private:
    Vector<Size,N> _shape;
};
 
template <typename T, int N, typename Owner>
class ExternalInitializer : public Initializer< N, ExternalInitializer<T,N,Owner> > {
public:
 
    template <typename Target>
    Target apply() const {
        typedef detail::ArrayAccess< Target > Access;
        typedef typename Access::Core Core;
        Manager::Ptr manager;
        if (!boost::is_same<Owner,NullOwner>::value) {
            manager = makeManager(_owner);
        }
        return Access::construct(_data, Core::create(_shape, _strides, manager));
    }
 
    ExternalInitializer(
        T * data, 
        Vector<Size,N> const & shape,
        Vector<Offset,N> const & strides,
        Owner const & owner
    ) : _data(data), _owner(owner), _shape(shape), _strides(strides) {}
 
private:
    T * _data;
    Owner _owner;
    Vector<Size,N> _shape;
    Vector<Offset,N> _strides;
};
 
} // namespace detail
 
 
template <int N, typename U>
inline detail::SimpleInitializer<N> allocate(Vector<U,N> const & shape) {
    return detail::SimpleInitializer<N>(Vector<Size,N>(shape));
}
 
inline detail::SimpleInitializer<1> allocate(Size n) {
    return detail::SimpleInitializer<1>(ndarray::makeVector(n)); 
}
 
inline detail::SimpleInitializer<2> allocate(Size n1, Size n2) {
    return detail::SimpleInitializer<2>(ndarray::makeVector(n1, n2)); 
}
 
inline detail::SimpleInitializer<3> allocate(Size n1, Size n2, Size n3) {
    return detail::SimpleInitializer<3>(ndarray::makeVector(n1, n2, n3)); 
}
 
template <typename Derived>
inline ArrayRef<typename boost::remove_const<typename Derived::Element>::type, 
                Derived::ND::value, Derived::ND::value>
copy(ExpressionBase<Derived> const & expr) {
    ArrayRef<typename boost::remove_const<typename Derived::Element>::type, 
        Derived::ND::value,Derived::ND::value> r(
            allocate(expr.getShape())
        );
    r = expr;
    return r;
}
 
template <int N>
Vector<Offset,N> computeStrides(Vector<Size,N> const & shape, DataOrderEnum order=ROW_MAJOR) {
    Vector<Offset,N> r(1);
    if (order == ROW_MAJOR) {
        for (int n=N-1; n > 0; --n) r[n-1] = r[n] * shape[n];
    } else {
        for (int n=1; n < N; ++n) r[n] = r[n-1] * shape[n-1];
    }
    return r;
}
 
template <typename T, int N, typename U, typename V, typename Owner>
inline detail::ExternalInitializer<T,N,Owner> external(
    T * data,
    Vector<U,N> const & shape,
    Vector<V,N> const & strides,
    Owner const & owner
) {
    return detail::ExternalInitializer<T,N,Owner>(
        data,
        Vector<Size,N>(shape.template cast<Size>()),
        Vector<Offset,N>(strides.template cast<Offset>()),
        owner
    );
}
 
template <typename T, int N, typename U, typename V>
inline detail::ExternalInitializer<T,N,detail::NullOwner> external(
    T * data,
    Vector<U,N> const & shape,
    Vector<V,N> const & strides
) {
    return detail::ExternalInitializer<T,N,detail::NullOwner>(
        data,
        Vector<Size,N>(shape),
        Vector<Offset,N>(strides),
        detail::NullOwner()
    );
}
 
template <typename T, int N, typename U, typename Owner>
inline detail::ExternalInitializer<T,N,Owner> external(
    T * data,
    Vector<U,N> const & shape,
    DataOrderEnum order,
    Owner const & owner
) {
    return detail::ExternalInitializer<T,N,Owner>(
        data,
        Vector<Size,N>(shape.template cast<Size>()),
        computeStrides(shape.template cast<Size>(), order),
        owner
    );
}
 
template <typename T, int N, typename U>
inline detail::ExternalInitializer<T,N,detail::NullOwner> external(
    T * data,
    Vector<U,N> const & shape,
    DataOrderEnum order = ROW_MAJOR
) {
    return detail::ExternalInitializer<T,N,detail::NullOwner>(
        data,
        Vector<Size,N>(shape.template cast<Size>()),
        computeStrides(shape.template cast<Size>(), order),
        detail::NullOwner()
    );
}
 
 
template <typename T, int N, int C>
Array<T,N,C>::Array(Size n1, Size n2, Size n3, Size n4, Size n5, Size n6, Size n7, Size n8)
    : Super(0, CorePtr())
{
    typename Super::Index shape;
    if (N > 0) shape[0] = n1;
    if (N > 1) shape[1] = n2;
    if (N > 2) shape[2] = n3;
    if (N > 3) shape[3] = n4;
    if (N > 4) shape[4] = n5;
    if (N > 5) shape[5] = n6;
    if (N > 6) shape[6] = n7;
    if (N > 7) shape[7] = n8;
    this->operator=(ndarray::allocate(shape));
}
 
template <typename T, int N, int C>
template <typename U>
Array<T,N,C>::Array(Vector<U,N> const & shape)
    : Super(0, CorePtr())
{
    this->operator=(ndarray::allocate(shape.template cast<U>()));
}
 
template <typename T, int N, int C>
ArrayRef<T,N,C>::ArrayRef(Size n1, Size n2, Size n3, Size n4, Size n5, Size n6, Size n7, Size n8)
    : Super(Array<T,N,C>(n1, n2, n3, n4, n5, n6, n7, n8))
{}
 
template <typename T, int N, int C>
template <typename U>
ArrayRef<T,N,C>::ArrayRef(Vector<U,N> const & shape)
    : Super(Array<T,N,C>(shape))
{}
 
} // namespace ndarray
 
#endif // !NDARRAY_initialization_h_INCLUDED