%
% API Documentation for Peach - Computational Intelligence for Python
% Module peach.fuzzy.fuzzy
%
% Generated by epydoc 3.0beta1
% [Mon Dec 21 08:51:35 2009]
%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                          Module Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.fuzzy \textit{(module)}|(}
\section{Module peach.fuzzy.fuzzy}

    \label{peach:fuzzy:fuzzy}

This package implements basic definitions for fuzzy logic

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                               Variables                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsection{Variables}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright \_\-\_\-d\-o\-c\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt \texttt{...}}&\\
\cline{1-2}
\end{longtable}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                           Class Description                           %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.fuzzy \textit{(module)}!peach.fuzzy.fuzzy.FuzzySet \textit{(class)}|(}
\subsection{Class FuzzySet}

    \label{peach:fuzzy:fuzzy:FuzzySet}
\begin{tabular}{cccccccc}
% Line for object, linespec=[False, False]
\multicolumn{2}{r}{\settowidth{\BCL}{object}\multirow{2}{\BCL}{object}}
&&
&&
  \\\cline{3-3}
  &&\multicolumn{1}{c|}{}
&&
&&
  \\
% Line for numpy.ndarray, linespec=[False]
\multicolumn{4}{r}{\settowidth{\BCL}{numpy.ndarray}\multirow{2}{\BCL}{numpy.ndarray}}
&&
  \\\cline{5-5}
  &&&&\multicolumn{1}{c|}{}
&&
  \\
&&&&\multicolumn{2}{l}{\textbf{peach.fuzzy.fuzzy.FuzzySet}}
\end{tabular}

Array containing fuzzy values for a set.

This class defines the behavior of a fuzzy set. It is an array of values in
the range from 0 to 1, and the basic operations of the logic -{}- and (using
the \texttt{{\&}} operator); or (using the \texttt{|} operator); not (using \texttt{{\textasciitilde}}
operator) -{}- can be defined according to a set of norms. The norms can be
redefined using the appropriated methods.

To create a FuzzySet, instantiate this class with a sequence as argument,
for example:
\begin{quote}{\ttfamily \raggedright \noindent
fuzzy{\_}set~=~FuzzySet({[}~0.,~0.25,~0.5,~0.75,~1.0~{]})
}\end{quote}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                                Methods                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Methods}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_new\_\_}(\textit{cls}, \textit{data})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Allocates space for the array.

A fuzzy set is derived from the basic NumPy array, so the appropriate
functions and methods are called to allocate the space. In theory, the
values for a fuzzy set should be in the range \texttt{0.0 <= x <= 1.0}, but
to increase efficiency, no verification is made.
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}

A new array object with the fuzzy set definitions.
      \end{quote}

    \vspace{1ex}

      Overrides: numpy.ndarray.\_\_new\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_init\_\_}(\textit{self}, \textit{data}=\texttt{\texttt{[}\texttt{]}})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Initializes the object.

Operations are defaulted to Zadeh norms \texttt{(max, min, 1-x)}
    \vspace{1ex}

      Overrides: object.\_\_init\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_and\_\_}(\textit{self}, \textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Fuzzy and (\texttt{{\&}}) operation.
    \vspace{1ex}

      Overrides: numpy.ndarray.\_\_and\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_or\_\_}(\textit{self}, \textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Fuzzy or (\texttt{|}) operation.
    \vspace{1ex}

      Overrides: numpy.ndarray.\_\_or\_\_

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_invert\_\_}(\textit{self})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Fuzzy not (\texttt{{\textasciitilde}}) operation.
    \vspace{1ex}

      Overrides: numpy.ndarray.\_\_invert\_\_

    \end{boxedminipage}

    \label{peach:fuzzy:fuzzy:FuzzySet:set_norm}
    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.fuzzy \textit{(module)}!peach.fuzzy.fuzzy.FuzzySet \textit{(class)}!peach.fuzzy.fuzzy.FuzzySet.set\_norm \textit{(method)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{set\_norm}(\textit{self}, \textit{f})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Selects a t-norm (and operation)

Use this method to change the behaviour of the and operation.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{x}

          \item[f]

A function of two parameters which must return the \texttt{and} of the
values.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{peach:fuzzy:fuzzy:FuzzySet:set_conorm}
    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.fuzzy \textit{(module)}!peach.fuzzy.fuzzy.FuzzySet \textit{(class)}!peach.fuzzy.fuzzy.FuzzySet.set\_conorm \textit{(method)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{set\_conorm}(\textit{self}, \textit{f})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Selects a t-conorm (or operation)

Use this method to change the behaviour of the or operation.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{x}

          \item[f]

A function of two parameters which must return the \texttt{or} of the
values.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{peach:fuzzy:fuzzy:FuzzySet:set_negation}
    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.fuzzy \textit{(module)}!peach.fuzzy.fuzzy.FuzzySet \textit{(class)}!peach.fuzzy.fuzzy.FuzzySet.set\_negation \textit{(method)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{set\_negation}(\textit{self}, \textit{f})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Selects a negation (not operation)

Use this method to change the behaviour of the not operation.
    \vspace{1ex}

      \textbf{Parameters}
      \begin{quote}
        \begin{Ventry}{x}

          \item[f]

A function of one parameter which must return the \texttt{not} of the
value.
        \end{Ventry}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__abs__}
    \index{numpy.ndarray.\_\_abs\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_abs\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

abs(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__add__}
    \index{numpy.ndarray.\_\_add\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_add\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x+y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__array__}
    \index{numpy.ndarray.\_\_array\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_array\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

a.{\_}{\_}array{\_}{\_}({\color{red}\bfseries{}{\textbar}}dtype) -{\textgreater} reference if type unchanged, copy otherwise.

Returns either a new reference to self if dtype is not given or a new array
of provided data type if dtype is different from the current dtype of the
array.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__array_wrap__}
    \index{numpy.ndarray.\_\_array\_wrap\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_array\_wrap\_\_}(\textit{a}, \textit{obj})

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
Object of same type as a from ndarray obj.
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__contains__}
    \index{numpy.ndarray.\_\_contains\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_contains\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y in x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__copy__}
    \index{numpy.ndarray.\_\_copy\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_copy\_\_}(\textit{a}, \textit{order}=\texttt{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return a copy of the array.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{order}] (\textbf{{\{}'C', 'F', 'A'{\}}, optional})
%[visit_definition]

If order is 'C' (False) then the result is contiguous (default).
If order is 'Fortran' (True) then the result has fortran order.
If order is 'Any' (None) then the result has fortran order
only if the array already is in fortran order.

%[depart_definition]
%[depart_definition_list_item]
\end{description}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__deepcopy__}
    \index{numpy.ndarray.\_\_deepcopy\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_deepcopy\_\_}(\textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Used if copy.deepcopy is called on an array.
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
Deep copy of array
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__delattr__}
    \index{object.\_\_delattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}delattr{\_}{\_}('name') {\textless}=={\textgreater} del x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__delitem__}
    \index{numpy.ndarray.\_\_delitem\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delitem\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

del x{[}y{]}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__delslice__}
    \index{numpy.ndarray.\_\_delslice\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_delslice\_\_}(\textit{x}, \textit{i}, \textit{j})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

del x{[}i:j{]}

Use of negative indices is not supported.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__div__}
    \index{numpy.ndarray.\_\_div\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_div\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x/y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__divmod__}
    \index{numpy.ndarray.\_\_divmod\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_divmod\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

divmod(x, y)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__eq__}
    \index{numpy.ndarray.\_\_eq\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_eq\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x==y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__float__}
    \index{numpy.ndarray.\_\_float\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_float\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

float(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__floordiv__}
    \index{numpy.ndarray.\_\_floordiv\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_floordiv\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x//y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__ge__}
    \index{numpy.ndarray.\_\_ge\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_ge\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textgreater}=y
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__getattribute__}
    \index{object.\_\_getattribute\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getattribute\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}getattribute{\_}{\_}('name') {\textless}=={\textgreater} x.name
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__getitem__}
    \index{numpy.ndarray.\_\_getitem\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getitem\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{[}y{]}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__getslice__}
    \index{numpy.ndarray.\_\_getslice\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_getslice\_\_}(\textit{x}, \textit{i}, \textit{j})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{[}i:j{]}

