// 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 the minimum of an array or minimum along an axis.<br></br>

///

/// Notes

///

/// NaN values are propagated, that is if at least one item is NaN, the

/// corresponding min value will be NaN as well.<br></br>

/// To ignore NaN values

/// (MATLAB behavior), please use nanmin.<br></br>

///

/// Don’t use amin for element-wise comparison of 2 arrays; when

/// a.shape[0] is 2, minimum(a[0], a[1]) is faster than

/// amin(a, axis=0).

/// </summary>

/// <param name="a">

/// Input data.

/// </param>

/// <param name="axis">

/// Axis or axes along which to operate.<br></br>

/// By default, flattened input is

/// used.<br></br>

///

/// If this is a tuple of ints, the minimum is selected over multiple axes,

/// instead of a single axis or all the axes as before.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// Must

/// be of the same shape and buffer length as the expected output.<br></br>

///

/// See doc.ufuncs (Section “Output arguments”) for more details.

/// </param>

/// <param name="keepdims">

/// If this is set to True, the axes which are reduced are left

/// in the result as dimensions with size one.<br></br>

/// With this option,

/// the result will broadcast correctly against the input array.<br></br>

///

/// If the default value is passed, then keepdims will not be

/// passed through to the amin method of sub-classes of

/// ndarray, however any non-default value will be.<br></br>

/// If the

/// sub-class’ method does not implement keepdims any

/// exceptions will be raised.

/// </param>

/// <param name="initial">

/// The maximum value of an output element.<br></br>

/// Must be present to allow

/// computation on empty slice.<br></br>

/// See reduce for details.

/// </param>

/// <returns>

/// Minimum of a.<br></br>

/// If axis is None, the result is a scalar value.<br></br>

///

/// If axis is given, the result is an array of dimension

/// a.ndim - 1.

/// </returns>

public NDarray amin(NDarray a, int[] axis = null, NDarray @out = null, bool? keepdims = null, ValueType initial = 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);

if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);

if (initial!=null) kwargs["initial"]=ToPython(initial);

dynamic py = __self__.InvokeMethod("amin", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return the maximum of an array or maximum along an axis.<br></br>

///

/// Notes

///

/// NaN values are propagated, that is if at least one item is NaN, the

/// corresponding max value will be NaN as well.<br></br>

/// To ignore NaN values

/// (MATLAB behavior), please use nanmax.<br></br>

///

/// Don’t use amax for element-wise comparison of 2 arrays; when

/// a.shape[0] is 2, maximum(a[0], a[1]) is faster than

/// amax(a, axis=0).

/// </summary>

/// <param name="a">

/// Input data.

/// </param>

/// <param name="axis">

/// Axis or axes along which to operate.<br></br>

/// By default, flattened input is

/// used.<br></br>

///

/// If this is a tuple of ints, the maximum is selected over multiple axes,

/// instead of a single axis or all the axes as before.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// Must

/// be of the same shape and buffer length as the expected output.<br></br>

///

/// See doc.ufuncs (Section “Output arguments”) for more details.

/// </param>

/// <param name="keepdims">

/// If this is set to True, the axes which are reduced are left

/// in the result as dimensions with size one.<br></br>

/// With this option,

/// the result will broadcast correctly against the input array.<br></br>

///

/// If the default value is passed, then keepdims will not be

/// passed through to the amax method of sub-classes of

/// ndarray, however any non-default value will be.<br></br>

/// If the

/// sub-class’ method does not implement keepdims any

/// exceptions will be raised.

/// </param>

/// <param name="initial">

/// The minimum value of an output element.<br></br>

/// Must be present to allow

/// computation on empty slice.<br></br>

/// See reduce for details.

/// </param>

/// <returns>

/// Maximum of a.<br></br>

/// If axis is None, the result is a scalar value.<br></br>

///

/// If axis is given, the result is an array of dimension

/// a.ndim - 1.

/// </returns>

public NDarray amax(NDarray a, int[] axis = null, NDarray @out = null, bool? keepdims = null, ValueType initial = 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);

if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);

if (initial!=null) kwargs["initial"]=ToPython(initial);

