// Copyright (c) 2019 by the SciSharp Team
// Code generated by CodeMinion: https://github.com/SciSharp/CodeMinion

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using Python.Runtime;
using Numpy.Models;
using Python.Included;

namespace Numpy
{
    public partial class NumPy
    {
        
        /// <summary>
        ///	Return a sorted copy of an array.<br></br>
        ///	
        ///	Notes
        ///	
        ///	The various sorting algorithms are characterized by their average speed,
        ///	worst case performance, work space size, and whether they are stable.<br></br>
        ///	 A
        ///	stable sort keeps items with the same key in the same relative
        ///	order.<br></br>
        ///	 The three available algorithms have the following
        ///	properties:
        ///	
        ///	All the sort algorithms make temporary copies of the data when
        ///	sorting along any but the last axis.<br></br>
        ///	  Consequently, sorting along
        ///	the last axis is faster and uses less space than sorting along
        ///	any other axis.<br></br>
        ///	
        ///	The sort order for complex numbers is lexicographic.<br></br>
        ///	 If both the real
        ///	and imaginary parts are non-nan then the order is determined by the
        ///	real parts except when they are equal, in which case the order is
        ///	determined by the imaginary parts.<br></br>
        ///	
        ///	Previous to numpy 1.4.0 sorting real and complex arrays containing nan
        ///	values led to undefined behaviour.<br></br>
        ///	 In numpy versions &gt;= 1.4.0 nan
        ///	values are sorted to the end.<br></br>
        ///	 The extended sort order is:
        ///	
        ///	where R is a non-nan real value.<br></br>
        ///	 Complex values with the same nan
        ///	placements are sorted according to the non-nan part if it exists.<br></br>
        ///	
        ///	Non-nan values are sorted as before.<br></br>
        ///	
        ///	quicksort has been changed to an introsort which will switch
        ///	heapsort when it does not make enough progress.<br></br>
        ///	 This makes its
        ///	worst case O(n*log(n)).<br></br>
        ///	
        ///	‘stable’ automatically choses the best stable sorting algorithm
        ///	for the data type being sorted.<br></br>
        ///	 It is currently mapped to
        ///	merge sort.
        /// </summary>
        /// <param name="a">
        ///	Array to be sorted.
        /// </param>
        /// <param name="axis">
        ///	Axis along which to sort.<br></br>
        ///	If None, the array is flattened before
        ///	sorting.<br></br>
        ///	The default is -1, which sorts along the last axis.
        /// </param>
        /// <param name="kind">
        ///	Sorting algorithm.<br></br>
        ///	Default is ‘quicksort’.
        /// </param>
        /// <param name="order">
        ///	When a is an array with fields defined, this argument specifies
        ///	which fields to compare first, second, etc.<br></br>
        ///	A single field can
        ///	be specified as a string, and not all fields need be specified,
        ///	but unspecified fields will still be used, in the order in which
        ///	they come up in the dtype, to break ties.
        /// </param>
        /// <returns>
        ///	Array of the same type and shape as a.
        /// </returns>
        public NDarray sort(NDarray a, int? axis = -1, string kind = "quicksort", string order = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            if (axis!=-1) kwargs["axis"]=ToPython(axis);
            if (kind!="quicksort") kwargs["kind"]=ToPython(kind);
            if (order!=null) kwargs["order"]=ToPython(order);
            dynamic py = __self__.InvokeMethod("sort", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Perform an indirect stable sort using a sequence of keys.<br></br>
        ///	
        ///	Given multiple sorting keys, which can be interpreted as columns in a
        ///	spreadsheet, lexsort returns an array of integer indices that describes
        ///	the sort order by multiple columns.<br></br>
        ///	 The last key in the sequence is used
        ///	for the primary sort order, the second-to-last key for the secondary sort
        ///	order, and so on.<br></br>
        ///	 The keys argument must be a sequence of objects that
        ///	can be converted to arrays of the same shape.<br></br>
        ///	 If a 2D array is provided
        ///	for the keys argument, it’s rows are interpreted as the sorting keys and
        ///	sorting is according to the last row, second last row etc.
        /// </summary>
        /// <param name="keys">
        ///	The k different “columns” to be sorted.<br></br>
        ///	The last column (or row if
        ///	keys is a 2D array) is the primary sort key.
        /// </param>
        /// <param name="axis">
        ///	Axis to be indirectly sorted.<br></br>
        ///	By default, sort over the last axis.
        /// </param>
        /// <returns>
        ///	Array of indices that sort the keys along the specified axis.
        /// </returns>
        public NDarray lexsort(NDarray keys, int? axis = -1)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                keys,
            });
            var kwargs=new PyDict();
            if (axis!=-1) kwargs["axis"]=ToPython(axis);
            dynamic py = __self__.InvokeMethod("lexsort", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns the indices that would sort an array.<br></br>
        ///	
        ///	Perform an indirect sort along the given axis using the algorithm specified
        ///	by the kind keyword.<br></br>
        ///	 It returns an array of indices of the same shape as
        ///	a that index data along the given axis in sorted order.<br></br>
        ///	
        ///	Notes
        ///	
        ///	See sort for notes on the different sorting algorithms.<br></br>
        ///	
        ///	As of NumPy 1.4.0 argsort works with real/complex arrays containing
        ///	nan values.<br></br>
        ///	 The enhanced sort order is documented in sort.
        /// </summary>
        /// <param name="a">
        ///	Array to sort.
        /// </param>
        /// <param name="axis">
        ///	Axis along which to sort.<br></br>
        ///	The default is -1 (the last axis).<br></br>
        ///	If None,
        ///	the flattened array is used.
        /// </param>
        /// <param name="kind">
        ///	Sorting algorithm.
        /// </param>
        /// <param name="order">
        ///	When a is an array with fields defined, this argument specifies
        ///	which fields to compare first, second, etc.<br></br>
        ///	A single field can
        ///	be specified as a string, and not all fields need be specified,
        ///	but unspecified fields will still be used, in the order in which
        ///	they come up in the dtype, to break ties.
        /// </param>
        /// <returns>
        ///	Array of indices that sort a along the specified axis.<br></br>
        ///	
        ///	If a is one-dimensional, a[index_array] yields a sorted a.<br></br>
        ///	
        ///	More generally, np.take_along_axis(a, index_array, axis=a) always
        ///	yields the sorted a, irrespective of dimensionality.
        /// </returns>
        public NDarray argsort(NDarray a, int? axis = -1, string kind = "quicksort", string order = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            if (axis!=-1) kwargs["axis"]=ToPython(axis);
            if (kind!="quicksort") kwargs["kind"]=ToPython(kind);
            if (order!=null) kwargs["order"]=ToPython(order);
            dynamic py = __self__.InvokeMethod("argsort", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Sort an array, in-place.<br></br>
        ///	
        ///	Notes
        ///	
        ///	See sort for notes on the different sorting algorithms.
        /// </summary>
        /// <param name="axis">
        ///	Axis along which to sort.<br></br>
        ///	Default is -1, which means sort along the
        ///	last axis.
        /// </param>
        /// <param name="kind">
        ///	Sorting algorithm.<br></br>
        ///	Default is ‘quicksort’.
        /// </param>
        /// <param name="order">
        ///	When a is an array with fields defined, this argument specifies
        ///	which fields to compare first, second, etc.<br></br>
        ///	A single field can
        ///	be specified as a string, and not all fields need be specified,
        ///	but unspecified fields will still be used, in the order in which
        ///	they come up in the dtype, to break ties.
        /// </param>
        public void sort(int? axis = -1, string kind = null, string order = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
            });
            var kwargs=new PyDict();
            if (axis!=-1) kwargs["axis"]=ToPython(axis);
            if (kind!=null) kwargs["kind"]=ToPython(kind);
            if (order!=null) kwargs["order"]=ToPython(order);
            dynamic py = __self__.InvokeMethod("sort", pyargs, kwargs);
        }
        
        /// <summary>
        ///	Return a copy of an array sorted along the first axis.<br></br>
        ///	
        ///	Notes
        ///	
        ///	np.msort(a) is equivalent to  np.sort(a, axis=0).
        /// </summary>
        /// <param name="a">
        ///	Array to be sorted.
        /// </param>
        /// <returns>
        ///	Array of the same type and shape as a.
        /// </returns>
        public NDarray msort(NDarray a)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            dynamic py = __self__.InvokeMethod("msort", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Sort a complex array using the real part first, then the imaginary part.
        /// </summary>
        /// <param name="a">
        ///	Input array
        /// </param>
        /// <returns>
        ///	Always returns a sorted complex array.
        /// </returns>
        public NDarray sort_complex(NDarray a)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            dynamic py = __self__.InvokeMethod("sort_complex", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Return a partitioned copy of an array.<br></br>
        ///	
        ///	Creates a copy of the array with its elements rearranged in such a
        ///	way that the value of the element in k-th position is in the
        ///	position it would be in a sorted array.<br></br>
        ///	 All elements smaller than
        ///	the k-th element are moved before this element and all equal or
        ///	greater are moved behind it.<br></br>
        ///	 The ordering of the elements in the two
        ///	partitions is undefined.<br></br>
        ///	
        ///	Notes
        ///	
        ///	The various selection algorithms are characterized by their average
        ///	speed, worst case performance, work space size, and whether they are
        ///	stable.<br></br>
        ///	 A stable sort keeps items with the same key in the same
        ///	relative order.<br></br>
        ///	 The available algorithms have the following
        ///	properties:
        ///	
        ///	All the partition algorithms make temporary copies of the data when
        ///	partitioning along any but the last axis.<br></br>
        ///	  Consequently,
        ///	partitioning along the last axis is faster and uses less space than
        ///	partitioning along any other axis.<br></br>
        ///	
        ///	The sort order for complex numbers is lexicographic.<br></br>
        ///	 If both the
        ///	real and imaginary parts are non-nan then the order is determined by
        ///	the real parts except when they are equal, in which case the order
        ///	is determined by the imaginary parts.
        /// </summary>
        /// <param name="a">
        ///	Array to be sorted.
        /// </param>
        /// <param name="kth">
        ///	Element index to partition by.<br></br>
        ///	The k-th value of the element
        ///	will be in its final sorted position and all smaller elements
        ///	will be moved before it and all equal or greater elements behind
        ///	it.<br></br>
        ///	The order of all elements in the partitions is undefined.<br></br>
        ///	If
        ///	provided with a sequence of k-th it will partition all elements
        ///	indexed by k-th  of them into their sorted position at once.
        /// </param>
        /// <param name="axis">
        ///	Axis along which to sort.<br></br>
        ///	If None, the array is flattened before
        ///	sorting.<br></br>
        ///	The default is -1, which sorts along the last axis.
        /// </param>
        /// <param name="kind">
        ///	Selection algorithm.<br></br>
        ///	Default is ‘introselect’.
        /// </param>
        /// <param name="order">
        ///	When a is an array with fields defined, this argument
        ///	specifies which fields to compare first, second, etc.<br></br>
        ///	A single
        ///	field can be specified as a string.<br></br>
        ///	Not all fields need be
        ///	specified, but unspecified fields will still be used, in the
        ///	order in which they come up in the dtype, to break ties.
        /// </param>
        /// <returns>
        ///	Array of the same type and shape as a.
        /// </returns>
        public NDarray partition(NDarray a, int[] kth, int? axis = -1, string kind = "introselect", string order = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
                kth,
            });
            var kwargs=new PyDict();
            if (axis!=-1) kwargs["axis"]=ToPython(axis);
            if (kind!="introselect") kwargs["kind"]=ToPython(kind);
            if (order!=null) kwargs["order"]=ToPython(order);
            dynamic py = __self__.InvokeMethod("partition", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Perform an indirect partition along the given axis using the
        ///	algorithm specified by the kind keyword.<br></br>
        ///	 It returns an array of
        ///	indices of the same shape as a that index data along the given
        ///	axis in partitioned order.<br></br>
        ///	
        ///	Notes
        ///	
        ///	See partition for notes on the different selection algorithms.
        /// </summary>
        /// <param name="a">
        ///	Array to sort.
        /// </param>
        /// <param name="kth">
        ///	Element index to partition by.<br></br>
        ///	The k-th element will be in its
        ///	final sorted position and all smaller elements will be moved
        ///	before it and all larger elements behind it.<br></br>
        ///	The order all
        ///	elements in the partitions is undefined.<br></br>
        ///	If provided with a
        ///	sequence of k-th it will partition all of them into their sorted
        ///	position at once.
        /// </param>
        /// <param name="axis">
        ///	Axis along which to sort.<br></br>
        ///	The default is -1 (the last axis).<br></br>
        ///	If
        ///	None, the flattened array is used.
        /// </param>
        /// <param name="kind">
        ///	Selection algorithm.<br></br>
        ///	Default is ‘introselect’
        /// </param>
        /// <param name="order">
        ///	When a is an array with fields defined, this argument
        ///	specifies which fields to compare first, second, etc.<br></br>
        ///	A single
        ///	field can be specified as a string, and not all fields need be
        ///	specified, but unspecified fields will still be used, in the
        ///	order in which they come up in the dtype, to break ties.
        /// </param>
        /// <returns>
        ///	Array of indices that partition a along the specified axis.<br></br>
        ///	
        ///	If a is one-dimensional, a[index_array] yields a partitioned a.<br></br>
        ///	
        ///	More generally, np.take_along_axis(a, index_array, axis=a) always
        ///	yields the partitioned a, irrespective of dimensionality.
        /// </returns>
        public NDarray argpartition(NDarray a, int[] kth, int? axis = -1, string kind = "introselect", string order = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
                kth,
            });
            var kwargs=new PyDict();
            if (axis!=-1) kwargs["axis"]=ToPython(axis);
            if (kind!="introselect") kwargs["kind"]=ToPython(kind);
            if (order!=null) kwargs["order"]=ToPython(order);
            dynamic py = __self__.InvokeMethod("argpartition", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns the indices of the maximum values along an axis.<br></br>
        ///	
        ///	Notes
        ///	
        ///	In case of multiple occurrences of the maximum values, the indices
        ///	corresponding to the first occurrence are returned.
        /// </summary>
        /// <param name="a">
        ///	Input array.
        /// </param>
        /// <param name="axis">
        ///	By default, the index is into the flattened array, otherwise
        ///	along the specified axis.
        /// </param>
        /// <param name="out">
        ///	If provided, the result will be inserted into this array.<br></br>
        ///	It should
        ///	be of the appropriate shape and dtype.
        /// </param>
        /// <returns>
        ///	Array of indices into the array.<br></br>
        ///	 It has the same shape as a.shape
        ///	with the dimension along axis removed.
        /// </returns>
        public NDarray argmax(NDarray a, int? axis = null, NDarray @out = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            if (axis!=null) kwargs["axis"]=ToPython(axis);
            if (@out!=null) kwargs["out"]=ToPython(@out);
            dynamic py = __self__.InvokeMethod("argmax", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Return the indices of the maximum values in the specified axis ignoring
        ///	NaNs.<br></br>
        ///	 For all-NaN slices ValueError is raised.<br></br>
        ///	 Warning: the
        ///	results cannot be trusted if a slice contains only NaNs and -Infs.
        /// </summary>
        /// <param name="a">
        ///	Input data.
        /// </param>
        /// <param name="axis">
        ///	Axis along which to operate.<br></br>
        ///	By default flattened input is used.
        /// </param>
        /// <returns>
        ///	An array of indices or a single index value.
        /// </returns>
        public NDarray nanargmax(NDarray a, int? axis = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            if (axis!=null) kwargs["axis"]=ToPython(axis);
            dynamic py = __self__.InvokeMethod("nanargmax", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Returns the indices of the minimum values along an axis.<br></br>
        ///	
        ///	Notes
        ///	
        ///	In case of multiple occurrences of the minimum values, the indices
        ///	corresponding to the first occurrence are returned.
        /// </summary>
        /// <param name="a">
        ///	Input array.
        /// </param>
        /// <param name="axis">
        ///	By default, the index is into the flattened array, otherwise
        ///	along the specified axis.
        /// </param>
        /// <param name="out">
        ///	If provided, the result will be inserted into this array.<br></br>
        ///	It should
        ///	be of the appropriate shape and dtype.
        /// </param>
        /// <returns>
        ///	Array of indices into the array.<br></br>
        ///	 It has the same shape as a.shape
        ///	with the dimension along axis removed.
        /// </returns>
        public NDarray argmin(NDarray a, int? axis = null, NDarray @out = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            if (axis!=null) kwargs["axis"]=ToPython(axis);
            if (@out!=null) kwargs["out"]=ToPython(@out);
            dynamic py = __self__.InvokeMethod("argmin", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Return the indices of the minimum values in the specified axis ignoring
        ///	NaNs.<br></br>
        ///	 For all-NaN slices ValueError is raised.<br></br>
        ///	 Warning: the results
        ///	cannot be trusted if a slice contains only NaNs and Infs.
        /// </summary>
        /// <param name="a">
        ///	Input data.
        /// </param>
        /// <param name="axis">
        ///	Axis along which to operate.<br></br>
        ///	By default flattened input is used.
        /// </param>
        /// <returns>
        ///	An array of indices or a single index value.
        /// </returns>
        public NDarray nanargmin(NDarray a, int? axis = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            if (axis!=null) kwargs["axis"]=ToPython(axis);
            dynamic py = __self__.InvokeMethod("nanargmin", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Find the indices of array elements that are non-zero, grouped by element.<br></br>
        ///	
        ///	Notes
        ///	
        ///	np.argwhere(a) is the same as np.transpose(np.nonzero(a)).<br></br>
        ///	
        ///	The output of argwhere is not suitable for indexing arrays.<br></br>
        ///	
        ///	For this purpose use nonzero(a) instead.
        /// </summary>
        /// <param name="a">
        ///	Input data.
        /// </param>
        /// <returns>
        ///	Indices of elements that are non-zero.<br></br>
        ///	 Indices are grouped by element.
        /// </returns>
        public NDarray argwhere(NDarray a)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            dynamic py = __self__.InvokeMethod("argwhere", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Return indices that are non-zero in the flattened version of a.<br></br>
        ///	
        ///	This is equivalent to np.nonzero(np.ravel(a))[0].
        /// </summary>
        /// <param name="a">
        ///	Input data.
        /// </param>
        /// <returns>
        ///	Output array, containing the indices of the elements of a.ravel()
        ///	that are non-zero.
        /// </returns>
        public NDarray flatnonzero(NDarray a)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            dynamic py = __self__.InvokeMethod("flatnonzero", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Find indices where elements should be inserted to maintain order.<br></br>
        ///	
        ///	Find the indices into a sorted array a such that, if the
        ///	corresponding elements in v were inserted before the indices, the
        ///	order of a would be preserved.<br></br>
        ///	
        ///	Assuming that a is sorted:
        ///	
        ///	Notes
        ///	
        ///	Binary search is used to find the required insertion points.<br></br>
        ///	
        ///	As of NumPy 1.4.0 searchsorted works with real/complex arrays containing
        ///	nan values.<br></br>
        ///	 The enhanced sort order is documented in sort.<br></br>
        ///	
        ///	This function is a faster version of the builtin python bisect.bisect_left
        ///	(side='left') and bisect.bisect_right (side='right') functions,
        ///	which is also vectorized in the v argument.
        /// </summary>
        /// <param name="a">
        ///	Input array.<br></br>
        ///	If sorter is None, then it must be sorted in
        ///	ascending order, otherwise sorter must be an array of indices
        ///	that sort it.
        /// </param>
        /// <param name="v">
        ///	Values to insert into a.
        /// </param>
        /// <param name="side">
        ///	If ‘left’, the index of the first suitable location found is given.<br></br>
        ///	
        ///	If ‘right’, return the last such index.<br></br>
        ///	If there is no suitable
        ///	index, return either 0 or N (where N is the length of a).
        /// </param>
        /// <param name="sorter">
        ///	Optional array of integer indices that sort array a into ascending
        ///	order.<br></br>
        ///	They are typically the result of argsort.
        /// </param>
        /// <returns>
        ///	Array of insertion points with the same shape as v.
        /// </returns>
        public NDarray<int> searchsorted(NDarray a, NDarray v, string side = "left", NDarray sorter = null)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
                v,
            });
            var kwargs=new PyDict();
            if (side!="left") kwargs["side"]=ToPython(side);
            if (sorter!=null) kwargs["sorter"]=ToPython(sorter);
            dynamic py = __self__.InvokeMethod("searchsorted", pyargs, kwargs);
            return ToCsharp<NDarray<int>>(py);
        }
        
        /// <summary>
        ///	Return the elements of an array that satisfy some condition.<br></br>
        ///	
        ///	This is equivalent to np.compress(ravel(condition), ravel(arr)).<br></br>
        ///	  If
        ///	condition is boolean np.extract is equivalent to arr[condition].<br></br>
        ///	
        ///	Note that place does the exact opposite of extract.
        /// </summary>
        /// <param name="condition">
        ///	An array whose nonzero or True entries indicate the elements of arr
        ///	to extract.
        /// </param>
        /// <param name="arr">
        ///	Input array of the same size as condition.
        /// </param>
        /// <returns>
        ///	Rank 1 array of values from arr where condition is True.
        /// </returns>
        public NDarray extract(NDarray condition, NDarray arr)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                condition,
                arr,
            });
            var kwargs=new PyDict();
            dynamic py = __self__.InvokeMethod("extract", pyargs, kwargs);
            return ToCsharp<NDarray>(py);
        }
        
        /// <summary>
        ///	Counts the number of non-zero values in the array a.<br></br>
        ///	
        ///	The word “non-zero” is in reference to the Python 2.x
        ///	built-in method __nonzero__() (renamed __bool__()
        ///	in Python 3.x) of Python objects that tests an object’s
        ///	“truthfulness”. For example, any number is considered
        ///	truthful if it is nonzero, whereas any string is considered
        ///	truthful if it is not the empty string.<br></br>
        ///	 Thus, this function
        ///	(recursively) counts how many elements in a (and in
        ///	sub-arrays thereof) have their __nonzero__() or __bool__()
        ///	method evaluated to True.
        /// </summary>
        /// <param name="a">
        ///	The array for which to count non-zeros.
        /// </param>
        /// <param name="axis">
        ///	Axis or tuple of axes along which to count non-zeros.<br></br>
        ///	
        ///	Default is None, meaning that non-zeros will be counted
        ///	along a flattened version of a.
        /// </param>
        /// <returns>
        ///	Number of non-zero values in the array along a given axis.<br></br>
        ///	
        ///	Otherwise, the total number of non-zero values in the array
        ///	is returned.
        /// </returns>
        public NDarray<int> count_nonzero(NDarray a, int[] axis)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            if (axis!=null) kwargs["axis"]=ToPython(axis);
            dynamic py = __self__.InvokeMethod("count_nonzero", pyargs, kwargs);
            return ToCsharp<NDarray<int>>(py);
        }
        
        /// <summary>
        ///	Counts the number of non-zero values in the array a.<br></br>
        ///	
        ///	The word “non-zero” is in reference to the Python 2.x
        ///	built-in method __nonzero__() (renamed __bool__()
        ///	in Python 3.x) of Python objects that tests an object’s
        ///	“truthfulness”. For example, any number is considered
        ///	truthful if it is nonzero, whereas any string is considered
        ///	truthful if it is not the empty string.<br></br>
        ///	 Thus, this function
        ///	(recursively) counts how many elements in a (and in
        ///	sub-arrays thereof) have their __nonzero__() or __bool__()
        ///	method evaluated to True.
        /// </summary>
        /// <param name="a">
        ///	The array for which to count non-zeros.
        /// </param>
        /// <returns>
        ///	Number of non-zero values in the array along a given axis.<br></br>
        ///	
        ///	Otherwise, the total number of non-zero values in the array
        ///	is returned.
        /// </returns>
        public int count_nonzero(NDarray a)
        {
            //auto-generated code, do not change
            var __self__=self;
            var pyargs=ToTuple(new object[]
            {
                a,
            });
            var kwargs=new PyDict();
            dynamic py = __self__.InvokeMethod("count_nonzero", pyargs, kwargs);
            return ToCsharp<int>(py);
        }
        
    }
}