Use of negative indices is not supported.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__gt__}
    \index{numpy.ndarray.\_\_gt\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_gt\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textgreater}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__hash__}
    \index{object.\_\_hash\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hash\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hash(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__hex__}
    \index{numpy.ndarray.\_\_hex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_hex\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

hex(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__iadd__}
    \index{numpy.ndarray.\_\_iadd\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_iadd\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x+y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__iand__}
    \index{numpy.ndarray.\_\_iand\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_iand\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\&}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__idiv__}
    \index{numpy.ndarray.\_\_idiv\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_idiv\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x/y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__ifloordiv__}
    \index{numpy.ndarray.\_\_ifloordiv\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_ifloordiv\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x//y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__ilshift__}
    \index{numpy.ndarray.\_\_ilshift\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_ilshift\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textless}{\textless}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__imod__}
    \index{numpy.ndarray.\_\_imod\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_imod\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\%}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__imul__}
    \index{numpy.ndarray.\_\_imul\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_imul\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x*y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__index__}
    \index{numpy.ndarray.\_\_index\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_index\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{[}y:z{]} {\textless}=={\textgreater} x{[}y.{\_}{\_}index{\_}{\_}():z.{\_}{\_}index{\_}{\_}(){]}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__int__}
    \index{numpy.ndarray.\_\_int\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_int\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

int(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__ior__}
    \index{numpy.ndarray.\_\_ior\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_ior\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textbar}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__ipow__}
    \index{numpy.ndarray.\_\_ipow\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_ipow\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x**y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__irshift__}
    \index{numpy.ndarray.\_\_irshift\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_irshift\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textgreater}{\textgreater}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__isub__}
    \index{numpy.ndarray.\_\_isub\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_isub\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x-y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__iter__}
    \index{numpy.ndarray.\_\_iter\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_iter\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

iter(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__itruediv__}
    \index{numpy.ndarray.\_\_itruediv\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_itruediv\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x/y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__ixor__}
    \index{numpy.ndarray.\_\_ixor\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_ixor\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textasciicircum}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__le__}
    \index{numpy.ndarray.\_\_le\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_le\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textless}=y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__len__}
    \index{numpy.ndarray.\_\_len\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_len\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

len(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__long__}
    \index{numpy.ndarray.\_\_long\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_long\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

long(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__lshift__}
    \index{numpy.ndarray.\_\_lshift\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_lshift\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textless}{\textless}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__lt__}
    \index{numpy.ndarray.\_\_lt\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_lt\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textless}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__mod__}
    \index{numpy.ndarray.\_\_mod\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_mod\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\%}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__mul__}
    \index{numpy.ndarray.\_\_mul\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_mul\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x*y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__ne__}
    \index{numpy.ndarray.\_\_ne\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_ne\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x!=y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__neg__}
    \index{numpy.ndarray.\_\_neg\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_neg\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

-x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__nonzero__}
    \index{numpy.ndarray.\_\_nonzero\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_nonzero\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x != 0
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__oct__}
    \index{numpy.ndarray.\_\_oct\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_oct\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

oct(x)
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__pos__}
    \index{numpy.ndarray.\_\_pos\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_pos\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

+x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__pow__}
    \index{numpy.ndarray.\_\_pow\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_pow\_\_}(\textit{x}, \textit{y}, \textit{z}=\texttt{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

pow(x, y{[}, z{]})
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__radd__}
    \index{numpy.ndarray.\_\_radd\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_radd\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y+x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rand__}
    \index{numpy.ndarray.\_\_rand\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rand\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y{\&}x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rdiv__}
    \index{numpy.ndarray.\_\_rdiv\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rdiv\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y/x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rdivmod__}
    \index{numpy.ndarray.\_\_rdivmod\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rdivmod\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

divmod(y, x)
    \vspace{1ex}

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_\_}(\textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

For pickling.
    \vspace{1ex}

      Overrides: object.\_\_reduce\_\_

    \end{boxedminipage}

    \label{object:__reduce_ex__}
    \index{object.\_\_reduce\_ex\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_reduce\_ex\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

helper for pickle
    \vspace{1ex}

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_repr\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

repr(x)
    \vspace{1ex}

      Overrides: object.\_\_repr\_\_

    \end{boxedminipage}

    \label{numpy:ndarray:__rfloordiv__}
    \index{numpy.ndarray.\_\_rfloordiv\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rfloordiv\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y//x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rlshift__}
    \index{numpy.ndarray.\_\_rlshift\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rlshift\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y{\textless}{\textless}x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rmod__}
    \index{numpy.ndarray.\_\_rmod\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rmod\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y{\%}x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rmul__}
    \index{numpy.ndarray.\_\_rmul\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rmul\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y*x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__ror__}
    \index{numpy.ndarray.\_\_ror\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_ror\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y{\textbar}x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rpow__}
    \index{numpy.ndarray.\_\_rpow\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rpow\_\_}(\textit{y}, \textit{x}, \textit{z}=\texttt{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

pow(x, y{[}, z{]})
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rrshift__}
    \index{numpy.ndarray.\_\_rrshift\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rrshift\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y{\textgreater}{\textgreater}x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rshift__}
    \index{numpy.ndarray.\_\_rshift\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rshift\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textgreater}{\textgreater}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rsub__}
    \index{numpy.ndarray.\_\_rsub\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rsub\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y-x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rtruediv__}
    \index{numpy.ndarray.\_\_rtruediv\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rtruediv\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y/x
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__rxor__}
    \index{numpy.ndarray.\_\_rxor\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_rxor\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

y{\textasciicircum}x
    \vspace{1ex}

    \end{boxedminipage}

    \label{object:__setattr__}
    \index{object.\_\_setattr\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setattr\_\_}(\textit{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x.{\_}{\_}setattr{\_}{\_}('name', value) {\textless}=={\textgreater} x.name = value
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__setitem__}
    \index{numpy.ndarray.\_\_setitem\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setitem\_\_}(\textit{x}, \textit{i}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{[}i{]}=y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__setslice__}
    \index{numpy.ndarray.\_\_setslice\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setslice\_\_}(\textit{x}, \textit{i}, \textit{j}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{[}i:j{]}=y

Use  of negative indices is not supported.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__setstate__}
    \index{numpy.ndarray.\_\_setstate\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_setstate\_\_}(\textit{a}, \textit{version}, \textit{shape}, \textit{dtype}, \textit{isfortran}, \textit{rawdata})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}
\begin{alltt}
For unpickling.

Parameters
----------
version : int
    optional pickle version. If omitted defaults to 0.
shape : tuple
dtype : data-type
isFortran : bool
rawdata : string or list
    a binary string with the data (or a list if 'a' is an object array)
\end{alltt}

    \vspace{1ex}

    \end{boxedminipage}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_str\_\_}(\textit{x})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

str(x)
    \vspace{1ex}

      Overrides: object.\_\_str\_\_

    \end{boxedminipage}

    \label{numpy:ndarray:__sub__}
    \index{numpy.ndarray.\_\_sub\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_sub\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x-y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__truediv__}
    \index{numpy.ndarray.\_\_truediv\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_truediv\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x/y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:__xor__}
    \index{numpy.ndarray.\_\_xor\_\_ \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{\_\_xor\_\_}(\textit{x}, \textit{y})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

x{\textasciicircum}y
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:all}
    \index{numpy.ndarray.all \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{all}(\textit{a}, \textit{axis}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Returns True if all elements evaluate to True.

Refer to \texttt{numpy.all} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.all : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:any}
    \index{numpy.ndarray.any \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{any}(\textit{a}, \textit{axis}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Check if any of the elements of \texttt{a} are true.

Refer to \texttt{numpy.any} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.any : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:argmax}
    \index{numpy.ndarray.argmax \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{argmax}(\textit{a}, \textit{axis}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return indices of the maximum values along the given axis of \texttt{a}.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{axis}] (\textbf{int, optional})
%[visit_definition]

Axis along which to operate.  By default flattened input is used.

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{out}] (\textbf{ndarray, optional})
%[visit_definition]

Alternative output array in which to place the result.  Must
be of the same shape and buffer length as the expected output.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{returns}{}
\pdfbookmark[3]{Returns}{returns}
\subsubsection*{Returns}
\begin{description}
%[visit_definition_list_item]
\item[{index{\_}array}] (\textbf{ndarray})
%[visit_definition]

An array of indices or single index value, or a reference to \texttt{out}
if it was specified.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.arange(6).reshape(2,3)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.argmax()
\pysrcoutput{5}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.argmax(0)
\pysrcoutput{array([1, 1, 1])}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.argmax(1)
\pysrcoutput{array([2, 2])}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:argmin}
    \index{numpy.ndarray.argmin \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{argmin}(\textit{a}, \textit{axis}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return indices of the minimum values along the given axis of \texttt{a}.

Refer to \texttt{numpy.ndarray.argmax} for detailed documentation.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:argsort}
    \index{numpy.ndarray.argsort \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{argsort}(\textit{a}, \textit{axis}=\texttt{-1}, \textit{kind}=\texttt{'quicksort'}, \textit{order}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Returns the indices that would sort this array.

Refer to \texttt{numpy.argsort} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.argsort : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:astype}
    \index{numpy.ndarray.astype \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{astype}(\textit{a}, \textit{t})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Copy of the array, cast to a specified type.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{t}] (\textbf{string or dtype})
%[visit_definition]

Typecode or data-type to which the array is cast.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }x = np.array([1, 2, 2.5])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }x
\pysrcoutput{array([ 1. ,  2. ,  2.5])}\end{alltt}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }x.astype(int)
\pysrcoutput{array([1, 2, 2])}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:byteswap}
    \index{numpy.ndarray.byteswap \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{byteswap}(\textit{a}, \textit{inplace})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Swap the bytes of the array elements

Toggle between low-endian and big-endian data representation by
returning a byteswapped array, optionally swapped in-place.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{inplace: bool, optional}] %[visit_definition]

If \texttt{True}, swap bytes in-place, default is \texttt{False}.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{returns}{}
\pdfbookmark[3]{Returns}{returns}
\subsubsection*{Returns}
\begin{description}
%[visit_definition_list_item]
\item[{out: ndarray}] %[visit_definition]

The byteswapped array. If \texttt{inplace} is \texttt{True}, this is
a view to self.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }A = np.array([1, 256, 8755], dtype=np.int16)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }map(hex, A)
\pysrcoutput{['0x1', '0x100', '0x2233']}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }A.byteswap(True)
\pysrcoutput{array([  256,     1, 13090], dtype=int16)}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }map(hex, A)
\pysrcoutput{['0x100', '0x1', '0x3322']}\end{alltt}