dynamic py = __self__.InvokeMethod("amax", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return minimum of an array or minimum along an axis, ignoring any NaNs.<br></br>

///

/// When all-NaN slices are encountered a RuntimeWarning is raised and

/// Nan is returned for that slice.<br></br>

///

/// Notes

///

/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic

/// (IEEE 754).<br></br>

/// This means that Not a Number is not equivalent to infinity.<br></br>

///

/// Positive infinity is treated as a very large number and negative

/// infinity is treated as a very small (i.e.<br></br>

/// negative) number.<br></br>

///

/// If the input has a integer type the function is equivalent to np.min.

/// </summary>

/// <param name="a">

/// Array containing numbers whose minimum is desired.<br></br>

/// If a is not an

/// array, a conversion is attempted.

/// </param>

/// <param name="axis">

/// Axis or axes along which the minimum is computed.<br></br>

/// The default is to compute

/// the minimum of the flattened array.

/// </param>

/// <param name="out">

/// Alternate output array in which to place the result.<br></br>

/// The default

/// is None; if provided, it must have the same shape as the

/// expected output, but the type will be cast if necessary.<br></br>

/// See

/// doc.ufuncs for details.

/// </param>

/// <param name="keepdims">

/// If this is set to True, the axes which are reduced are left

/// in the result as dimensions with size one.<br></br>

/// With this option,

/// the result will broadcast correctly against the original a.<br></br>

///

/// If the value is anything but the default, then

/// keepdims will be passed through to the min method

/// of sub-classes of ndarray.<br></br>

/// If the sub-classes methods

/// does not implement keepdims any exceptions will be raised.

/// </param>

/// <returns>

/// An array with the same shape as a, with the specified axis

/// removed.<br></br>

/// If a is a 0-d array, or if axis is None, an ndarray

/// scalar is returned.<br></br>

/// The same dtype as a is returned.

/// </returns>

public NDarray nanmin(NDarray a, int[] axis = null, NDarray @out = null, bool? keepdims = 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);

if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);

dynamic py = __self__.InvokeMethod("nanmin", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Return the maximum of an array or maximum along an axis, ignoring any

/// NaNs.<br></br>

/// When all-NaN slices are encountered a RuntimeWarning is

/// raised and NaN is returned for that slice.<br></br>

///

/// Notes

///

/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic

/// (IEEE 754).<br></br>

/// This means that Not a Number is not equivalent to infinity.<br></br>

///

/// Positive infinity is treated as a very large number and negative

/// infinity is treated as a very small (i.e.<br></br>

/// negative) number.<br></br>

///

/// If the input has a integer type the function is equivalent to np.max.

/// </summary>

/// <param name="a">

/// Array containing numbers whose maximum is desired.<br></br>

/// If a is not an

/// array, a conversion is attempted.

/// </param>

/// <param name="axis">

/// Axis or axes along which the maximum is computed.<br></br>

/// The default is to compute

/// the maximum of the flattened array.

/// </param>

/// <param name="out">

/// Alternate output array in which to place the result.<br></br>

/// The default

/// is None; if provided, it must have the same shape as the

/// expected output, but the type will be cast if necessary.<br></br>

/// See

/// doc.ufuncs for details.

/// </param>

/// <param name="keepdims">

/// If this is set to True, the axes which are reduced are left

/// in the result as dimensions with size one.<br></br>

/// With this option,

/// the result will broadcast correctly against the original a.<br></br>

///

/// If the value is anything but the default, then

/// keepdims will be passed through to the max method

/// of sub-classes of ndarray.<br></br>

/// If the sub-classes methods

/// does not implement keepdims any exceptions will be raised.

/// </param>

/// <returns>

/// An array with the same shape as a, with the specified axis removed.<br></br>

///

/// If a is a 0-d array, or if axis is None, an ndarray scalar is

/// returned.<br></br>

/// The same dtype as a is returned.

/// </returns>

public NDarray nanmax(NDarray a, int[] axis = null, NDarray @out = null, bool? keepdims = 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);

if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);

