diff --git a/doc/numpy/reference/binary_ufunc.rst b/doc/numpy/reference/binary_ufunc.rst
index 988df2e9..041a4263 100644
--- a/doc/numpy/reference/binary_ufunc.rst
+++ b/doc/numpy/reference/binary_ufunc.rst
@@ -90,6 +90,7 @@ Example(s)
----------
::
+
namespace p = boost::python;
namespace np = boost::python::numpy;
diff --git a/doc/numpy/reference/dtype.rst b/doc/numpy/reference/dtype.rst
index 6491dfd7..929a76af 100644
--- a/doc/numpy/reference/dtype.rst
+++ b/doc/numpy/reference/dtype.rst
@@ -82,6 +82,7 @@ Example(s)
----------
::
+
namespace p = boost::python;
namespace np = boost::python::numpy;
diff --git a/doc/numpy/reference/ndarray.rst b/doc/numpy/reference/ndarray.rst
index b22f0bbf..2b3ec2c4 100644
--- a/doc/numpy/reference/ndarray.rst
+++ b/doc/numpy/reference/ndarray.rst
@@ -353,6 +353,7 @@ Example(s)
----------
::
+
namespace p = boost::python;
namespace np = boost::python::numpy;
diff --git a/doc/numpy/reference/unary_ufunc.rst b/doc/numpy/reference/unary_ufunc.rst
index b1d88555..7f78da4c 100644
--- a/doc/numpy/reference/unary_ufunc.rst
+++ b/doc/numpy/reference/unary_ufunc.rst
@@ -86,6 +86,7 @@ Example(s)
----------
::
+
namespace p = boost::python;
namespace np = boost::python::numpy;
diff --git a/doc/numpy/tutorial/dtype.rst b/doc/numpy/tutorial/dtype.rst
index 34008d19..557e72ba 100644
--- a/doc/numpy/tutorial/dtype.rst
+++ b/doc/numpy/tutorial/dtype.rst
@@ -5,32 +5,32 @@ Here is a brief tutorial to show how to create ndarrays with built-in python dat
Like before, first get the necessary headers, setup the namespaces and initialize the Python runtime and numpy module::
- #include
- #include
+ #include
+ #include
- namespace p = boost::python;
- namespace np = boost::python::numpy;
+ namespace p = boost::python;
+ namespace np = boost::python::numpy;
- int main(int argc, char **argv)
- {
- Py_Initialize();
- np::initialize();
+ int main(int argc, char **argv)
+ {
+ Py_Initialize();
+ np::initialize();
Next, we create the shape and dtype. We use the get_builtin method to get the numpy dtype corresponding to the builtin C++ dtype
Here, we will create a 3x3 array passing a tuple with (3,3) for the size, and double as the data type ::
- p::tuple shape = p::make_tuple(3, 3);
- np::dtype dtype = np::dtype::get_builtin();
- np::ndarray a = np::zeros(shape, dtype);
+ p::tuple shape = p::make_tuple(3, 3);
+ np::dtype dtype = np::dtype::get_builtin();
+ np::ndarray a = np::zeros(shape, dtype);
Finally, we can print the array using the extract method in the python namespace.
Here, we first convert the variable into a string, and then extract it as a C++ character array from the python string using the template ::
- std::cout << "Original array:\n" << p::extract(p::str(a)) << std::endl;
+ std::cout << "Original array:\n" << p::extract(p::str(a)) << std::endl;
We can also print the dtypes of the data members of the ndarray by using the get_dtype method for the ndarray ::
- std::cout << "Datatype is:\n" << p::extract(p::str(a.get_dtype())) << std::endl ;
+ std::cout << "Datatype is:\n" << p::extract(p::str(a.get_dtype())) << std::endl ;
We can also create custom dtypes and build ndarrays with the custom dtypes
@@ -40,16 +40,15 @@ The list should contain one or more tuples of the format (variable name, variabl
So first create a tuple with a variable name and its dtype, double, to create a custom dtype ::
- p::tuple for_custom_dtype = p::make_tuple("ha",dtype) ;
+ p::tuple for_custom_dtype = p::make_tuple("ha",dtype) ;
Next, create a list, and add this tuple to the list. Then use the list to create the custom dtype ::
- p::list list_for_dtype ;
- list_for_dtype.append(for_custom_dtype) ;
- np::dtype custom_dtype = np::dtype(list_for_dtype) ;
+ p::list list_for_dtype ;
+ list_for_dtype.append(for_custom_dtype) ;
+ np::dtype custom_dtype = np::dtype(list_for_dtype) ;
We are now ready to create an ndarray with dimensions specified by \*shape\* and of custom dtpye ::
- np::ndarray new_array = np::zeros(shape,custom_dtype);
-
- }
+ np::ndarray new_array = np::zeros(shape,custom_dtype);
+ }
diff --git a/doc/numpy/tutorial/fromdata.rst b/doc/numpy/tutorial/fromdata.rst
index 4f18997e..33bcee45 100644
--- a/doc/numpy/tutorial/fromdata.rst
+++ b/doc/numpy/tutorial/fromdata.rst
@@ -6,46 +6,51 @@ The from_data method makes this possible.
Like before, first get the necessary headers, setup the namespaces and initialize the Python runtime and numpy module::
- #include
- #include
+ #include
+ #include
- namespace p = boost::python;
- namespace np = boost::python::numpy;
+ namespace p = boost::python;
+ namespace np = boost::python::numpy;
- int main(int argc, char **argv)
- {
- Py_Initialize();
- np::initialize();
+ int main(int argc, char **argv)
+ {
+ Py_Initialize();
+ np::initialize();
Create an array in C++ , and pass the pointer to it to the from_data method to create an ndarray::
- int arr[] = {1,2,3,4,5} ;
- np::ndarray py_array = np::from_data(arr, np::dtype::get_builtin() , p::make_tuple(5), p::make_tuple(sizeof(int)), p::object());
+ int arr[] = {1,2,3,4,5};
+ np::ndarray py_array = np::from_data(arr, np::dtype::get_builtin(),
+ p::make_tuple(5),
+ p::make_tuple(sizeof(int)),
+ p::object());
Print the source C++ array, as well as the ndarray, to check if they are the same::
- std::cout << "C++ array :" << std::endl ;
- for (int j=0;j<4;j++)
- {
- std::cout << arr[j] << ' ' ;
- }
- std::cout << std::endl << "Python ndarray :" << p::extract(p::str(py_array)) << std::endl;
+ std::cout << "C++ array :" << std::endl;
+ for (int j=0;j<4;j++)
+ {
+ std::cout << arr[j] << ' ';
+ }
+ std::cout << std::endl
+ << "Python ndarray :" << p::extract(p::str(py_array)) << std::endl;
Now, change an element in the Python ndarray, and check if the value changed correspondingly in the source C++ array::
- py_array[1] = 5 ;
- std::cout << "Is the change reflected in the C++ array used to create the ndarray ? " << std::endl ;
- for (int j = 0; j < 5; j++)
- {
- std::cout << arr[j] << ' ' ;
- }
+ py_array[1] = 5 ;
+ std::cout << "Is the change reflected in the C++ array used to create the ndarray ? " << std::endl;
+ for (int j = 0; j < 5; j++)
+ {
+ std::cout << arr[j] << ' ';
+ }
Next, change an element of the source C++ array and see if it is reflected in the Python ndarray::
- arr[2] = 8 ;
- std::cout << std::endl << "Is the change reflected in the Python ndarray ?" << std::endl << p::extract(p::str(py_array)) << std::endl;
-
-}
+ arr[2] = 8;
+ std::cout << std::endl
+ << "Is the change reflected in the Python ndarray ?" << std::endl
+ << p::extract(p::str(py_array)) << std::endl;
+ }
As we can see, the changes are reflected across the ends. This happens because the from_data method passes the C++ array by reference to create the ndarray, and thus uses the same locations for storing data.
diff --git a/doc/numpy/tutorial/ndarray.rst b/doc/numpy/tutorial/ndarray.rst
index d944ae43..b270da70 100644
--- a/doc/numpy/tutorial/ndarray.rst
+++ b/doc/numpy/tutorial/ndarray.rst
@@ -8,87 +8,92 @@ This tutorial will introduce you to some of the ways in which you can create nda
First, as before, initialise the necessary namepaces and runtimes ::
- #include
- #include
+ #include
+ #include
- namespace p = boost::python;
- namespace np = boost::python::numpy;
+ namespace p = boost::python;
+ namespace np = boost::python::numpy;
- int main(int argc, char **argv)
- {
- Py_Initialize();
- np::initialize();
+ int main(int argc, char **argv)
+ {
+ Py_Initialize();
+ np::initialize();
Let's now create an ndarray from a simple tuple. We first create a tuple object, and then pass it to the array method, to generate the necessary tuple ::
- p::object tu = p::make_tuple('a','b','c') ;
- np::ndarray example_tuple = np::array(tu) ;
+ p::object tu = p::make_tuple('a','b','c');
+ np::ndarray example_tuple = np::array(tu);
Let's now try the same with a list. We create an empty list, add an element using the append method, and as before, call the array method ::
- p::list l ;
- l.append('a') ;
- np::ndarray example_list = np::array (l) ;
+ p::list l;
+ l.append('a');
+ np::ndarray example_list = np::array (l);
Optionally, we can also specify a dtype for the array ::
- np::dtype dt = np::dtype::get_builtin();
- np::ndarray example_list1 = np::array (l,dt);
+ np::dtype dt = np::dtype::get_builtin();
+ np::ndarray example_list1 = np::array (l,dt);
We can also create an array by supplying data arrays and a few other parameters.
First,create an integer array ::
- int data[] = {1,2,3,4,5} ;
+ int data[] = {1,2,3,4,5};
Create a shape, and strides, needed by the function ::
- p::tuple shape = p::make_tuple(5) ;
- p::tuple stride = p::make_tuple(sizeof(int)) ;
+ p::tuple shape = p::make_tuple(5);
+ p::tuple stride = p::make_tuple(sizeof(int));
Here, shape is (4,) , and the stride is `sizeof(int)``.
A stride is the number of bytes that must be traveled to get to the next desired element while constructing the ndarray.
The function also needs an owner, to keep track of the data array passed. Passing none is dangerous ::
- p::object own ;
+ p::object own;
The from_data function takes the data array, datatype,shape,stride and owner as arguments and returns an ndarray ::
- np::ndarray data_ex1 = np::from_data(data,dt, shape,stride,own);
+ np::ndarray data_ex1 = np::from_data(data,dt, shape,stride,own);
Now let's print the ndarray we created ::
- std::cout << "Single dimensional array ::" << std::endl << p::extract < char const * > (p::str(data_ex)) << std::endl ;
+ std::cout << "Single dimensional array ::" << std::endl
+ << p::extract(p::str(data_ex)) << std::endl;
Let's make it a little more interesting. Lets make an 3x2 ndarray from a multi-dimensional array using non-unit strides
First lets create a 3x4 array of 8-bit integers ::
- uint8_t mul_data[][4] = {{1,2,3,4},{5,6,7,8},{1,3,5,7}};
+ uint8_t mul_data[][4] = {{1,2,3,4},{5,6,7,8},{1,3,5,7}};
Now let's create an array of 3x2 elements, picking the first and third elements from each row . For that, the shape will be 3x2.
The strides will be 4x2 i.e. 4 bytes to go to the next desired row, and 2 bytes to go to the next desired column ::
- shape = p::make_tuple(3,2) ;
- stride = p::make_tuple(sizeof(uint8_t)*2,sizeof(uint8_t)) ;
+ shape = p::make_tuple(3,2);
+ stride = p::make_tuple(sizeof(uint8_t)*2,sizeof(uint8_t));
Get the numpy dtype for the built-in 8-bit integer data type ::
- np::dtype dt1 = np::dtype::get_builtin();
+ np::dtype dt1 = np::dtype::get_builtin();
Now lets first create and print out the ndarray as is.
Notice how we can pass the shape and strides in the function directly, as well as the owner. The last part can be done because we don't have any use to
manipulate the "owner" object ::
- np::ndarray mul_data_ex = np::from_data(mul_data,dt1, p::make_tuple(3,4),p::make_tuple(4,1),p::object());
- std::cout << "Original multi dimensional array :: " << std::endl << p::extract < char const * > (p::str(mul_data_ex)) << std::endl ;
+ np::ndarray mul_data_ex = np::from_data(mul_data, dt1,
+ p::make_tuple(3,4),
+ p::make_tuple(4,1),
+ p::object());
+ std::cout << "Original multi dimensional array :: " << std::endl
+ << p::extract(p::str(mul_data_ex)) << std::endl;
Now create the new ndarray using the shape and strides and print out the array we created using non-unit strides ::
- mul_data_ex = np::from_data(mul_data,dt1, shape,stride,p::object());
- std::cout << "Selective multidimensional array :: "< (p::str(mul_data_ex)) << std::endl ;
+ mul_data_ex = np::from_data(mul_data, dt1, shape, stride, p::object());
+ std::cout << "Selective multidimensional array :: "<(p::str(mul_data_ex)) << std::endl ;
+ }
-Note : The from_data method will throw "error_already_set" if the number of elements dictated by the shape and the corresponding strides don't match
-
-}
+.. note:: The from_data method will throw ``error_already_set`` if the number of elements dictated by the shape and the corresponding strides don't match.
diff --git a/doc/numpy/tutorial/ufunc.rst b/doc/numpy/tutorial/ufunc.rst
index 47acafb4..a3571dbc 100644
--- a/doc/numpy/tutorial/ufunc.rst
+++ b/doc/numpy/tutorial/ufunc.rst
@@ -35,82 +35,86 @@ Now we create the structs necessary to implement the ufuncs. The typedefs *must*
Initialise the Python runtime and the numpy module ::
int main(int argc, char **argv)
- {
- Py_Initialize();
- np::initialize();
+ {
+ Py_Initialize();
+ np::initialize();
Now expose the struct UnarySquare to Python as a class, and let ud be the class object. ::
- p::object ud = p::class_ >("UnarySquare")
- .def("__call__", np::unary_ufunc::make());
+ p::object ud = p::class_ >("UnarySquare");
+ ud.def("__call__", np::unary_ufunc::make());
Let inst be an instance of the class ud ::
- p::object inst = ud();
+ p::object inst = ud();
Use the "__call__" method to call the overloaded () operator and print the value ::
- std::cout << "Square of unary scalar 1.0 is " << p::extract (p::str(inst.attr("__call__")(1.0))) << std::endl ;
+ std::cout << "Square of unary scalar 1.0 is " << p::extract(p::str(inst.attr("__call__")(1.0))) << std::endl;
Create an array in C++ ::
- int arr[] = {1,2,3,4} ;
+ int arr[] = {1,2,3,4} ;
..and use it to create the ndarray in Python ::
- np::ndarray demo_array = np::from_data(arr, np::dtype::get_builtin() , p::make_tuple(4), p::make_tuple(4), p::object());
+ np::ndarray demo_array = np::from_data(arr, np::dtype::get_builtin(),
+ p::make_tuple(4),
+ p::make_tuple(4),
+ p::object());
Print out the demo array ::
- std::cout << "Demo array is " << p::extract (p::str(demo_array)) << std::endl ;
+ std::cout << "Demo array is " << p::extract(p::str(demo_array)) << std::endl;
Call the "__call__" method to perform the operation and assign the value to result_array ::
- p::object result_array = inst.attr("__call__")(demo_array) ;
+ p::object result_array = inst.attr("__call__")(demo_array);
Print the resultant array ::
- std::cout << "Square of demo array is " << p::extract (p::str(result_array)) << std::endl ;
+ std::cout << "Square of demo array is " << p::extract(p::str(result_array)) << std::endl;
Lets try the same with a list ::
- p::list li ;
- li.append(3);
- li.append(7);
+ p::list li;
+ li.append(3);
+ li.append(7);
Print out the demo list ::
- std::cout << "Demo list is " << p::extract (p::str(li)) << std::endl ;
+ std::cout << "Demo list is " << p::extract(p::str(li)) << std::endl;
Call the ufunc for the list ::
- result_array = inst.attr("__call__")(li) ;
+ result_array = inst.attr("__call__")(li);
And print the list out ::
- std::cout << "Square of demo list is " << p::extract (p::str(result_array)) << std::endl ;
+ std::cout << "Square of demo list is " << p::extract(p::str(result_array)) << std::endl;
Now lets try Binary ufuncs. Again, expose the struct BinarySquare to Python as a class, and let ud be the class object ::
- ud = p::class_ >("BinarySquare")
- .def("__call__", np::binary_ufunc::make());
+ ud = p::class_ >("BinarySquare");
+ ud.def("__call__", np::binary_ufunc::make());
And initialise ud ::
- inst = ud();
+ inst = ud();
Print the two input lists ::
- std::cout << "The two input list for binary ufunc are " << std::endl << p::extract (p::str(demo_array)) << std::endl << p::extract (p::str(demo_array)) << std::endl ;
+ std::cout << "The two input list for binary ufunc are " << std::endl
+ << p::extract(p::str(demo_array)) << std::endl
+ << p::extract(p::str(demo_array)) << std::endl;
Call the binary ufunc taking demo_array as both inputs ::
- result_array = inst.attr("__call__")(demo_array,demo_array) ;
+ result_array = inst.attr("__call__")(demo_array,demo_array);
And print the output ::
- std::cout << "Square of list with binary ufunc is " << p::extract (p::str(result_array)) << std::endl ;
-
-}
+ std::cout << "Square of list with binary ufunc is " << p::extract(p::str(result_array)) << std::endl;
+ }