Arrays of strings are not swapped
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }A = np.array([\pysrcstring{'ceg'}, \pysrcstring{'fac'}])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }A.byteswap()
\pysrcoutput{array(['ceg', 'fac'],}
\pysrcoutput{      dtype='{\textbar}S3')}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:choose}
    \index{numpy.ndarray.choose \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{choose}(\textit{a}, \textit{choices}, \textit{out}=\texttt{None}, \textit{mode}=\texttt{'raise'})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Use an index array to construct a new array from a set of choices.

Refer to \texttt{numpy.choose} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.choose : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:clip}
    \index{numpy.ndarray.clip \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{clip}(\textit{a}, \textit{a\_min}, \textit{a\_max}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return an array whose values are limited to \texttt{{[}a{\_}min, a{\_}max{]}}.

Refer to \texttt{numpy.clip} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.clip : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:compress}
    \index{numpy.ndarray.compress \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{compress}(\textit{a}, \textit{condition}, \textit{axis}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return selected slices of this array along given axis.

Refer to \texttt{numpy.compress} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.compress : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:conj}
    \index{numpy.ndarray.conj \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{conj}(\textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return an array with all complex-valued elements conjugated.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:conjugate}
    \index{numpy.ndarray.conjugate \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{conjugate}(\textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return an array with all complex-valued elements conjugated.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:copy}
    \index{numpy.ndarray.copy \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{copy}(\textit{a}, \textit{order}=\texttt{'C'})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return a copy of the array.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{order}] (\textbf{{\{}'C', 'F', 'A'{\}}, optional})
%[visit_definition]

By default, the result is stored in C-contiguous (row-major) order in
memory.  If \texttt{order} is \texttt{F}, the result has 'Fortran' (column-major)
order.  If order is 'A' ('Any'), then the result has the same order
as the input.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }x = np.array([[1,2,3],[4,5,6]], order=\pysrcstring{'F'})\end{alltt}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }y = x.copy()\end{alltt}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }x.fill(0)\end{alltt}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }x
\pysrcoutput{array([[0, 0, 0],}
\pysrcoutput{       [0, 0, 0]])}\end{alltt}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }y
\pysrcoutput{array([[1, 2, 3],}
\pysrcoutput{       [4, 5, 6]])}\end{alltt}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }y.flags[\pysrcstring{'C\_CONTIGUOUS'}]
\pysrcoutput{True}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:cumprod}
    \index{numpy.ndarray.cumprod \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{cumprod}(\textit{a}, \textit{axis}=\texttt{None}, \textit{dtype}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return the cumulative product of the elements along the given axis.

Refer to \texttt{numpy.cumprod} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.cumprod : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:cumsum}
    \index{numpy.ndarray.cumsum \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{cumsum}(\textit{a}, \textit{axis}=\texttt{None}, \textit{dtype}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return the cumulative sum of the elements along the given axis.

Refer to \texttt{numpy.cumsum} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.cumsum : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:diagonal}
    \index{numpy.ndarray.diagonal \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{diagonal}(\textit{a}, \textit{offset}=\texttt{0}, \textit{axis1}=\texttt{0}, \textit{axis2}=\texttt{1})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return specified diagonals.

Refer to \texttt{numpy.diagonal} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.diagonal : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:dump}
    \index{numpy.ndarray.dump \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{dump}(\textit{a}, \textit{file})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Dump a pickle of the array to the specified file.
The array can be read back with pickle.load or numpy.load.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{file}] (\textbf{str})
%[visit_definition]

A string naming the dump file.

%[depart_definition]
%[depart_definition_list_item]
\end{description}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:dumps}
    \index{numpy.ndarray.dumps \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{dumps}(\textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Returns the pickle of the array as a string.
pickle.loads or numpy.loads will convert the string back to an array.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:fill}
    \index{numpy.ndarray.fill \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{fill}(\textit{a}, \textit{value})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Fill the array with a scalar value.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{a}] (\textbf{ndarray})
%[visit_definition]

Input array

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{value}] (\textbf{scalar})
%[visit_definition]

All elements of \texttt{a} will be assigned this value.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.array([1, 2])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.fill(0)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a
\pysrcoutput{array([0, 0])}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.empty(2)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.fill(1)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a
\pysrcoutput{array([ 1.,  1.])}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:flatten}
    \index{numpy.ndarray.flatten \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{flatten}(\textit{a}, \textit{order}=\texttt{'C'})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Collapse an array into one dimension.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{order}] (\textbf{{\{}'C', 'F'{\}}, optional})