dynamic py = __self__.InvokeMethod("nanmax", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Range of values (maximum - minimum) along an axis.<br></br>

///

/// The name of the function comes from the acronym for ‘peak to peak’.

/// </summary>

/// <param name="a">

/// Input values.

/// </param>

/// <param name="axis">

/// Axis along which to find the peaks.<br></br>

/// By default, flatten the

/// array.<br></br>

/// axis may be negative, in

/// which case it counts from the last to the first axis.<br></br>

///

/// If this is a tuple of ints, a reduction is performed on multiple

/// axes, instead of a single axis or all the axes as before.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// It must

/// have the same shape and buffer length as the expected output,

/// but the type of the output values will be cast if necessary.

/// </param>

/// <param name="keepdims">

/// If this is set to True, the axes which are reduced are left

/// in the result as dimensions with size one.<br></br>

/// With this option,

/// the result will broadcast correctly against the input array.<br></br>

///

/// If the default value is passed, then keepdims will not be

/// passed through to the ptp method of sub-classes of

/// ndarray, however any non-default value will be.<br></br>

/// If the

/// sub-class’ method does not implement keepdims any

/// exceptions will be raised.

/// </param>

/// <returns>

/// A new array holding the result, unless out was

/// specified, in which case a reference to out is returned.

/// </returns>

public NDarray ptp(NDarray a, int[] axis = null, NDarray @out = null, bool? keepdims = 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);

if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);

dynamic py = __self__.InvokeMethod("ptp", pyargs, kwargs);

return ToCsharp<NDarray>(py);

}

/// <summary>

/// Compute the q-th percentile of the data along the specified axis.<br></br>

///

/// Returns the q-th percentile(s) of the array elements.<br></br>

///

/// Notes

///

/// Given a vector V of length N, the q-th percentile of

/// V is the value q/100 of the way from the minimum to the

/// maximum in a sorted copy of V.<br></br>

/// The values and distances of

/// the two nearest neighbors as well as the interpolation parameter

/// will determine the percentile if the normalized ranking does not

/// match the location of q exactly.<br></br>

/// This function is the same as

/// the median if q=50, the same as the minimum if q=0 and the

/// same as the maximum if q=100.

/// </summary>

/// <param name="a">

/// Input array or object that can be converted to an array.

/// </param>

/// <param name="q">

/// Percentile or sequence of percentiles to compute, which must be between

/// 0 and 100 inclusive.

/// </param>

/// <param name="axis">

/// Axis or axes along which the percentiles are computed.<br></br>

/// The

/// default is to compute the percentile(s) along a flattened

/// version of the array.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// It must

/// have the same shape and buffer length as the expected output,

/// but the type (of the output) will be cast if necessary.

/// </param>

/// <param name="overwrite_input">

/// If True, then allow the input array a to be modified by intermediate

/// calculations, to save memory.<br></br>

/// In this case, the contents of the input

/// a after this function completes is undefined.

/// </param>

/// <param name="interpolation">

/// This optional parameter specifies the interpolation method to

/// use when the desired percentile lies between two data points

/// i &lt; j:

/// </param>

/// <param name="keepdims">

/// If this is set to True, the axes which are reduced are left in

/// the result as dimensions with size one.<br></br>

/// With this option, the

/// result will broadcast correctly against the original array a.

/// </param>

/// <returns>

/// If q is a single percentile and axis=None, then the result

/// is a scalar.<br></br>

/// If multiple percentiles are given, first axis of

/// the result corresponds to the percentiles.<br></br>

/// The other axes are

/// the axes that remain after the reduction of a.<br></br>

/// If the input

/// contains integers or floats smaller than float64, the output

/// data-type is float64. Otherwise, the output data-type is the

/// same as that of the input.<br></br>

/// If out is specified, that array is

/// returned instead.

/// </returns>

public NDarray<double> percentile(NDarray a, NDarray<float> q, int[] axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = false)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

q,

});

var kwargs=new PyDict();

if (axis!=null) kwargs["axis"]=ToPython(axis);

if (@out!=null) kwargs["out"]=ToPython(@out);

if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input);

if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation);

if (keepdims!=false) kwargs["keepdims"]=ToPython(keepdims);

dynamic py = __self__.InvokeMethod("percentile", pyargs, kwargs);

return ToCsharp<NDarray<double>>(py);

}

/// <summary>

/// Compute the q-th percentile of the data along the specified axis.<br></br>

///

/// Returns the q-th percentile(s) of the array elements.<br></br>

