GeezerVison is showing github.com — python/src/numpy/dtype.cpp at develop · boostorg/python

Expand file tree

dtype.cpp

Copy path

More file actions

Latest commit

History

201 lines (175 loc) · 6.48 KB

dtype.cpp

Copy path

File metadata and controls

201 lines (175 loc) · 6.48 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

// Copyright Jim Bosch 2010-2012.

// Copyright Stefan Seefeld 2016.

// 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)

#ifdef _MSC_VER

#include <boost/cstdint.hpp>

#endif

#define BOOST_PYTHON_NUMPY_INTERNAL

#include <boost/python/numpy/internal.hpp>

#define DTYPE_FROM_CODE(code) \

dtype(python::detail::new_reference(reinterpret_cast<PyObject*>(PyArray_DescrFromType(code))))

#define BUILTIN_INT_DTYPE(bits) \

template <> struct builtin_int_dtype<bits, false> \

{ \

static dtype get() { return DTYPE_FROM_CODE(NPY_INT ## bits);} \

}; \

template <> struct builtin_int_dtype<bits, true> \

{ \

static dtype get() { return DTYPE_FROM_CODE(NPY_UINT ## bits);} \

}; \

template BOOST_NUMPY_DECL dtype get_int_dtype<bits, false>(); \

template BOOST_NUMPY_DECL dtype get_int_dtype<bits, true>()

#define BUILTIN_FLOAT_DTYPE(bits) \

template <> struct builtin_float_dtype<bits> \

{ \

static dtype get() { return DTYPE_FROM_CODE(NPY_FLOAT ## bits);} \

}; \

template BOOST_NUMPY_DECL dtype get_float_dtype<bits>()

#define BUILTIN_COMPLEX_DTYPE(bits) \

template <> struct builtin_complex_dtype<bits> \

{ \

static dtype get() { return DTYPE_FROM_CODE(NPY_COMPLEX ## bits);} \

}; \

template BOOST_NUMPY_DECL dtype get_complex_dtype<bits>()

namespace boost { namespace python { namespace converter {

NUMPY_OBJECT_MANAGER_TRAITS_IMPL(PyArrayDescr_Type, numpy::dtype)

} // namespace boost::python::converter

namespace numpy {

namespace detail {

dtype builtin_dtype<bool,true>::get() { return DTYPE_FROM_CODE(NPY_BOOL); }

template <int bits, bool isUnsigned> struct builtin_int_dtype;

template <int bits> struct builtin_float_dtype;

template <int bits> struct builtin_complex_dtype;

template <int bits, bool isUnsigned> dtype get_int_dtype() {

return builtin_int_dtype<bits,isUnsigned>::get();

}

template <int bits> dtype get_float_dtype() { return builtin_float_dtype<bits>::get(); }

template <int bits> dtype get_complex_dtype() { return builtin_complex_dtype<bits>::get(); }

BUILTIN_INT_DTYPE(8);

BUILTIN_INT_DTYPE(16);

BUILTIN_INT_DTYPE(32);

BUILTIN_INT_DTYPE(64);

#ifdef NPY_FLOAT16

BUILTIN_FLOAT_DTYPE(16);

#endif

BUILTIN_FLOAT_DTYPE(32);

BUILTIN_FLOAT_DTYPE(64);

BUILTIN_COMPLEX_DTYPE(64);

BUILTIN_COMPLEX_DTYPE(128);

#if NPY_BITSOF_LONGDOUBLE > NPY_BITSOF_DOUBLE

template <> struct builtin_float_dtype< NPY_BITSOF_LONGDOUBLE > {

static dtype get() { return DTYPE_FROM_CODE(NPY_LONGDOUBLE); }

};

template dtype get_float_dtype< NPY_BITSOF_LONGDOUBLE >();

template <> struct builtin_complex_dtype< 2 * NPY_BITSOF_LONGDOUBLE > {

static dtype get() { return DTYPE_FROM_CODE(NPY_CLONGDOUBLE); }

};

template dtype get_complex_dtype< 2 * NPY_BITSOF_LONGDOUBLE >();

#endif

} // namespace detail

python::detail::new_reference dtype::convert(object const & arg, bool align)

{

PyArray_Descr* obj=NULL;

if (align)

{

if (PyArray_DescrAlignConverter(arg.ptr(), &obj) < 0)

throw_error_already_set();

}

else

{

if (PyArray_DescrConverter(arg.ptr(), &obj) < 0)

throw_error_already_set();

}

return python::detail::new_reference(reinterpret_cast<PyObject*>(obj));

}

int dtype::get_itemsize() const {

#if NPY_ABI_VERSION < 0x02000000

return reinterpret_cast<PyArray_Descr*>(ptr())->elsize;

#else

return PyDataType_ELSIZE(reinterpret_cast<PyArray_Descr*>(ptr()));

#endif

}

bool equivalent(dtype const & a, dtype const & b) {

return a == b;

}

namespace

{

namespace pyconv = boost::python::converter;

template <typename T>

class array_scalar_converter

{

public:

static PyTypeObject const * get_pytype()

{

// This implementation depends on the fact that get_builtin returns pointers to objects

// NumPy has declared statically, and that the typeobj member also refers to a static

// object. That means we don't need to do any reference counting.

// In fact, I'm somewhat concerned that increasing the reference count of any of these

// might cause leaks, because I don't think Boost.Python ever decrements it, but it's

// probably a moot point if everything is actually static.

return reinterpret_cast<PyArray_Descr*>(dtype::get_builtin<T>().ptr())->typeobj;

}

static void * convertible(PyObject * obj)

{

if (obj->ob_type == get_pytype())

{

return obj;

}

else

{

dtype dt(python::detail::borrowed_reference(obj->ob_type));

if (equivalent(dt, dtype::get_builtin<T>()))

{

return obj;

}

return 0;

}

static void convert(PyObject * obj, pyconv::rvalue_from_python_stage1_data* data)

{

void * storage = reinterpret_cast<pyconv::rvalue_from_python_storage<T>*>(data)->storage.bytes;

// We assume std::complex is a "standard layout" here and elsewhere; not guaranteed by

// C++03 standard, but true in every known implementation (and guaranteed by C++11).

PyArray_ScalarAsCtype(obj, reinterpret_cast<T*>(storage));

data->convertible = storage;

}

static void declare()

{

pyconv::registry::push_back(&convertible, &convert, python::type_id<T>()

#ifndef BOOST_PYTHON_NO_PY_SIGNATURES

, &get_pytype

#endif

);

}

};

} // anonymous

void dtype::register_scalar_converters()

{

array_scalar_converter<bool>::declare();

array_scalar_converter<npy_uint8>::declare();

array_scalar_converter<npy_int8>::declare();

array_scalar_converter<npy_uint16>::declare();

array_scalar_converter<npy_int16>::declare();

array_scalar_converter<npy_uint32>::declare();

array_scalar_converter<npy_int32>::declare();

#ifdef _MSC_VER

// Since the npy_(u)int32 types are defined as long types and treated

// as being different from the int32 types, these converters must be declared

// explicitely.

array_scalar_converter<boost::uint32_t>::declare();

array_scalar_converter<boost::int32_t>::declare();

#endif

array_scalar_converter<npy_uint64>::declare();

array_scalar_converter<npy_int64>::declare();

array_scalar_converter<float>::declare();

array_scalar_converter<double>::declare();

array_scalar_converter< std::complex<float> >::declare();

array_scalar_converter< std::complex<double> >::declare();

#if NPY_BITSOF_LONGDOUBLE > NPY_BITSOF_DOUBLE

array_scalar_converter<long double>::declare();

array_scalar_converter< std::complex<long double> >::declare();

#endif

}

}}} // namespace boost::python::numpy