ndarray.hpp

Go to the documentation of this file.

// Copyright Jim Bosch 2010-2012.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_NUMPY_NDARRAY_HPP_INCLUDED
#define BOOST_NUMPY_NDARRAY_HPP_INCLUDED

#include <boost/python.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/numpy/numpy_object_mgr_traits.hpp>
#include <boost/numpy/dtype.hpp>

#include <vector>

namespace boost 
{
namespace numpy 
{

class ndarray : public python::object 
{

  struct array_struct 
  {
    PyObject_HEAD
    char * data;
    int nd;
    Py_intptr_t * shape;
    Py_intptr_t * strides;
    PyObject * base;
    PyObject * descr;
    int flags;
    PyObject * weakreflist;
  };
  
  array_struct * get_struct() const { return reinterpret_cast<array_struct*>(this->ptr()); }

public:
  
  enum bitflag 
  {
    NONE=0x0, C_CONTIGUOUS=0x1, F_CONTIGUOUS=0x2, V_CONTIGUOUS=0x1|0x2, 
    ALIGNED=0x4, WRITEABLE=0x8, BEHAVED=0x4|0x8,
    CARRAY_RO=0x1|0x4, CARRAY=0x1|0x4|0x8, CARRAY_MIS=0x1|0x8,
    FARRAY_RO=0x2|0x4, FARRAY=0x2|0x4|0x8, FARRAY_MIS=0x2|0x8,
    UPDATE_ALL=0x1|0x2|0x4, VARRAY=0x1|0x2|0x8, ALL=0x1|0x2|0x4|0x8
  };

  BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(ndarray, object);

  ndarray view(dtype const & dt) const;
    
  ndarray astype(dtype const & dt) const;

  ndarray copy() const;

  int const shape(int n) const { return get_shape()[n]; }

  int const strides(int n) const { return get_strides()[n]; }
    
  char * get_data() const { return get_struct()->data; }

  dtype get_dtype() const;
  
  python::object get_base() const;
  
  void set_base(object const & base);
  
  Py_intptr_t const * get_shape() const { return get_struct()->shape; }
  
  Py_intptr_t const * get_strides() const { return get_struct()->strides; }
  
  int const get_nd() const { return get_struct()->nd; }
  
  bitflag const get_flags() const;
  
  ndarray transpose() const;
  
  ndarray squeeze() const;
  
  ndarray reshape(python::tuple const & shape) const;
  
  python::object scalarize() const;
};

ndarray zeros(python::tuple const & shape, dtype const & dt);
ndarray zeros(int nd, Py_intptr_t const * shape, dtype const & dt);

ndarray empty(python::tuple const & shape, dtype const & dt);
ndarray empty(int nd, Py_intptr_t const * shape, dtype const & dt);

ndarray array(python::object const & obj);
ndarray array(python::object const & obj, dtype const & dt);

namespace detail 
{

ndarray from_data_impl(void * data,
                       dtype const & dt,
                       std::vector<Py_intptr_t> const & shape,
                       std::vector<Py_intptr_t> const & strides,
                       python::object const & owner,
                       bool writeable);

template <typename Container>
ndarray from_data_impl(void * data,
                       dtype const & dt,
                       Container shape,
                       Container strides,
                       python::object const & owner,
                       bool writeable,
                       typename boost::enable_if< boost::is_integral<typename Container::value_type> >::type * enabled = NULL)
{
  std::vector<Py_intptr_t> shape_(shape.begin(),shape.end());
  std::vector<Py_intptr_t> strides_(strides.begin(), strides.end());
  return from_data_impl(data, dt, shape_, strides_, owner, writeable);    
}

ndarray from_data_impl(void * data,
                       dtype const & dt,
                       python::object const & shape,
                       python::object const & strides,
                       python::object const & owner,
                       bool writeable);

} // namespace boost::numpy::detail

template <typename Container>
inline ndarray from_data(void * data,
                         dtype const & dt,
                         Container shape,
                         Container strides,
                         python::object const & owner)
{
  return numpy::detail::from_data_impl(data, dt, shape, strides, owner, true);
}    

template <typename Container>
inline ndarray from_data(void const * data,
                         dtype const & dt,
                         Container shape,
                         Container strides,
                         python::object const & owner)
{
  return numpy::detail::from_data_impl(const_cast<void*>(data), dt, shape, strides, owner, false);
}    

ndarray from_object(python::object const & obj, dtype const & dt, 
                    int nd_min, int nd_max, ndarray::bitflag flags=ndarray::NONE);

inline ndarray from_object(python::object const & obj, dtype const & dt, 
                           int nd, ndarray::bitflag flags=ndarray::NONE)
{
  return from_object(obj, dt, nd, nd, flags);
}

inline ndarray from_object(python::object const & obj, dtype const & dt, ndarray::bitflag flags=ndarray::NONE)
{
  return from_object(obj, dt, 0, 0, flags);
}

ndarray from_object(python::object const & obj, int nd_min, int nd_max, 
                    ndarray::bitflag flags=ndarray::NONE);

inline ndarray from_object(python::object const & obj, int nd, ndarray::bitflag flags=ndarray::NONE)
{
  return from_object(obj, nd, nd, flags);
}

inline ndarray from_object(python::object const & obj, ndarray::bitflag flags=ndarray::NONE)
{
  return from_object(obj, 0, 0, flags);
}

inline ndarray::bitflag operator|(ndarray::bitflag a, ndarray::bitflag b)
{
  return ndarray::bitflag(int(a) | int(b));
}

inline ndarray::bitflag operator&(ndarray::bitflag a, ndarray::bitflag b)
{
  return ndarray::bitflag(int(a) & int(b));
}

} // namespace boost::numpy

namespace python
{
namespace converter 
{

NUMPY_OBJECT_MANAGER_TRAITS(numpy::ndarray);

} // namespace boost::python::converter
} // namespace boost::python
} // namespace boost

#endif // !BOOST_NUMPY_NDARRAY_HPP_INCLUDED