%[visit_definition]

Whether to flatten in C (row-major) or Fortran (column-major) order.
The default is 'C'.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{returns}{}
\pdfbookmark[3]{Returns}{returns}
\subsubsection*{Returns}
\begin{description}
%[visit_definition_list_item]
\item[{y}] (\textbf{ndarray})
%[visit_definition]

A copy of the input array, flattened to one dimension.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.array([[1,2], [3,4]])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.flatten()
\pysrcoutput{array([1, 2, 3, 4])}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.flatten(\pysrcstring{'F'})
\pysrcoutput{array([1, 3, 2, 4])}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:getfield}
    \index{numpy.ndarray.getfield \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{getfield}(\textit{a}, \textit{dtype}, \textit{offset})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Returns a field of the given array as a certain type. A field is a view of
the array data with each itemsize determined by the given type and the
offset into the current array.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:item}
    \index{numpy.ndarray.item \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{item}(\textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Copy the first element of array to a standard Python scalar and return
it. The array must be of size one.
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:itemset}
    \index{numpy.ndarray.itemset \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{itemset}(\textit{...})

    \end{boxedminipage}

    \label{numpy:ndarray:max}
    \index{numpy.ndarray.max \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{max}(\textit{a}, \textit{axis}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return the maximum along a given axis.

Refer to \texttt{numpy.amax} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.amax : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:mean}
    \index{numpy.ndarray.mean \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{mean}(\textit{a}, \textit{axis}=\texttt{None}, \textit{dtype}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Returns the average of the array elements along given axis.

Refer to \texttt{numpy.mean} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.mean : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:min}
    \index{numpy.ndarray.min \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{min}(\textit{a}, \textit{axis}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return the minimum along a given axis.

Refer to \texttt{numpy.amin} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.amin : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:newbyteorder}
    \index{numpy.ndarray.newbyteorder \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{newbyteorder}(\textit{a}, \textit{byteorder})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Equivalent to a.view(a.dtype.newbytorder(byteorder))
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:nonzero}
    \index{numpy.ndarray.nonzero \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{nonzero}(\textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return the indices of the elements that are non-zero.

Refer to \texttt{numpy.nonzero} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.nonzero : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:prod}
    \index{numpy.ndarray.prod \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{prod}(\textit{a}, \textit{axis}=\texttt{None}, \textit{dtype}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return the product of the array elements over the given axis

Refer to \texttt{numpy.prod} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.prod : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:ptp}
    \index{numpy.ndarray.ptp \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{ptp}(\textit{a}, \textit{axis}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Peak to peak (maximum - minimum) value along a given axis.

Refer to \texttt{numpy.ptp} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.ptp : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:put}
    \index{numpy.ndarray.put \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{put}(\textit{a}, \textit{indices}, \textit{values}, \textit{mode}=\texttt{'raise'})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Set a.flat{[}n{]} = values{[}n{]} for all n in indices.

Refer to \texttt{numpy.put} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.put : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:ravel}
    \index{numpy.ndarray.ravel \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{ravel}(\textit{a}, \textit{order}=\texttt{...})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return a flattened array.

Refer to \texttt{numpy.ravel} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.ravel : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:repeat}
    \index{numpy.ndarray.repeat \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{repeat}(\textit{a}, \textit{repeats}, \textit{axis}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Repeat elements of an array.

Refer to \texttt{numpy.repeat} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.repeat : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:reshape}
    \index{numpy.ndarray.reshape \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{reshape}(\textit{a}, \textit{shape}, \textit{order}=\texttt{'C'})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Returns an array containing the same data with a new shape.

Refer to \texttt{numpy.reshape} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.reshape : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:resize}
    \index{numpy.ndarray.resize \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{resize}(\textit{a}, \textit{new\_shape}, \textit{refcheck}=\texttt{True}, \textit{order}=\texttt{False})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Change shape and size of array in-place.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{a}] (\textbf{ndarray})
%[visit_definition]

Input array.

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{new{\_}shape}] (\textbf{{\{}tuple, int{\}}})
%[visit_definition]

Shape of resized array.

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{refcheck}] (\textbf{bool, optional})
%[visit_definition]

If False, memory referencing will not be checked. Default is True.

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{order}] (\textbf{bool, optional})
%[visit_definition]

{\textless}needs an explanation{\textgreater}. Default if False.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{returns}{}
\pdfbookmark[3]{Returns}{returns}
\subsubsection*{Returns}

None

%___________________________________________________________________________

\hypertarget{raises}{}
\pdfbookmark[3]{Raises}{raises}
\subsubsection*{Raises}
\begin{description}
%[visit_definition_list_item]
\item[{ValueError}] %[visit_definition]

If \texttt{a} does not own its own data, or references or views to it exist.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}

Shrinking an array: array is flattened in C-order, resized, and reshaped:
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.array([[0,1],[2,3]])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.resize((2,1))
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a
\pysrcoutput{array([[0],}
\pysrcoutput{       [1]])}\end{alltt}

Enlarging an array: as above, but missing entries are filled with zeros:
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }b = np.array([[0,1],[2,3]])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }b.resize((2,3))
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }b
\pysrcoutput{array([[0, 1, 2],}
\pysrcoutput{       [3, 0, 0]])}\end{alltt}

Referencing an array prevents resizing:
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }c = a
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.resize((1,1))
\pysrcexcept{Traceback (most recent call last):}
\pysrcexcept{...}
\pysrcexcept{ValueError: cannot resize an array that has been referenced ...}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:round}
    \index{numpy.ndarray.round \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{round}(\textit{a}, \textit{decimals}=\texttt{0}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return an array rounded a to the given number of decimals.

Refer to \texttt{numpy.around} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.around : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:searchsorted}
    \index{numpy.ndarray.searchsorted \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{searchsorted}(\textit{a}, \textit{v}, \textit{side}=\texttt{'left'})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Find indices where elements of v should be inserted in a to maintain order.

For full documentation, see \texttt{numpy.searchsorted}

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.searchsorted : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:setfield}
    \index{numpy.ndarray.setfield \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{setfield}(\textit{m}, \textit{value}, \textit{dtype}, \textit{offset})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

places val into field of the given array defined by the data type and offset.
    \vspace{1ex}

      \textbf{Return Value}
      \begin{quote}
\begin{alltt}
None
\end{alltt}

      \end{quote}

    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:setflags}
    \index{numpy.ndarray.setflags \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{setflags}(\textit{a}, \textit{write}=\texttt{None}, \textit{align}=\texttt{None}, \textit{uic}=\texttt{None})

    \end{boxedminipage}

    \label{numpy:ndarray:sort}
    \index{numpy.ndarray.sort \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{sort}(\textit{a}, \textit{axis}=\texttt{-1}, \textit{kind}=\texttt{'quicksort'}, \textit{order}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Sort an array, in-place.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{axis}] (\textbf{int, optional})
%[visit_definition]

Axis along which to sort. Default is -1, which means sort along the
last axis.

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{kind}] (\textbf{{\{}'quicksort', 'mergesort', 'heapsort'{\}}, optional})
%[visit_definition]

Sorting algorithm. Default is 'quicksort'.

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{order}] (\textbf{list, optional})
%[visit_definition]

When \texttt{a} is an array with fields defined, this argument specifies
which fields to compare first, second, etc.  Not all fields need be
specified.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.sort : Return a sorted copy of an array.
argsort : Indirect sort.
lexsort : Indirect stable sort on multiple keys.
searchsorted : Find elements in sorted array.

%___________________________________________________________________________

\hypertarget{notes}{}
\pdfbookmark[3]{Notes}{notes}
\subsubsection*{Notes}

See \texttt{sort} for notes on the different sorting algorithms.

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.array([[1,4], [3,1]])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.sort(axis=1)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a
\pysrcoutput{array([[1, 4],}
\pysrcoutput{       [1, 3]])}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.sort(axis=0)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a
\pysrcoutput{array([[1, 3],}
\pysrcoutput{       [1, 4]])}\end{alltt}

Use the \texttt{order} keyword to specify a field to use when sorting a
structured array:
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.array([(\pysrcstring{'a'}, 2), (\pysrcstring{'c'}, 1)], dtype=[(\pysrcstring{'x'}, \pysrcstring{'S1'}), (\pysrcstring{'y'}, int)])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.sort(order=\pysrcstring{'y'})
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a
\pysrcoutput{array([('c', 1), ('a', 2)],}
\pysrcoutput{      dtype=[('x', '{\textbar}S1'), ('y', '{\textless}i4')])}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:squeeze}
    \index{numpy.ndarray.squeeze \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{squeeze}(\textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Remove single-dimensional entries from the shape of \texttt{a}.

Refer to \texttt{numpy.squeeze} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.squeeze : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:std}
    \index{numpy.ndarray.std \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{std}(\textit{a}, \textit{axis}=\texttt{None}, \textit{dtype}=\texttt{None}, \textit{out}=\texttt{None}, \textit{ddof}=\texttt{0})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Returns the standard deviation of the array elements along given axis.

Refer to \texttt{numpy.std} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.std : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:sum}
    \index{numpy.ndarray.sum \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{sum}(\textit{a}, \textit{axis}=\texttt{None}, \textit{dtype}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return the sum of the array elements over the given axis.

Refer to \texttt{numpy.sum} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.sum : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:swapaxes}
    \index{numpy.ndarray.swapaxes \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{swapaxes}(\textit{a}, \textit{axis1}, \textit{axis2})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return a view of the array with \texttt{axis1} and \texttt{axis2} interchanged.

Refer to \texttt{numpy.swapaxes} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.swapaxes : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:take}
    \index{numpy.ndarray.take \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{take}(\textit{a}, \textit{indices}, \textit{axis}=\texttt{None}, \textit{out}=\texttt{None}, \textit{mode}=\texttt{'raise'})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return an array formed from the elements of a at the given indices.

Refer to \texttt{numpy.take} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.take : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:tofile}
    \index{numpy.ndarray.tofile \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{tofile}(\textit{a}, \textit{fid}, \textit{sep}=\texttt{""}, \textit{format}=\texttt{"\%s"})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Write array to a file as text or binary.

Data is always written in 'C' order, independently of the order of \texttt{a}.
The data produced by this method can be recovered by using the function
fromfile().

This is a convenience function for quick storage of array data.
Information on endianess and precision is lost, so this method is not a
good choice for files intended to archive data or transport data between
machines with different endianess. Some of these problems can be overcome
by outputting the data as text files at the expense of speed and file size.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{fid}] (\textbf{file or string})
%[visit_definition]

An open file object or a string containing a filename.

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{sep}] (\textbf{string})
%[visit_definition]

Separator between array items for text output.
If ``'' (empty), a binary file is written, equivalently to
file.write(a.tostring()).

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{format}] (\textbf{string})
%[visit_definition]

