matrix.hpp

Go to the documentation of this file.

// mds_utils/python/ublas/matrix.hpp
// 
// Copyright (c) 2009 - Michele De Stefano (micdestefano@users.sourceforge.net)
// 
// Distributed under the MIT License (See accompanying file COPYING)

#ifndef MDS_UTILS_PYTHON_UBLAS_MATRIX_HPP_INCLUDED
#define MDS_UTILS_PYTHON_UBLAS_MATRIX_HPP_INCLUDED

#include <boost/numeric/ublas/matrix.hpp>
#include <mds_utils/ublas/traits.hpp>
#include <mds_utils/python/ublas/detail/common.hpp>
#include <algorithm>

namespace mds_utils { namespace python { namespace ublas {
    
template<class M>
inline typename std::enable_if<
    mds_utils::ublas::is_matrix<M>::value,M>::type
        get(PyObject *po) {

    using namespace mds_utils::python::numpy;
    using namespace mds_utils::python::ublas;
    using namespace std;
        

    if (!PyArray_Check(po)) {
        throw std::invalid_argument("Cannot convert to "
            "boost::numeric::ublas::matrix: not a numpy array.");
    }

    PyArrayObject   *m_po(reinterpret_cast<PyArrayObject*>(po));
    

    int                 ndim(PyArray_NDIM(m_po));
    
    if (ndim != 2) {
        throw std::invalid_argument("Cannot convert from an "
            "array with num. of dims. different from 2.");
    }
    
    npy_intp            *dims(PyArray_DIMS(m_po));
            
    M                   mout(dims[0],dims[1]);
    
    NDArrayIterator<
        typename M::value_type,
        typename detail::ublas_to_npy_storage<
            typename M::orientation_category>::tag,NPY_ITER_READONLY>
                        it_beg(m_po),it_end(it_beg,true);

    copy(it_beg,it_end,mout.data().begin());
    
    return mout;
}


template<class ublas_mat_T>
inline typename std::enable_if<
    mds_utils::ublas::is_matrix<ublas_mat_T>::value,
    PyObject*
            >::type to_python(const ublas_mat_T& mat) {
    
    using namespace mds_utils::python::numpy;
    using namespace std;

    int
        nd(2),
        flags(detail::numpy_flags<
            typename ublas_mat_T::orientation_category>());
        
    npy_intp
        dims[] = {
            boost::numeric_cast<npy_intp>(mat.size1()),
            boost::numeric_cast<npy_intp>(mat.size2())
        };
    
    int dtype(numpy_dtype_traits<
        typename ublas_mat_T::value_type>::typenum);
    
    PyObject *pout(PyArray_New(&PyArray_Type,nd,dims,dtype,
        NULL,NULL,0,flags,NULL));
    
    if (pout == NULL) {
        throw std::runtime_error("Could not create output numpy array.");
    }
    
    PyArrayObject   *m_po(reinterpret_cast<PyArrayObject*>(pout));

    typedef typename ublas_mat_T::value_type                    value_type;
    typedef typename detail::ublas_to_npy_storage<
            typename ublas_mat_T::orientation_category>::tag    storage;

    NDArrayIterator<value_type,storage,NPY_ITER_WRITEONLY>  it_beg(m_po);

    copy(mat.data().begin(),mat.data().end(),it_beg);
    
    return pout;
}


}}}

#endif