///

/// Notes

///

/// Given a vector V of length N, the q-th percentile of

/// V is the value q/100 of the way from the minimum to the

/// maximum in a sorted copy of V.<br></br>

/// The values and distances of

/// the two nearest neighbors as well as the interpolation parameter

/// will determine the percentile if the normalized ranking does not

/// match the location of q exactly.<br></br>

/// This function is the same as

/// the median if q=50, the same as the minimum if q=0 and the

/// same as the maximum if q=100.

/// </summary>

/// <param name="a">

/// Input array or object that can be converted to an array.

/// </param>

/// <param name="q">

/// Percentile or sequence of percentiles to compute, which must be between

/// 0 and 100 inclusive.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// It must

/// have the same shape and buffer length as the expected output,

/// but the type (of the output) will be cast if necessary.

/// </param>

/// <param name="overwrite_input">

/// If True, then allow the input array a to be modified by intermediate

/// calculations, to save memory.<br></br>

/// In this case, the contents of the input

/// a after this function completes is undefined.

/// </param>

/// <param name="interpolation">

/// This optional parameter specifies the interpolation method to

/// use when the desired percentile lies between two data points

/// i &lt; j:

/// </param>

/// <returns>

/// If q is a single percentile and axis=None, then the result

/// is a scalar.<br></br>

/// If multiple percentiles are given, first axis of

/// the result corresponds to the percentiles.<br></br>

/// The other axes are

/// the axes that remain after the reduction of a.<br></br>

/// If the input

/// contains integers or floats smaller than float64, the output

/// data-type is float64. Otherwise, the output data-type is the

/// same as that of the input.<br></br>

/// If out is specified, that array is

/// returned instead.

/// </returns>

public double percentile(NDarray a, NDarray<float> q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear")

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

q,

});

var kwargs=new PyDict();

if (@out!=null) kwargs["out"]=ToPython(@out);

if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input);

if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation);

dynamic py = __self__.InvokeMethod("percentile", pyargs, kwargs);

return ToCsharp<double>(py);

}

/// <summary>

/// Compute the qth percentile of the data along the specified axis,

/// while ignoring nan values.<br></br>

///

/// Returns the qth percentile(s) of the array elements.<br></br>

///

/// Notes

///

/// Given a vector V of length N, the q-th percentile of

/// V is the value q/100 of the way from the minimum to the

/// maximum in a sorted copy of V.<br></br>

/// The values and distances of

/// the two nearest neighbors as well as the interpolation parameter

/// will determine the percentile if the normalized ranking does not

/// match the location of q exactly.<br></br>

/// This function is the same as

/// the median if q=50, the same as the minimum if q=0 and the

/// same as the maximum if q=100.

/// </summary>

/// <param name="a">

/// Input array or object that can be converted to an array, containing

/// nan values to be ignored.

/// </param>

/// <param name="q">

/// Percentile or sequence of percentiles to compute, which must be between

/// 0 and 100 inclusive.

/// </param>

/// <param name="axis">

/// Axis or axes along which the percentiles are computed.<br></br>

/// The

/// default is to compute the percentile(s) along a flattened

/// version of the array.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// It must

/// have the same shape and buffer length as the expected output,

/// but the type (of the output) will be cast if necessary.

/// </param>

/// <param name="overwrite_input">

/// If True, then allow the input array a to be modified by intermediate

/// calculations, to save memory.<br></br>

/// In this case, the contents of the input

/// a after this function completes is undefined.

/// </param>

/// <param name="interpolation">

/// This optional parameter specifies the interpolation method to

/// use when the desired percentile lies between two data points

/// i &lt; j:

/// </param>

/// <param name="keepdims">

/// If this is set to True, the axes which are reduced are left in

/// the result as dimensions with size one.<br></br>

/// With this option, the

/// result will broadcast correctly against the original array a.<br></br>

///

/// If this is anything but the default value it will be passed

/// through (in the special case of an empty array) to the

/// mean function of the underlying array.<br></br>

/// If the array is

/// a sub-class and mean does not have the kwarg keepdims this

/// will raise a RuntimeError.

/// </param>

/// <returns>

/// If q is a single percentile and axis=None, then the result

/// is a scalar.<br></br>