Format string for text file output.
Each entry in the array is formatted to text by converting it to the
closest Python type, and using ``format'' {\%} item.

%[depart_definition]
%[depart_definition_list_item]
\end{description}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:tolist}
    \index{numpy.ndarray.tolist \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{tolist}(\textit{a})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return the array as a possibly nested list.

Return a copy of the array data as a hierarchical Python list.
Data items are converted to the nearest compatible Python type.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}

none

%___________________________________________________________________________

\hypertarget{returns}{}
\pdfbookmark[3]{Returns}{returns}
\subsubsection*{Returns}
\begin{description}
%[visit_definition_list_item]
\item[{y}] (\textbf{list})
%[visit_definition]

The possibly nested list of array elements.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{notes}{}
\pdfbookmark[3]{Notes}{notes}
\subsubsection*{Notes}

The array may be recreated, \texttt{a = np.array(a.tolist())}.

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.array([1, 2])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.tolist()
\pysrcoutput{[1, 2]}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.array([[1, 2], [3, 4]])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }list(a)
\pysrcoutput{[array([1, 2]), array([3, 4])]}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.tolist()
\pysrcoutput{[[1, 2], [3, 4]]}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:tostring}
    \index{numpy.ndarray.tostring \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{tostring}(\textit{a}, \textit{order}=\texttt{'C'})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Construct a Python string containing the raw data bytes in the array.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{order}] (\textbf{{\{}'C', 'F', None{\}}})
