python/include/boost/python/numpy/ndarray.hpp at develop · boostorg/python · GitHub

History

313 lines (261 loc) · 10.6 KB

Raw

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

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

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

#ifndef boost_python_numpy_ndarray_hpp_

#define boost_python_numpy_ndarray_hpp_

/**

* @brief Object manager and various utilities for numpy.ndarray.

#include <boost/python.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/python/detail/type_traits.hpp>

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

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

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

#include <vector>

namespace boost { namespace python { namespace numpy {

/**

* @brief A boost.python "object manager" (subclass of object) for numpy.ndarray.

* @todo This could have a lot more functionality (like boost::python::numeric::array).

* Right now all that exists is what was needed to move raw data between C++ and Python.

class BOOST_NUMPY_DECL ndarray : public object

{

/**

* @brief An internal struct that's byte-compatible with PyArrayObject.

* This is just a hack to allow inline access to this stuff while hiding numpy/arrayobject.h

* from the user.

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;

};

/// @brief Return the held Python object as an array_struct.

array_struct * get_struct() const { return reinterpret_cast<array_struct*>(this->ptr()); }

public:

/**

* @brief Enum to represent (some) of Numpy's internal flags.

* These don't match the actual Numpy flag values; we can't get those without including

* numpy/arrayobject.h or copying them directly. That's very unfortunate.

* @todo I'm torn about whether this should be an enum. It's very convenient to not

* make these simple integer values for overloading purposes, but the need to

* define every possible combination and custom bitwise operators is ugly.

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

/// @brief Return a view of the scalar with the given dtype.

ndarray view(dtype const & dt) const;

/// @brief Copy the array, cast to a specified type.

ndarray astype(dtype const & dt) const;

/// @brief Copy the scalar (deep for all non-object fields).

ndarray copy() const;

/// @brief Return the size of the nth dimension. raises IndexError if k not in [-get_nd() : get_nd()-1 ]

Py_intptr_t shape(int n) const;

/// @brief Return the stride of the nth dimension. raises IndexError if k not in [-get_nd() : get_nd()-1]

Py_intptr_t strides(int n) const;

/**

* @brief Return the array's raw data pointer.

* This returns char so stride math works properly on it. It's pretty much

* expected that the user will have to reinterpret_cast it.

char * get_data() const { return get_struct()->data; }

/// @brief Return the array's data-type descriptor object.

dtype get_dtype() const;

/// @brief Return the object that owns the array's data, or None if the array owns its own data.

object get_base() const;

/// @brief Set the object that owns the array's data. Use with care.

void set_base(object const & base);

/// @brief Return the shape of the array as an array of integers (length == get_nd()).

Py_intptr_t const * get_shape() const { return get_struct()->shape; }

/// @brief Return the stride of the array as an array of integers (length == get_nd()).

Py_intptr_t const * get_strides() const { return get_struct()->strides; }

/// @brief Return the number of array dimensions.

int get_nd() const { return get_struct()->nd; }

/// @brief Return the array flags.

bitflag get_flags() const;

/// @brief Reverse the dimensions of the array.

ndarray transpose() const;

/// @brief Eliminate any unit-sized dimensions.

ndarray squeeze() const;

/// @brief Equivalent to self.reshape(*shape) in Python.

ndarray reshape(python::tuple const & shape) const;

/**

* @brief If the array contains only a single element, return it as an array scalar; otherwise return

* the array.

* @internal This is simply a call to PyArray_Return();

object scalarize() const;

};

/**

* @brief Construct a new array with the given shape and data type, with data initialized to zero.

BOOST_NUMPY_DECL ndarray zeros(python::tuple const & shape, dtype const & dt);

BOOST_NUMPY_DECL ndarray zeros(int nd, Py_intptr_t const * shape, dtype const & dt);

/**

* @brief Construct a new array with the given shape and data type, with data left uninitialized.

BOOST_NUMPY_DECL ndarray empty(python::tuple const & shape, dtype const & dt);

BOOST_NUMPY_DECL ndarray empty(int nd, Py_intptr_t const * shape, dtype const & dt);

/**

* @brief Construct a new array from an arbitrary Python sequence.

* @todo This does't seem to handle ndarray subtypes the same way that "numpy.array" does in Python.

BOOST_NUMPY_DECL ndarray array(object const & obj);

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

namespace detail

{

BOOST_NUMPY_DECL ndarray from_data_impl(void * data,

dtype const & dt,

std::vector<Py_intptr_t> const & shape,

std::vector<Py_intptr_t> const & strides,

object const & owner,

bool writeable);

template <typename Container>

ndarray from_data_impl(void * data,

dtype const & dt,

Container shape,

Container strides,

object const & owner,

bool writeable,

typename boost::enable_if< boost::python::detail::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);

}

BOOST_NUMPY_DECL ndarray from_data_impl(void * data,

dtype const & dt,

object const & shape,

object const & strides,

object const & owner,

bool writeable);

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

/**

* @brief Construct a new ndarray object from a raw pointer.

* @param[in] data Raw pointer to the first element of the array.

* @param[in] dt Data type descriptor. Often retrieved with dtype::get_builtin().

* @param[in] shape Shape of the array as STL container of integers; must have begin() and end().

* @param[in] strides Shape of the array as STL container of integers; must have begin() and end().

* @param[in] owner An arbitray Python object that owns that data pointer. The array object will

* keep a reference to the object, and decrement it's reference count when the

* array goes out of scope. Pass None at your own peril.

* @todo Should probably take ranges of iterators rather than actual container objects.

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

}

/**

* @brief Construct a new ndarray object from a raw pointer.

* @param[in] data Raw pointer to the first element of the array.

* @param[in] dt Data type descriptor. Often retrieved with dtype::get_builtin().

* @param[in] shape Shape of the array as STL container of integers; must have begin() and end().

* @param[in] strides Shape of the array as STL container of integers; must have begin() and end().

* @param[in] owner An arbitray Python object that owns that data pointer. The array object will

* keep a reference to the object, and decrement it's reference count when the

* array goes out of scope. Pass None at your own peril.

* This overload takes a const void pointer and sets the "writeable" flag of the array to false.

* @todo Should probably take ranges of iterators rather than actual container objects.

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

}

/**

* @brief Transform an arbitrary object into a numpy array with the given requirements.

* @param[in] obj An arbitrary python object to convert. Arrays that meet the requirements

* will be passed through directly.

* @param[in] dt Data type descriptor. Often retrieved with dtype::get_builtin().

* @param[in] nd_min Minimum number of dimensions.

* @param[in] nd_max Maximum number of dimensions.

* @param[in] flags Bitwise OR of flags specifying additional requirements.

BOOST_NUMPY_DECL ndarray from_object(object const & obj,

dtype const & dt,

int nd_min,

int nd_max,

ndarray::bitflag flags=ndarray::NONE);

BOOST_NUMPY_DECL inline ndarray from_object(object const & obj,

dtype const & dt,

int nd,

ndarray::bitflag flags=ndarray::NONE)

{

return from_object(obj, dt, nd, nd, flags);

}

BOOST_NUMPY_DECL inline ndarray from_object(object const & obj,

dtype const & dt,

ndarray::bitflag flags=ndarray::NONE)

{

return from_object(obj, dt, 0, 0, flags);

}

BOOST_NUMPY_DECL ndarray from_object(object const & obj,

int nd_min,

int nd_max,

ndarray::bitflag flags=ndarray::NONE);

BOOST_NUMPY_DECL inline ndarray from_object(object const & obj,

int nd,

ndarray::bitflag flags=ndarray::NONE)

{

return from_object(obj, nd, nd, flags);

}

BOOST_NUMPY_DECL inline ndarray from_object(object const & obj,

ndarray::bitflag flags=ndarray::NONE)

{

return from_object(obj, 0, 0, flags);

}

BOOST_NUMPY_DECL inline ndarray::bitflag operator|(ndarray::bitflag a,

ndarray::bitflag b)

{

return ndarray::bitflag(int(a) | int(b));

}

BOOST_NUMPY_DECL inline ndarray::bitflag operator&(ndarray::bitflag a,

ndarray::bitflag b)

{

return ndarray::bitflag(int(a) & int(b));

}

} // namespace boost::python::numpy

namespace converter

{

NUMPY_OBJECT_MANAGER_TRAITS(numpy::ndarray);

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

#endif

python/include/boost/python/numpy/ndarray.hpp at develop · boostorg/python · GitHub

Uh oh!

Expand file tree

Breadcrumbs

ndarray.hpp

Latest commit

History

Breadcrumbs

ndarray.hpp

File metadata and controls