/// If multiple percentiles are given, first axis of

/// the result corresponds to the percentiles.<br></br>

/// The other axes are

/// the axes that remain after the reduction of a.<br></br>

/// If the input

/// contains integers or floats smaller than float64, the output

/// data-type is float64. Otherwise, the output data-type is the

/// same as that of the input.<br></br>

/// If out is specified, that array is

/// returned instead.

/// </returns>

public NDarray<double> nanpercentile(NDarray a, NDarray<float> q, int[] axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

q,

});

var kwargs=new PyDict();

if (axis!=null) kwargs["axis"]=ToPython(axis);

if (@out!=null) kwargs["out"]=ToPython(@out);

if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input);

if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation);

if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);

dynamic py = __self__.InvokeMethod("nanpercentile", pyargs, kwargs);

return ToCsharp<NDarray<double>>(py);

}

/// <summary>

/// Compute the qth percentile of the data along the specified axis,

/// while ignoring nan values.<br></br>

///

/// Returns the qth percentile(s) of the array elements.<br></br>

///

/// Notes

///

/// Given a vector V of length N, the q-th percentile of

/// V is the value q/100 of the way from the minimum to the

/// maximum in a sorted copy of V.<br></br>

/// The values and distances of

/// the two nearest neighbors as well as the interpolation parameter

/// will determine the percentile if the normalized ranking does not

/// match the location of q exactly.<br></br>

/// This function is the same as

/// the median if q=50, the same as the minimum if q=0 and the

/// same as the maximum if q=100.

/// </summary>

/// <param name="a">

/// Input array or object that can be converted to an array, containing

/// nan values to be ignored.

/// </param>

/// <param name="q">

/// Percentile or sequence of percentiles to compute, which must be between

/// 0 and 100 inclusive.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// It must

/// have the same shape and buffer length as the expected output,

/// but the type (of the output) will be cast if necessary.

/// </param>

/// <param name="overwrite_input">

/// If True, then allow the input array a to be modified by intermediate

/// calculations, to save memory.<br></br>

/// In this case, the contents of the input

/// a after this function completes is undefined.

/// </param>

/// <param name="interpolation">

/// This optional parameter specifies the interpolation method to

/// use when the desired percentile lies between two data points

/// i &lt; j:

/// </param>

/// <returns>

/// If q is a single percentile and axis=None, then the result

/// is a scalar.<br></br>

/// If multiple percentiles are given, first axis of

/// the result corresponds to the percentiles.<br></br>

/// The other axes are

/// the axes that remain after the reduction of a.<br></br>

/// If the input

/// contains integers or floats smaller than float64, the output

/// data-type is float64. Otherwise, the output data-type is the

/// same as that of the input.<br></br>

/// If out is specified, that array is

/// returned instead.

/// </returns>

public double nanpercentile(NDarray a, NDarray<float> q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear")

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

q,

});

var kwargs=new PyDict();

if (@out!=null) kwargs["out"]=ToPython(@out);

if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input);

if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation);

dynamic py = __self__.InvokeMethod("nanpercentile", pyargs, kwargs);

return ToCsharp<double>(py);

}

/// <summary>

/// Compute the q-th quantile of the data along the specified axis.<br></br>

///

/// ..versionadded:: 1.15.0

///

/// Notes

///

/// Given a vector V of length N, the q-th quantile of

/// V is the value q of the way from the minimum to the

/// maximum in a sorted copy of V.<br></br>

/// The values and distances of

/// the two nearest neighbors as well as the interpolation parameter

/// will determine the quantile if the normalized ranking does not

/// match the location of q exactly.<br></br>

/// This function is the same as

/// the median if q=0.5, the same as the minimum if q=0.0 and the

/// same as the maximum if q=1.0.

/// </summary>

/// <param name="a">

/// Input array or object that can be converted to an array.

/// </param>

/// <param name="q">

/// Quantile or sequence of quantiles to compute, which must be between

/// 0 and 1 inclusive.

/// </param>

/// <param name="axis">

/// Axis or axes along which the quantiles are computed.<br></br>

/// The

/// default is to compute the quantile(s) along a flattened

/// version of the array.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// It must

/// have the same shape and buffer length as the expected output,