%[visit_definition]

Order of the data for multidimensional arrays:
C, Fortran, or the same as for the original array.

%[depart_definition]
%[depart_definition_list_item]
\end{description}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:trace}
    \index{numpy.ndarray.trace \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{trace}(\textit{a}, \textit{offset}=\texttt{0}, \textit{axis1}=\texttt{0}, \textit{axis2}=\texttt{1}, \textit{dtype}=\texttt{None}, \textit{out}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Return the sum along diagonals of the array.

Refer to \texttt{numpy.trace} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.trace : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:transpose}
    \index{numpy.ndarray.transpose \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{transpose}(\textit{a}, *\textit{axes})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Returns a view of 'a' with axes transposed. If no axes are given,
or None is passed, switches the order of the axes. For a 2-d
array, this is the usual matrix transpose. If axes are given,
they describe how the axes are permuted.

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a = np.array([[1,2],[3,4]])
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a
\pysrcoutput{array([[1, 2],}
\pysrcoutput{       [3, 4]])}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.transpose()
\pysrcoutput{array([[1, 3],}
\pysrcoutput{       [2, 4]])}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.transpose((1,0))
\pysrcoutput{array([[1, 3],}
\pysrcoutput{       [2, 4]])}
\pysrcoutput{}\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }a.transpose(1,0)
\pysrcoutput{array([[1, 3],}
\pysrcoutput{       [2, 4]])}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:var}
    \index{numpy.ndarray.var \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{var}(\textit{a}, \textit{axis}=\texttt{None}, \textit{dtype}=\texttt{None}, \textit{out}=\texttt{None}, \textit{ddof}=\texttt{0})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

Returns the variance of the array elements, along given axis.

Refer to \texttt{numpy.var} for full documentation.

%___________________________________________________________________________

\hypertarget{see-also}{}
\pdfbookmark[3]{See Also}{see-also}
\subsubsection*{See Also}

numpy.var : equivalent function
    \vspace{1ex}

    \end{boxedminipage}

    \label{numpy:ndarray:view}
    \index{numpy.ndarray.view \textit{(function)}}

    \vspace{0.5ex}

    \begin{boxedminipage}{\textwidth}

    \raggedright \textbf{view}(\textit{a}, \textit{dtype}=\texttt{None}, \textit{type}=\texttt{None})

    \vspace{-1.5ex}

    \rule{\textwidth}{0.5\fboxrule}

New view of array with the same data.

%___________________________________________________________________________

\hypertarget{parameters}{}
\pdfbookmark[3]{Parameters}{parameters}
\subsubsection*{Parameters}
\begin{description}
%[visit_definition_list_item]
\item[{dtype}] (\textbf{data-type})
%[visit_definition]

Data-type descriptor of the returned view, e.g. float32 or int16.

%[depart_definition]
%[depart_definition_list_item]
%[visit_definition_list_item]
\item[{type}] (\textbf{python type})
%[visit_definition]

Type of the returned view, e.g. ndarray or matrix.

%[depart_definition]
%[depart_definition_list_item]
\end{description}

%___________________________________________________________________________

\hypertarget{examples}{}
\pdfbookmark[3]{Examples}{examples}
\subsubsection*{Examples}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }x = np.array([(1, 2)], dtype=[(\pysrcstring{'a'}, np.int8), (\pysrcstring{'b'}, np.int8)])\end{alltt}

