Imported from /home/lorry/working-area/delta_boost-tarball/boost_1_54_0.tar.bz2.boost_1_54_0baserock/morph

1 files changed, 136 insertions, 0 deletions

diff --git a/libs/python/test/numpy.cpp b/libs/python/test/numpy.cpp
new file mode 100644
index 000000000..9472f92ed
--- /dev/null
+++ b/libs/python/test/numpy.cpp
@@ -0,0 +1,136 @@
+// Copyright David Abrahams 2002.
+// 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)
+
+#include <boost/python/numeric.hpp>
+#include <boost/python/tuple.hpp>
+#include <boost/python/module.hpp>
+#include <boost/python/def.hpp>
+#include <boost/python/str.hpp>
+
+using namespace boost::python;
+namespace py = boost::python;
+
+// See if we can invoke array() from C++
+numeric::array new_array()
+{
+    return numeric::array(
+        py::make_tuple(
+            py::make_tuple(1,2,3)
+          , py::make_tuple(4,5,6)
+          , py::make_tuple(7,8,9)
+            )
+        );
+}
+
+// test argument conversion
+void take_array(numeric::array /*x*/)
+{
+}
+
+// A separate function to invoke the info() member. Must happen
+// outside any doctests since this prints directly to stdout and the
+// result text includes the address of the 'self' array.
+void info(numeric::array const& z)
+{
+    z.info();
+}
+
+namespace
+{
+  object handle_error()
+  {
+      PyObject* type, *value, *traceback;                                 
+      PyErr_Fetch(&type, &value, &traceback);                             
+      handle<> ty(type), v(value), tr(traceback);
+      return object("exception");
+      str format("exception type: %sn");                                 
+      format += "exception value: %sn";                                  
+      format += "traceback:n%s" ;                                        
+      object ret = format % py::make_tuple(ty, v, tr);
+      return ret;
+  }
+}
+#define CHECK(expr)                                                         \
+{                                                                           \
+    object result;                                                          \
+    try { result = object(expr); }                                          \
+    catch(error_already_set)                                                \
+    {                                                                       \
+        result = handle_error();                                            \
+    }                                                                       \
+    check(result);                                                          \
+}
+
+// Tests which work on both Numeric and numarray array objects. Of
+// course all of the operators "just work" since numeric::array
+// inherits that behavior from object.
+void exercise(numeric::array& y, object check)
+{
+    y[py::make_tuple(2,1)] = 3;
+    CHECK(y);
+    CHECK(y.astype('D'));
+    CHECK(y.copy());
+    CHECK(y.typecode());
+}
+
+// numarray-specific tests.  check is a callable object which we can
+// use to record intermediate results, which are later compared with
+// the results of corresponding python operations.
+void exercise_numarray(numeric::array& y, object check)
+{
+    CHECK(str(y));
+    
+    CHECK(y.argmax());
+    CHECK(y.argmax(0));
+    
+    CHECK(y.argmin());
+    CHECK(y.argmin(0));
+    
+    CHECK(y.argsort());
+    CHECK(y.argsort(1));
+
+    y.byteswap();
+    CHECK(y);
+    
+    CHECK(y.diagonal());
+    CHECK(y.diagonal(1));
+    CHECK(y.diagonal(0, 0));
+    CHECK(y.diagonal(0, 1, 0));
+
+    CHECK(y.is_c_array());
+    CHECK(y.isbyteswapped());
+
+    CHECK(y.trace());
+    CHECK(y.trace(1));
+    CHECK(y.trace(0, 0));
+    CHECK(y.trace(0, 1, 0));
+
+    CHECK(y.new_("D").getshape());
+    CHECK(y.new_("D").type());
+    y.sort();
+    CHECK(y);
+    CHECK(y.type());
+
+    CHECK(y.factory(py::make_tuple(1.2, 3.4)));
+    CHECK(y.factory(py::make_tuple(1.2, 3.4), "f8"));
+    CHECK(y.factory(py::make_tuple(1.2, 3.4), "f8", true));
+    CHECK(y.factory(py::make_tuple(1.2, 3.4), "f8", true, false));
+    CHECK(y.factory(py::make_tuple(1.2, 3.4), "f8", true, false, object()));
+    CHECK (y.factory(py::make_tuple(1.2, 3.4), "f8", true, false, object(), py::make_tuple(1,2,1)));
+
+}
+
+BOOST_PYTHON_MODULE(numpy_ext)
+{
+    def("new_array", new_array);
+    def("take_array", take_array);
+    def("exercise", exercise);
+    def("exercise_numarray", exercise_numarray);
+    def("set_module_and_type", &numeric::array::set_module_and_type);
+    def("get_module_name", &numeric::array::get_module_name);
+    def("info", info);
+}
+
+#include "module_tail.cpp"