num_util.h

Go to the documentation of this file.

#ifndef NUM_UTIL_H__
#define NUM_UTIL_H__

// Copyright 2006  Phil Austin (http://www.eos.ubc.ca/personal/paustin)
// 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)

//
// $Id: num_util.h,v 1.19 2009/08/04 23:34:01 pfkeb Exp $
//

#define PY_ARRAY_UNIQUE_SYMBOL HippoPyArrayHandle
#define NO_IMPORT_ARRAY

// for have numarray etc
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

//#define PY_ARRAY_UNIQUE_SYMBOL PyArrayHandle
#define NO_IMPORT_ARRAY


#include <boost/python.hpp>

#ifdef HAVE_NUMPY
#define NPY_NO_PREFIX
#include <numpy/arrayobject.h>
typedef int intp;
#else
#ifdef HAVE_NUMERIC
#include <Numeric/arrayobject.h>
#else
#include <numarray/arrayobject.h
typedef int intp;
#endif
#endif

#include <iostream>
#include <sstream>
#include <vector>
#include <numeric>
#include <map>
#include <complex>



namespace num_util{

  boost::python::numeric::array makeNum(boost::python::object x);

  boost::python::numeric::array makeNum(intp n, PyArray_TYPES t);

  boost::python::numeric::array makeNum(std::vector<int> dimens, 
                                        PyArray_TYPES t);
                                      
#ifdef HAVE_NUMPY
#ifdef _MSC_VER
  template <typename T>  PyArray_TYPES getEnum ();
#else
  template<typename T> PyArray_TYPES getEnum(void)
  {
    PyErr_SetString(PyExc_ValueError, "no mapping available for this type");
    boost::python::throw_error_already_set();
    return PyArray_VOID;
  }
#endif
#else
  template <typename T>  PyArray_TYPES getEnum ();
#endif

  template <typename T> boost::python::numeric::array makeNum(T* data, int n = 0){
    boost::python::object obj(boost::python::handle<>(PyArray_FromDims(1, &n, getEnum<T>())));
#ifdef HAVE_NUMPY
    void *arr_data = PyArray_DATA((PyArrayObject*) obj.ptr());
    memcpy(arr_data, data, PyArray_ITEMSIZE((PyArrayObject*) obj.ptr()) * n); // copies the input data to 
#else
  char *arr_data = ((PyArrayObject*) obj.ptr())->data; 
  memcpy(arr_data, data, sizeof(T) * n); // copies the input data to 
                                           // PyArrayObject->data
#endif

    return boost::python::extract<boost::python::numeric::array>(obj);
  }

  template <typename T> boost::python::numeric::array makeNum(T * data, std::vector<int> dims){
    intp total = std::accumulate(dims.begin(),dims.end(),1,std::multiplies<intp>());
    boost::python::object obj(boost::python::handle<>(PyArray_FromDims(dims.size(),&dims[0], getEnum<T>())));
#ifdef HAVE_NUMPY
    void *arr_data = PyArray_DATA((PyArrayObject*) obj.ptr());
    memcpy(arr_data, data, PyArray_ITEMSIZE((PyArrayObject*) obj.ptr()) * total);
#else
  char *arr_data = ((PyArrayObject*) obj.ptr())->data; 
  memcpy(arr_data, data, sizeof(T) * total); // copies the input data to 
                                           // PyArrayObject->data
#endif

    return boost::python::extract<boost::python::numeric::array>(obj);
  }

  template <>  boost::python::numeric::array makeNum<double> ( double * data,
                                                  std::vector < int>  dims );    

  boost::python::numeric::array makeNum(const 
                                        boost::python::numeric::array& arr);

  PyArray_TYPES type(boost::python::numeric::array arr);

  void check_type(boost::python::numeric::array arr, 
                  PyArray_TYPES expected_type);

  int rank(boost::python::numeric::array arr);

  void check_rank(boost::python::numeric::array arr, int expected_rank);
  
  intp size(boost::python::numeric::array arr);
  
  void check_size(boost::python::numeric::array arr, intp expected_size);

  std::vector<intptr_t> shape(boost::python::numeric::array arr);

  intp get_dim(boost::python::numeric::array arr, int dimnum);

  void check_shape(boost::python::numeric::array arr, 
                   std::vector<intp> expected_dims);

  void check_dim(boost::python::numeric::array arr, int dimnum, intp dimsize);

  bool iscontiguous(boost::python::numeric::array arr);

  void check_contiguous(boost::python::numeric::array arr);

  void* data(boost::python::numeric::array arr);

  void copy_data(boost::python::numeric::array arr, char* new_data);
  
  boost::python::numeric::array clone(boost::python::numeric::array arr);
  
  boost::python::numeric::array astype(boost::python::numeric::array arr, 
                                       PyArray_TYPES t);


/*    *Returns the reference count of the array. */
/*    *@param arr a Boost/Python numeric array. */
/*    *@return the reference count of the array. */

  int refcount(boost::python::numeric::array arr);

  std::vector<intp> strides(boost::python::numeric::array arr);

  void check_PyArrayElementType(boost::python::object newo);

  typedef std::map<PyArray_TYPES, std::string> KindStringMap;

  typedef std::map<PyArray_TYPES, char> KindCharMap;

  typedef std::map<char, PyArray_TYPES> KindTypeMap;

  std::string type2string(PyArray_TYPES t_type);

  char type2char(PyArray_TYPES t_type);
  
  PyArray_TYPES char2type(char e_type);

  template <class T>
  inline std::string vector_str(const std::vector<T>& vec);

  inline void check_size_match(std::vector<intp> dims, intp n);

} //  namespace num_util

#endif