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

 #ifndef NUMARRAY_DWA2002922_HPP

 # define NUMARRAY_DWA2002922_HPP

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

 # include <boost/python/tuple.hpp>

 # include <boost/python/str.hpp>

 # include <boost/preprocessor/iteration/local.hpp>

 # include <boost/preprocessor/cat.hpp>

 # include <boost/preprocessor/repetition/enum.hpp>

 # include <boost/preprocessor/repetition/enum_params.hpp>

 # include <boost/preprocessor/repetition/enum_binary_params.hpp>

 namespace boost { namespace python { namespace numeric {

 class array;

 namespace aux

 {

   struct BOOST_PYTHON_DECL array_base : object

   {

 # define BOOST_PP_LOCAL_MACRO(n)                                \

       array_base(BOOST_PP_ENUM_PARAMS_Z(1, n, object const& x));

 # define BOOST_PP_LOCAL_LIMITS (1, 7)

 # include BOOST_PP_LOCAL_ITERATE()

       object argmax(long axis=-1);

       object argmin(long axis=-1);

       object argsort(long axis=-1);

       object astype(object const& type = object());

       void byteswap();

       object copy() const;

       object diagonal(long offset = 0, long axis1 = 0, long axis2 = 1) const;

       void info() const;

       bool is_c_array() const;

       bool isbyteswapped() const;

       array new_(object type) const;

       void sort();

       object trace(long offset = 0, long axis1 = 0, long axis2 = 1) const;

       object type() const;

       char typecode() const;

       object factory(

           object const& sequence = object()

         , object const& typecode = object()

         , bool copy = true

         , bool savespace = false

         , object type = object()

         , object shape = object());

       object getflat() const;

       long getrank() const;

       object getshape() const;

       bool isaligned() const;

       bool iscontiguous() const;

       long itemsize() const;

       long nelements() const;

       object nonzero() const;

       void put(object const& indices, object const& values);

       void ravel();

       object repeat(object const& repeats, long axis=0);

       void resize(object const& shape);

       void setflat(object const& flat);

       void setshape(object const& shape);

       void swapaxes(long axis1, long axis2);

       object take(object const& sequence, long axis = 0) const;

       void tofile(object const& file) const;

       str tostring() const;

       void transpose(object const& axes = object());

       object view() const;

    public: // implementation detail - do not touch.

       BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(array_base, object);

   };

   struct BOOST_PYTHON_DECL array_object_manager_traits

   {

       static bool check(PyObject* obj);

       static detail::new_non_null_reference adopt(PyObject* obj);

   };

 } // namespace aux

 class array : public aux::array_base

 {

     typedef aux::array_base base;

  public:

     object astype() { return base::astype(); }

     template <class Type>

     object astype(Type const& type_)

     {

         return base::astype(object(type_));

     }

     template <class Type>

     array new_(Type const& type_) const

     {

         return base::new_(object(type_));

     }

     template <class Sequence>

     void resize(Sequence const& x)

     {

         base::resize(object(x));

     }

 # define BOOST_PP_LOCAL_MACRO(n)                                \

       void resize(BOOST_PP_ENUM_PARAMS_Z(1, n, long x))              \

       {                                                         \

           resize(make_tuple(BOOST_PP_ENUM_PARAMS_Z(1, n, x)));       \

       }

 # define BOOST_PP_LOCAL_LIMITS (1, BOOST_PYTHON_MAX_ARITY)

 # include BOOST_PP_LOCAL_ITERATE()

     template <class Sequence>

     void setshape(Sequence const& x)

     {

         base::setshape(object(x));

     }

 # define BOOST_PP_LOCAL_MACRO(n)                                \

     void setshape(BOOST_PP_ENUM_PARAMS_Z(1, n, long x))              \

     {                                                           \

         setshape(make_tuple(BOOST_PP_ENUM_PARAMS_Z(1, n, x)));       \

     }

 # define BOOST_PP_LOCAL_LIMITS (1, BOOST_PYTHON_MAX_ARITY)

 # include BOOST_PP_LOCAL_ITERATE()

     template <class Indices, class Values>

     void put(Indices const& indices, Values const& values)

     {

         base::put(object(indices), object(values));

     }

     template <class Sequence>

     object take(Sequence const& sequence, long axis = 0)

     {

         return base::take(object(sequence), axis);

     }

     template <class File>

     void tofile(File const& f) const

     {

         base::tofile(object(f));

     }

     object factory()

     {

         return base::factory();

     }

     template <class Sequence>

     object factory(Sequence const& sequence)

     {

         return base::factory(object(sequence));

     }

     template <class Sequence, class Typecode>

     object factory(

         Sequence const& sequence

       , Typecode const& typecode_

       , bool copy = true

       , bool savespace = false

     )

     {

         return base::factory(object(sequence), object(typecode_), copy, savespace);

     }

     template <class Sequence, class Typecode, class Type>

     object factory(

         Sequence const& sequence

       , Typecode const& typecode_

       , bool copy

       , bool savespace

       , Type const& type

     )

     {

         return base::factory(object(sequence), object(typecode_), copy, savespace, object(type));

     }

     template <class Sequence, class Typecode, class Type, class Shape>

     object factory(

         Sequence const& sequence

       , Typecode const& typecode_

       , bool copy

       , bool savespace

       , Type const& type

       , Shape const& shape

     )

     {

         return base::factory(object(sequence), object(typecode_), copy, savespace, object(type), object(shape));

     }

 # define BOOST_PYTHON_ENUM_AS_OBJECT(z, n, x) object(BOOST_PP_CAT(x,n))

 # define BOOST_PP_LOCAL_MACRO(n)                                        \

     template <BOOST_PP_ENUM_PARAMS_Z(1, n, class T)>                    \

     explicit array(BOOST_PP_ENUM_BINARY_PARAMS_Z(1, n, T, const& x))    \

     : base(BOOST_PP_ENUM_1(n, BOOST_PYTHON_ENUM_AS_OBJECT, x))          \

     {}

 # define BOOST_PP_LOCAL_LIMITS (1, 7)

 # include BOOST_PP_LOCAL_ITERATE()

 # undef BOOST_PYTHON_AS_OBJECT

     static BOOST_PYTHON_DECL void set_module_and_type(char const* package_name = 0, char const* type_attribute_name = 0);

     static BOOST_PYTHON_DECL std::string get_module_name();

  public: // implementation detail -- for internal use only

     BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(array, base);

 };

 } // namespace boost::python::numeric

 namespace converter

 {

   template <>

   struct object_manager_traits< numeric::array >

       : numeric::aux::array_object_manager_traits

   {

       BOOST_STATIC_CONSTANT(bool, is_specialized = true);

   };

 }

 }} // namespace boost::python

 #endif // NUMARRAY_DWA2002922_HPP