/// but the type (of the output) will be cast if necessary.

/// </param>

/// <param name="overwrite_input">

/// If True, then allow the input array a to be modified by intermediate

/// calculations, to save memory.<br></br>

/// In this case, the contents of the input

/// a after this function completes is undefined.

/// </param>

/// <param name="interpolation">

/// This optional parameter specifies the interpolation method to

/// use when the desired quantile lies between two data points

/// i &lt; j:

/// </param>

/// <param name="keepdims">

/// If this is set to True, the axes which are reduced are left in

/// the result as dimensions with size one.<br></br>

/// With this option, the

/// result will broadcast correctly against the original array a.

/// </param>

/// <returns>

/// If q is a single quantile and axis=None, then the result

/// is a scalar.<br></br>

/// If multiple quantiles are given, first axis of

/// the result corresponds to the quantiles.<br></br>

/// The other axes are

/// the axes that remain after the reduction of a.<br></br>

/// If the input

/// contains integers or floats smaller than float64, the output

/// data-type is float64. Otherwise, the output data-type is the

/// same as that of the input.<br></br>

/// If out is specified, that array is

/// returned instead.

/// </returns>

public NDarray<double> quantile(NDarray a, NDarray<float> q, int[] axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = false)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

q,

});

var kwargs=new PyDict();

if (axis!=null) kwargs["axis"]=ToPython(axis);

if (@out!=null) kwargs["out"]=ToPython(@out);

if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input);

if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation);

if (keepdims!=false) kwargs["keepdims"]=ToPython(keepdims);

dynamic py = __self__.InvokeMethod("quantile", pyargs, kwargs);

return ToCsharp<NDarray<double>>(py);

}

/// <summary>

/// Compute the q-th quantile of the data along the specified axis.<br></br>

///

/// ..versionadded:: 1.15.0

///

/// Notes

///

/// Given a vector V of length N, the q-th quantile of

/// V is the value q of the way from the minimum to the

/// maximum in a sorted copy of V.<br></br>

/// The values and distances of

/// the two nearest neighbors as well as the interpolation parameter

/// will determine the quantile if the normalized ranking does not

/// match the location of q exactly.<br></br>

/// This function is the same as

/// the median if q=0.5, the same as the minimum if q=0.0 and the

/// same as the maximum if q=1.0.

/// </summary>

/// <param name="a">

/// Input array or object that can be converted to an array.

/// </param>

/// <param name="q">

/// Quantile or sequence of quantiles to compute, which must be between

/// 0 and 1 inclusive.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// It must

/// have the same shape and buffer length as the expected output,

/// but the type (of the output) will be cast if necessary.

/// </param>

/// <param name="overwrite_input">

/// If True, then allow the input array a to be modified by intermediate

/// calculations, to save memory.<br></br>

/// In this case, the contents of the input

/// a after this function completes is undefined.

/// </param>

/// <param name="interpolation">

/// This optional parameter specifies the interpolation method to

/// use when the desired quantile lies between two data points

/// i &lt; j:

/// </param>

/// <returns>

/// If q is a single quantile and axis=None, then the result

/// is a scalar.<br></br>

/// If multiple quantiles are given, first axis of

/// the result corresponds to the quantiles.<br></br>

/// The other axes are

/// the axes that remain after the reduction of a.<br></br>

/// If the input

/// contains integers or floats smaller than float64, the output

/// data-type is float64. Otherwise, the output data-type is the

/// same as that of the input.<br></br>

/// If out is specified, that array is

/// returned instead.

/// </returns>

public double quantile(NDarray a, NDarray<float> q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear")

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

q,

});

var kwargs=new PyDict();

if (@out!=null) kwargs["out"]=ToPython(@out);

if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input);

if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation);

dynamic py = __self__.InvokeMethod("quantile", pyargs, kwargs);

return ToCsharp<double>(py);

}

/// <summary>

/// Compute the qth quantile of the data along the specified axis,

/// while ignoring nan values.<br></br>

///

/// Returns the qth quantile(s) of the array elements.<br></br>

///

/// .. versionadded:: 1.15.0

/// </summary>

/// <param name="a">

/// Input array or object that can be converted to an array, containing

/// nan values to be ignored