Viewing array data using a different type and dtype:
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }y = x.view(dtype=np.int16, type=np.matrix)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }\pysrckeyword{print} y.dtype
\pysrcoutput{int16}\end{alltt}
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }\pysrckeyword{print} type(y)
\pysrcoutput{{\textless}class 'numpy.core.defmatrix.matrix'{\textgreater}}\end{alltt}

Using a view to convert an array to a record array:
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }z = x.view(np.recarray)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }z.a
\pysrcoutput{array([1], dtype=int8)}\end{alltt}

Views share data:
\begin{alltt}
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }x[0] = (9, 10)
\pysrcprompt{{\textgreater}{\textgreater}{\textgreater} }z[0]
\pysrcoutput{(9, 10)}\end{alltt}
    \vspace{1ex}

    \end{boxedminipage}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%                              Properties                               %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

  \subsubsection{Properties}

\begin{longtable}{|p{.30\textwidth}|p{.62\textwidth}|l}
\cline{1-2}
\cline{1-2} \centering \textbf{Name} & \centering \textbf{Description}& \\
\cline{1-2}
\endhead\cline{1-2}\multicolumn{3}{r}{\small\textit{continued on next page}}\\\endfoot\cline{1-2}
\endlastfoot\raggedright T\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'T' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright \_\-\_\-a\-r\-r\-a\-y\-\_\-f\-i\-n\-a\-l\-i\-z\-e\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_array\_finalize\_\_' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright \_\-\_\-a\-r\-r\-a\-y\-\_\-i\-n\-t\-e\-r\-f\-a\-c\-e\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_array\_interface\_\_' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright \_\-\_\-a\-r\-r\-a\-y\-\_\-p\-r\-i\-o\-r\-i\-t\-y\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_array\_priority\_\_' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright \_\-\_\-a\-r\-r\-a\-y\-\_\-s\-t\-r\-u\-c\-t\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_array\_struct\_\_' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright \_\-\_\-c\-l\-a\-s\-s\-\_\-\_\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute '\_\_class\_\_' of 'object' objects{\textgreater}}&\\
\cline{1-2}
\raggedright b\-a\-s\-e\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'base' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright c\-t\-y\-p\-e\-s\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'ctypes' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright d\-a\-t\-a\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'data' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright d\-t\-y\-p\-e\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'dtype' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright f\-l\-a\-g\-s\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'flags' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright f\-l\-a\-t\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'flat' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright i\-m\-a\-g\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'imag' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright i\-t\-e\-m\-s\-i\-z\-e\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'itemsize' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright n\-b\-y\-t\-e\-s\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'nbytes' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright n\-d\-i\-m\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'ndim' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright r\-e\-a\-l\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'real' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright s\-h\-a\-p\-e\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'shape' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright s\-i\-z\-e\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'size' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\raggedright s\-t\-r\-i\-d\-e\-s\- & \raggedright \textbf{Value:}
{\tt {\textless}attribute 'strides' of 'numpy.ndarray' objects{\textgreater}}&\\
\cline{1-2}
\end{longtable}

    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.fuzzy \textit{(module)}!peach.fuzzy.fuzzy.FuzzySet \textit{(class)}|)}
    \index{peach \textit{(package)}!peach.fuzzy \textit{(package)}!peach.fuzzy.fuzzy \textit{(module)}|)}


