###

# (NumPy)

# unary_ufunc

Table of Contents

- unary_ufunc
  - synopsis
  - constructors
  - accessors
  - Example(s)

A `unary_ufunc` is a struct used as an intermediate step to broadcast a single argument so that a C++ function can be converted to a ufunc like function

> `<boost/python/numpy/ufunc.hpp>` contains the `unary_ufunc` structure definitions

## synopsis

    namespace boost
    {
    namespace python
    {
    namespace numpy
    {

    template <typename TUnaryFunctor,
              typename TArgument=typename TUnaryFunctor::argument_type,
              typename TResult=typename TUnaryFunctor::result_type>
    struct unary_ufunc
    {

      static object call(TUnaryFunctor & self,
                         object const & input,
                         object const & output) ;

      static object make();

    };
    }
    }
    }

## constructors

    struct example_unary_ufunc
    {
      typedef any_valid_type argument_type;
      typedef any_valid_type result_type;
    };

Requirements: | The `any_valid` type must be defined using typedef as a valid C++ type in order to use the struct methods correctly
Note: | The struct must be exposed as a Python class, and an instance of the class must be created to use the `call` method corresponding to the `__call__` attribute of the Python object

## accessors

    template <typename TUnaryFunctor,
              typename TArgument=typename TUnaryFunctor::argument_type,
              typename TResult=typename TUnaryFunctor::result_type>
    static object call(TUnaryFunctor & self,
                       object const & input,
                       object const & output);

Requires: | Typenames `TUnaryFunctor` and optionally `TArgument` for argument type and `TResult` for result type
Effects: | Passes a Python object to the underlying C++ functor after broadcasting its arguments

    template <typename TUnaryFunctor,
              typename TArgument=typename TUnaryFunctor::argument_type,
              typename TResult=typename TUnaryFunctor::result_type>
    static object make();

Requires: | Typenames `TUnaryFunctor` and optionally `TArgument` for argument type and `TResult` for result type
Returns: | A Python function object to call the overloaded () operator in the struct (in typical usage)

## Example(s)

    namespace p = boost::python;
    namespace np = boost::python::numpy;

    struct UnarySquare
    {
      typedef double argument_type;
      typedef double result_type;
      double operator()(double r) const { return r * r;}
    };

    p::object ud = p::class_<UnarySquare, boost::shared_ptr<UnarySquare> >("UnarySquare").def("__call__", np::unary_ufunc<UnarySquare>::make());
    p::object inst = ud();
    std::cout << "Square of unary scalar 1.0 is " << p::extract <char const * > (p::str(inst.attr("__call__")(1.0))) << std::endl ;