/// </param>

/// <param name="q">

/// Quantile or sequence of quantiles to compute, which must be between

/// 0 and 1 inclusive.

/// </param>

/// <param name="axis">

/// Axis or axes along which the quantiles are computed.<br></br>

/// The

/// default is to compute the quantile(s) along a flattened

/// version of the array.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// It must

/// have the same shape and buffer length as the expected output,

/// but the type (of the output) will be cast if necessary.

/// </param>

/// <param name="overwrite_input">

/// If True, then allow the input array a to be modified by intermediate

/// calculations, to save memory.<br></br>

/// In this case, the contents of the input

/// a after this function completes is undefined.

/// </param>

/// <param name="interpolation">

/// This optional parameter specifies the interpolation method to

/// use when the desired quantile lies between two data points

/// i &lt; j:

/// </param>

/// <param name="keepdims">

/// If this is set to True, the axes which are reduced are left in

/// the result as dimensions with size one.<br></br>

/// With this option, the

/// result will broadcast correctly against the original array a.<br></br>

///

/// If this is anything but the default value it will be passed

/// through (in the special case of an empty array) to the

/// mean function of the underlying array.<br></br>

/// If the array is

/// a sub-class and mean does not have the kwarg keepdims this

/// will raise a RuntimeError.

/// </param>

/// <returns>

/// If q is a single percentile and axis=None, then the result

/// is a scalar.<br></br>

/// If multiple quantiles are given, first axis of

/// the result corresponds to the quantiles.<br></br>

/// The other axes are

/// the axes that remain after the reduction of a.<br></br>

/// If the input

/// contains integers or floats smaller than float64, the output

/// data-type is float64. Otherwise, the output data-type is the

/// same as that of the input.<br></br>

/// If out is specified, that array is

/// returned instead.

/// </returns>

public NDarray<double> nanquantile(NDarray a, NDarray<float> q, int[] axis, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear", bool? keepdims = null)

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

q,

});

var kwargs=new PyDict();

if (axis!=null) kwargs["axis"]=ToPython(axis);

if (@out!=null) kwargs["out"]=ToPython(@out);

if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input);

if (interpolation!="linear") kwargs["interpolation"]=ToPython(interpolation);

if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);

dynamic py = __self__.InvokeMethod("nanquantile", pyargs, kwargs);

return ToCsharp<NDarray<double>>(py);

}

/// <summary>

/// Compute the qth quantile of the data along the specified axis,

/// while ignoring nan values.<br></br>

///

/// Returns the qth quantile(s) of the array elements.<br></br>

///

/// .. versionadded:: 1.15.0

/// </summary>

/// <param name="a">

/// Input array or object that can be converted to an array, containing

/// nan values to be ignored

/// </param>

/// <param name="q">

/// Quantile or sequence of quantiles to compute, which must be between

/// 0 and 1 inclusive.

/// </param>

/// <param name="out">

/// Alternative output array in which to place the result.<br></br>

/// It must

/// have the same shape and buffer length as the expected output,

/// but the type (of the output) will be cast if necessary.

/// </param>

/// <param name="overwrite_input">

/// If True, then allow the input array a to be modified by intermediate

/// calculations, to save memory.<br></br>

/// In this case, the contents of the input

/// a after this function completes is undefined.

/// </param>

/// <param name="interpolation">

/// This optional parameter specifies the interpolation method to

/// use when the desired quantile lies between two data points

/// i &lt; j:

/// </param>

/// <returns>

/// If q is a single percentile and axis=None, then the result

/// is a scalar.<br></br>

/// If multiple quantiles are given, first axis of

/// the result corresponds to the quantiles.<br></br>

/// The other axes are

/// the axes that remain after the reduction of a.<br></br>

/// If the input

/// contains integers or floats smaller than float64, the output

/// data-type is float64. Otherwise, the output data-type is the

/// same as that of the input.<br></br>

/// If out is specified, that array is

/// returned instead.

/// </returns>

public double nanquantile(NDarray a, NDarray<float> q, NDarray @out = null, bool? overwrite_input = false, string interpolation = "linear")

{

//auto-generated code, do not change

var __self__=self;

var pyargs=ToTuple(new object[]

{

a,

q,

});