\documentclass{article} %[11pt]{amsart}
\usepackage{geometry}
\geometry{letterpaper}
\usepackage{graphicx}
\usepackage{amssymb}
\usepackage{amsmath}
\usepackage{siunitx}
\usepackage{tikz}
\usepackage{lscape}
\usepackage{pgfplots}
\usetikzlibrary{
  arrows,
  calc,
  decorations.markings,
  decorations.pathreplacing,
  dsp,
  fit,
  positioning
}
\input{../util/control.tex}

\newcommand{\qhat}{\hat{q}}
\newcommand{\cbar}{\bar{c}}
\newcommand{\qbar}{\bar{q}}
\newcommand{\cmd}{\mathrm{cmd}}
\newcommand{\ff}{\mathrm{ff}}
\newcommand{\eff}{\mathrm{eff}}
\newcommand{\app}{\mathrm{app}}
\newcommand{\wind}{\mathrm{wind}}
\newcommand{\kite}{\mathrm{kite}}
\newcommand{\nom}{\mathrm{nom}}
\newcommand{\aero}{\mathrm{aero}}
\newcommand{\geom}{\mathrm{geom}}

\begin{document}

\section{Describing function analysis of rate limit nonlinearity}

There are two modes for the rate limit nonlinearity: one where the
signal is only rate limited for a portion of the period and another
where the signal is rate limited for the entire duration.  For
simplicity, we focus on the latter case.  Reference \cite{pratt2000}
has a good analysis of this case, and reference \cite{ponce2003} has a
more complete analysis of both cases.

The describing function for a rate-limit, when it is completely
rate-limiting the input signal is:
\begin{eqnarray}
\gamma &=& \sin^{-1} \left( \frac{\pi}{2} \frac{R}{M \omega} \right) \\
N(M, \omega) &=& \frac{4 R}{\pi M \omega} (\sin \gamma + i \cos \gamma)
\end{eqnarray}

This may be reduced to a function of one variable $x = M \omega / R$:
\begin{eqnarray}
N(x) &=& \frac{2}{x^2} +
i \frac{4}{\pi x} \cos \sin^{-1} \left( \frac{\pi}{2 x} \right) \\
&=& \frac{2}{x^2} \left(1 + i \sqrt{\left(\frac{2 x}{\pi}\right)^2 - 1} \right)
\end{eqnarray}

\begin{equation}
-1/N(x) = -\frac{\pi^2}{8}
\left( 1 - i \sqrt{\left(\frac{2 x}{\pi}\right)^2 - 1} \right)
\end{equation}

\begin{equation}
C(s) = k_p + k_d s + k_i / s
\end{equation}

\begin{equation}
G_{\mathrm{motor}}(s) = \frac{\omega_m}{s + \omega_m}
\end{equation}

\begin{equation}
G_{\mathrm{yaw}}(s) = \frac{1}{I_{zz} s^2}
\end{equation}

\begin{equation}
L(s) = C(s) G_{\mathrm{motor}}(s) G_{\mathrm{yaw}}(s)
\end{equation}

\begin{table}
\begin{center}
\begin{tabular}{cc}
\hline
\hline
Variable & Value \\
\hline
$k_p$ & $2.58 \times 10^5$ \\
$k_i$ & $2.04 \times 10^4$ \\
$k_d$ & $1.31 \times 10^5$ \\
$I_{zz}$ & $3 \times 10^4$ \\
$\omega_m$ & $2 \pi \cdot 6$ \\
\hline
\hline
\end{tabular}
\end{center}
\end{table}

\begin{figure}[!ht]
\begin{center}
\begin{tikzpicture}
\begin{axis}[
    scale=1.3,
    xlabel=Re,
    xmin=-5,
    xmax=5,
    ylabel=Im,
    ymin=-5,
    ymax=5,
    grid=both
  ]
  \def\a{(2 / (x * x))};
  \def\b{(2 / (x * x) * sqrt((2 * x / 3.14)^2 - 1))};
  \def\m{(\a * \a + \b * \b)};
  \def\kp{2.58e5};
  \def\ki{2.04e4};
  \def\kd{1.31e5};
  \def\Izz{3e4};
  \def\omegam{(2 * 3.14 * 6)};
  \def\Ga{(-\kd * \omegam * x^2 + \ki * \omegam)};
  \def\Gb{(\kp * \omegam * x)};
  \def\Gc{(\Izz * x^4)};
  \def\Gd{(-\Izz * \omegam * x^3)};
  \def\Gm{(\Gc * \Gc + \Gd * \Gd)};
  \addplot [smooth, color=blue, mark=none, domain=0:10]
           ({-\a / \m}, {\b / \m});
  \addplot [smooth, color=green, mark=none, domain=-15:-1]
            ({(\Ga * \Gc + \Gb * \Gd) / \Gm}, {(\Gb * \Gc - \Ga * \Gd) / \Gm});
  \addplot [smooth, color=green, mark=none, domain=1:15]
            ({(\Ga * \Gc + \Gb * \Gd) / \Gm}, {(\Gb * \Gc - \Ga * \Gd) / \Gm});
\end{axis}
\end{tikzpicture}
\caption{$L(j \omega) = -1 / N(M \omega / R)$ Intersection occurs at $x = 2.44$ and
  $\omega = -2.77$ rad/s.}
\label{fig:rlocus}
\end{center}
\end{figure}

\begin{thebibliography}{1}
\bibitem{pratt2000} Pratt, Roger. ``Flight Control Systems: Practical Issues in
  Design and Implementation.'' {\it IET}. 2000.\
\bibitem{ponce2003} Ponce, E. and Roman, M. ``The describing function
  method accuracy in first order plants with rate-limited feedback.''
  {\it Proceedings of the European Control Conference}. 2003.
\end{thebibliography}

\end{document}