// Copyright (c) 2020 by Meinrad Recheis (Member of SciSharp)
// 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;
#if PYTHON_INCLUDED
using Python.Included;
#endif
namespace Numpy
{
public partial class NDarray
{
///
/// Copy an element of an array to a standard Python scalar and return it.
///
/// Notes
///
/// When the data type of a is longdouble or clongdouble, item() returns
/// a scalar array object because there is no available Python scalar that
/// would not lose information.
/// Void arrays return a buffer object for item(),
/// unless fields are defined, in which case a tuple is returned.
///
/// item is very similar to a[args], except, instead of an array scalar,
/// a standard Python scalar is returned.
/// This can be useful for speeding up
/// access to elements of the array and doing arithmetic on elements of the
/// array using Python’s optimized math.
///
///
/// A copy of the specified element of the array as a suitable
/// Python scalar
///
public T item(params int[] args)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
args,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("item", pyargs, kwargs);
return ToCsharp(py);
}
/*
///
/// Return the array as a (possibly nested) list.
///
/// Return a copy of the array data as a (nested) Python list.
///
/// Data items are converted to the nearest compatible Python type.
///
/// Notes
///
/// The array may be recreated, a = np.array(a.tolist()).
///
///
/// The possibly nested list of array elements.
///
public List tolist()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("tolist");
return ToCsharp>(py);
}
*/
///
/// Write array to a file as text or binary (default).
///
/// Data is always written in ‘C’ order, independent of the order of a.
///
/// The data produced by this method can be recovered using the function
/// fromfile().
///
/// Notes
///
/// This is a convenience function for quick storage of array data.
///
/// Information on endianness 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 endianness.
/// Some of these problems can be overcome
/// by outputting the data as text files, at the expense of speed and file
/// size.
///
/// When fid is a file object, array contents are directly written to the
/// file, bypassing the file object’s write method.
/// As a result, tofile
/// cannot be used with files objects supporting compression (e.g., GzipFile)
/// or file-like objects that do not support fileno() (e.g., BytesIO).
///
///
/// An open file object, or a string containing a filename.
///
///
/// Separator between array items for text output.
///
/// If “” (empty), a binary file is written, equivalent to
/// file.write(a.tobytes()).
///
///
/// Format string for text file output.
///
/// Each entry in the array is formatted to text by first converting
/// it to the closest Python type, and then using “format” % item.
///
public void tofile(string fid, string sep, string format)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
fid,
sep,
format,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("tofile", pyargs, kwargs);
}
///
/// Dump a pickle of the array to the specified file.
///
/// The array can be read back with pickle.load or numpy.load.
///
///
/// A string naming the dump file.
///
public void dump(string file)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
file,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("dump", pyargs, kwargs);
}
///
/// Returns the pickle of the array as a string.
///
/// pickle.loads or numpy.loads will convert the string back to an array.
///
public void dumps()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("dumps");
}
///
/// Copy of the array, cast to a specified type.
///
/// Notes
///
/// Starting in NumPy 1.9, astype method now returns an error if the string
/// dtype to cast to is not long enough in ‘safe’ casting mode to hold the max
/// value of integer/float array that is being casted.
/// Previously the casting
/// was allowed even if the result was truncated.
///
///
/// Typecode or data-type to which the array is cast.
///
///
/// Controls the memory layout order of the result.
///
/// ‘C’ means C order, ‘F’ means Fortran order, ‘A’
/// means ‘F’ order if all the arrays are Fortran contiguous,
/// ‘C’ order otherwise, and ‘K’ means as close to the
/// order the array elements appear in memory as possible.
///
/// Default is ‘K’.
///
///
/// Controls what kind of data casting may occur.
/// Defaults to ‘unsafe’
/// for backwards compatibility.
///
///
/// If True, then sub-classes will be passed-through (default), otherwise
/// the returned array will be forced to be a base-class array.
///
///
/// By default, astype always returns a newly allocated array.
/// If this
/// is set to false, and the dtype, order, and subok
/// requirements are satisfied, the input array is returned instead
/// of a copy.
///
///
/// Unless copy is False and the other conditions for returning the input
/// array are satisfied (see description for copy input parameter), arr_t
/// is a new array of the same shape as the input array, with dtype, order
/// given by dtype, order.
///
public NDarray astype(Dtype dtype, string order = null, string casting = null, bool? subok = null, bool? copy = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
dtype,
});
var kwargs=new PyDict();
if (order!=null) kwargs["order"]=ToPython(order);
if (casting!=null) kwargs["casting"]=ToPython(casting);
if (subok!=null) kwargs["subok"]=ToPython(subok);
if (copy!=null) kwargs["copy"]=ToPython(copy);
dynamic py = __self__.InvokeMethod("astype", pyargs, kwargs);
return ToCsharp(py);
}
///
/// 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.
///
///
/// If True, swap bytes in-place, default is False.
///
///
/// The byteswapped array.
/// If inplace is True, this is
/// a view to self.
///
public NDarray byteswap(bool? inplace = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (inplace!=null) kwargs["inplace"]=ToPython(inplace);
dynamic py = __self__.InvokeMethod("byteswap", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return a copy of the array.
///
///
/// Controls the memory layout of the copy.
/// ‘C’ means C-order,
/// ‘F’ means F-order, ‘A’ means ‘F’ if a is Fortran contiguous,
/// ‘C’ otherwise.
/// ‘K’ means match the layout of a as closely
/// as possible.
/// (Note that this function and numpy.copy are very
/// similar, but have different default values for their order=
/// arguments.)
///
public NDarray copy(string order = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (order!=null) kwargs["order"]=ToPython(order);
dynamic py = __self__.InvokeMethod("copy", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns a field of the given array as a certain type.
///
/// A field is a view of the array data with a given data-type.
/// The values in
/// the view are determined by the given type and the offset into the current
/// array in bytes.
/// The offset needs to be such that the view dtype fits in the
/// array dtype; for example an array of dtype complex128 has 16-byte elements.
///
/// If taking a view with a 32-bit integer (4 bytes), the offset needs to be
/// between 0 and 12 bytes.
///
///
/// The data type of the view.
/// The dtype size of the view can not be larger
/// than that of the array itself.
///
///
/// Number of bytes to skip before beginning the element view.
///
public void getfield(Dtype dtype, int offset)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
dtype,
offset,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("getfield", pyargs, kwargs);
}
///
/// Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
/// respectively.
///
/// These Boolean-valued flags affect how numpy interprets the memory
/// area used by a (see Notes below).
/// The ALIGNED flag can only
/// be set to True if the data is actually aligned according to the type.
///
/// The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
/// to True.
/// The flag WRITEABLE can only be set to True if the array owns its
/// own memory, or the ultimate owner of the memory exposes a writeable buffer
/// interface, or is a string.
/// (The exception for string is made so that
/// unpickling can be done without copying memory.)
///
/// Notes
///
/// Array flags provide information about how the memory area used
/// for the array is to be interpreted.
/// There are 7 Boolean flags
/// in use, only four of which can be changed by the user:
/// WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
///
/// WRITEABLE (W) the data area can be written to;
///
/// ALIGNED (A) the data and strides are aligned appropriately for the hardware
/// (as determined by the compiler);
///
/// UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
///
/// WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
/// by .base).
/// When the C-API function PyArray_ResolveWritebackIfCopy is
/// called, the base array will be updated with the contents of this array.
///
/// All flags can be accessed using the single (upper case) letter as well
/// as the full name.
///
///
/// Describes whether or not a can be written to.
///
///
/// Describes whether or not a is aligned properly for its type.
///
///
/// Describes whether or not a is a copy of another “base” array.
///
public void setflags(bool? write = null, bool? align = null, bool? uic = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (write!=null) kwargs["write"]=ToPython(write);
if (align!=null) kwargs["align"]=ToPython(align);
if (uic!=null) kwargs["uic"]=ToPython(uic);
dynamic py = __self__.InvokeMethod("setflags", pyargs, kwargs);
}
///
/// Fill the array with a scalar value.
///
///
/// All elements of a will be assigned this value.
///
public void fill(ValueType @value)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
@value,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("fill", pyargs, kwargs);
}
///
/// Return a copy of the array collapsed into one dimension.
///
///
/// ‘C’ means to flatten in row-major (C-style) order.
///
/// ‘F’ means to flatten in column-major (Fortran-
/// style) order.
/// ‘A’ means to flatten in column-major
/// order if a is Fortran contiguous in memory,
/// row-major order otherwise.
/// ‘K’ means to flatten
/// a in the order the elements occur in memory.
///
/// The default is ‘C’.
///
///
/// A copy of the input array, flattened to one dimension.
///
public NDarray flatten(string order = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (order!=null) kwargs["order"]=ToPython(order);
dynamic py = __self__.InvokeMethod("flatten", pyargs, kwargs);
return ToCsharp(py);
}
///
/// For unpickling.
///
/// The state argument must be a sequence that contains the following
/// elements:
///
///
/// optional pickle version.
/// If omitted defaults to 0.
///
///
/// a binary string with the data (or a list if ‘a’ is an object array)
///
public void __setstate__(int version, Shape shape, Dtype dtype, bool isFortran, string rawdata)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
version,
shape,
dtype,
isFortran,
rawdata,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("__setstate__", pyargs, kwargs);
}
///
/// Gives a new shape to an array without changing its data.
///
/// Notes
///
/// It is not always possible to change the shape of an array without
/// copying the data.
/// If you want an error to be raised when the data is copied,
/// you should assign the new shape to the shape attribute of the array:
///
/// The order keyword gives the index ordering both for fetching the values
/// from a, and then placing the values into the output array.
///
/// For example, let’s say you have an array:
///
/// You can think of reshaping as first raveling the array (using the given
/// index order), then inserting the elements from the raveled array into the
/// new array using the same kind of index ordering as was used for the
/// raveling.
///
///
/// The new shape should be compatible with the original shape.
/// If
/// an integer, then the result will be a 1-D array of that length.
///
/// One shape dimension can be -1. In this case, the value is
/// inferred from the length of the array and remaining dimensions.
///
///
/// Read the elements of a using this index order, and place the
/// elements into the reshaped array using this index order.
/// ‘C’
/// means to read / write the elements using C-like index order,
/// with the last axis index changing fastest, back to the first
/// axis index changing slowest.
/// ‘F’ means to read / write the
/// elements using Fortran-like index order, with the first index
/// changing fastest, and the last index changing slowest.
/// Note that
/// the ‘C’ and ‘F’ options take no account of the memory layout of
/// the underlying array, and only refer to the order of indexing.
///
/// ‘A’ means to read / write the elements in Fortran-like index
/// order if a is Fortran contiguous in memory, C-like order
/// otherwise.
///
///
/// This will be a new view object if possible; otherwise, it will
/// be a copy.
/// Note there is no guarantee of the memory layout (C- or
/// Fortran- contiguous) of the returned array.
///
public NDarray reshape(Shape newshape, string order = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
newshape,
});
var kwargs=new PyDict();
if (order!=null) kwargs["order"]=ToPython(order);
dynamic py = __self__.InvokeMethod("reshape", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return a contiguous flattened array.
///
/// A 1-D array, containing the elements of the input, is returned.
/// A copy is
/// made only if needed.
///
/// As of NumPy 1.10, the returned array will have the same type as the input
/// array.
/// (for example, a masked array will be returned for a masked array
/// input)
///
/// Notes
///
/// In row-major, C-style order, in two dimensions, the row index
/// varies the slowest, and the column index the quickest.
/// This can
/// be generalized to multiple dimensions, where row-major order
/// implies that the index along the first axis varies slowest, and
/// the index along the last quickest.
/// The opposite holds for
/// column-major, Fortran-style index ordering.
///
/// When a view is desired in as many cases as possible, arr.reshape(-1)
/// may be preferable.
///
///
/// The elements of a are read using this index order.
/// ‘C’ means
/// to index the elements in row-major, C-style order,
/// with the last axis index changing fastest, back to the first
/// axis index changing slowest.
/// ‘F’ means to index the elements
/// in column-major, Fortran-style order, with the
/// first index changing fastest, and the last index changing
/// slowest.
/// Note that the ‘C’ and ‘F’ options take no account of
/// the memory layout of the underlying array, and only refer to
/// the order of axis indexing.
/// ‘A’ means to read the elements in
/// Fortran-like index order if a is Fortran contiguous in
/// memory, C-like order otherwise.
/// ‘K’ means to read the
/// elements in the order they occur in memory, except for
/// reversing the data when strides are negative.
/// By default, ‘C’
/// index order is used.
///
///
/// y is an array of the same subtype as a, with shape (a.size,).
///
/// Note that matrices are special cased for backward compatibility, if a
/// is a matrix, then y is a 1-D ndarray.
///
public NDarray ravel(string order = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (order!=null) kwargs["order"]=ToPython(order);
dynamic py = __self__.InvokeMethod("ravel", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Move axes of an array to new positions.
///
/// Other axes remain in their original order.
///
///
/// Original positions of the axes to move.
/// These must be unique.
///
///
/// Destination positions for each of the original axes.
/// These must also be
/// unique.
///
///
/// Array with moved axes.
/// This array is a view of the input array.
///
public NDarray moveaxis(int[] source, int[] destination)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
source,
destination,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("moveaxis", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Roll the specified axis backwards, until it lies in a given position.
///
/// This function continues to be supported for backward compatibility, but you
/// should prefer moveaxis.
/// The moveaxis function was added in NumPy
/// 1.11.
///
///
/// The axis to roll backwards.
/// The positions of the other axes do not
/// change relative to one another.
///
///
/// The axis is rolled until it lies before this position.
/// The default,
/// 0, results in a “complete” roll.
///
///
/// For NumPy >= 1.10.0 a view of a is always returned.
/// For earlier
/// NumPy versions a view of a is returned only if the order of the
/// axes is changed, otherwise the input array is returned.
///
public NDarray rollaxis(int axis, int? start = 0)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
axis,
});
var kwargs=new PyDict();
if (start!=0) kwargs["start"]=ToPython(start);
dynamic py = __self__.InvokeMethod("rollaxis", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Interchange two axes of an array.
///
///
/// First axis.
///
///
/// Second axis.
///
///
/// For NumPy >= 1.10.0, if a is an ndarray, then a view of a is
/// returned; otherwise a new array is created.
/// For earlier NumPy
/// versions a view of a is returned only if the order of the
/// axes is changed, otherwise the input array is returned.
///
public NDarray swapaxes(int axis1, int axis2)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
axis1,
axis2,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("swapaxes", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Produce an object that mimics broadcasting.
///
///
/// Input parameters.
///
///
/// Broadcast the input parameters against one another, and
/// return an object that encapsulates the result.
///
/// Amongst others, it has shape and nd properties, and
/// may be used as an iterator.
///
public NDarray broadcast(NDarray in1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
in1,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("broadcast", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Broadcast an array to a new shape.
///
/// Notes
///
///
/// The shape of the desired array.
///
///
/// If True, then sub-classes will be passed-through, otherwise
/// the returned array will be forced to be a base-class array (default).
///
///
/// A readonly view on the original array with the given shape.
/// It is
/// typically not contiguous.
/// Furthermore, more than one element of a
/// broadcasted array may refer to a single memory location.
///
public NDarray broadcast_to(Shape shape, bool? subok = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
shape,
});
var kwargs=new PyDict();
if (subok!=false) kwargs["subok"]=ToPython(subok);
dynamic py = __self__.InvokeMethod("broadcast_to", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Expand the shape of an array.
///
/// Insert a new axis that will appear at the axis position in the expanded
/// array shape.
///
///
/// Position in the expanded axes where the new axis is placed.
///
///
/// Output array.
/// The number of dimensions is one greater than that of
/// the input array.
///
public NDarray expand_dims(int axis)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
axis,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("expand_dims", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Remove single-dimensional entries from the shape of an array.
///
///
/// Selects a subset of the single-dimensional entries in the
/// shape.
/// If an axis is selected with shape entry greater than
/// one, an error is raised.
///
///
/// The input array, but with all or a subset of the
/// dimensions of length 1 removed.
/// This is always a itself
/// or a view into a.
///
public NDarray squeeze(Axis axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("squeeze", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return an array converted to a float type.
///
///
/// Float type code to coerce input array a.
/// If dtype is one of the
/// ‘int’ dtypes, it is replaced with float64.
///
///
/// The input a as a float ndarray.
///
public NDarray asfarray(Dtype dtype = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
dynamic py = __self__.InvokeMethod("asfarray", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return an array (ndim >= 1) laid out in Fortran order in memory.
///
///
/// By default, the data-type is inferred from the input data.
///
///
/// The input a in Fortran, or column-major, order.
///
public NDarray asfortranarray(Dtype dtype = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
dynamic py = __self__.InvokeMethod("asfortranarray", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Convert the input to an array, checking for NaNs or Infs.
///
///
/// By default, the data-type is inferred from the input data.
///
///
/// Whether to use row-major (C-style) or
/// column-major (Fortran-style) memory representation.
///
/// Defaults to ‘C’.
///
///
/// Array interpretation of a.
/// No copy is performed if the input
/// is already an ndarray.
/// If a is a subclass of ndarray, a base
/// class ndarray is returned.
///
public NDarray asarray_chkfinite(Dtype dtype = null, string order = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
if (order!=null) kwargs["order"]=ToPython(order);
dynamic py = __self__.InvokeMethod("asarray_chkfinite", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return an ndarray of the provided type that satisfies requirements.
///
/// This function is useful to be sure that an array with the correct flags
/// is returned for passing to compiled code (perhaps through ctypes).
///
/// Notes
///
/// The returned array will be guaranteed to have the listed requirements
/// by making a copy if needed.
///
///
/// The required data-type.
/// If None preserve the current dtype.
/// If your
/// application requires the data to be in native byteorder, include
/// a byteorder specification as a part of the dtype specification.
///
///
/// The requirements list can be any of the following
///
public NDarray require(Dtype dtype, string[] requirements = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
dtype,
});
var kwargs=new PyDict();
if (requirements!=null) kwargs["requirements"]=ToPython(requirements);
dynamic py = __self__.InvokeMethod("require", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Split an array into multiple sub-arrays.
///
///
/// If indices_or_sections is an integer, N, the array will be divided
/// into N equal arrays along axis.
/// If such a split is not possible,
/// an error is raised.
///
/// If indices_or_sections is a 1-D array of sorted integers, the entries
/// indicate where along axis the array is split.
/// For example,
/// [2, 3] would, for axis=0, result in
///
/// If an index exceeds the dimension of the array along axis,
/// an empty sub-array is returned correspondingly.
///
///
/// The axis along which to split, default is 0.
///
///
/// A list of sub-arrays.
///
public NDarray[] split(int[] indices_or_sections, int? axis = 0)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
indices_or_sections,
});
var kwargs=new PyDict();
if (axis!=0) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("split", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Construct an array by repeating A the number of times given by reps.
///
/// If reps has length d, the result will have dimension of
/// max(d, A.ndim).
///
/// If A.ndim < d, A is promoted to be d-dimensional by prepending new
/// axes.
/// So a shape (3,) array is promoted to (1, 3) for 2-D replication,
/// or shape (1, 1, 3) for 3-D replication.
/// If this is not the desired
/// behavior, promote A to d-dimensions manually before calling this
/// function.
///
/// If A.ndim > d, reps is promoted to A.ndim by pre-pending 1’s to it.
///
/// Thus for an A of shape (2, 3, 4, 5), a reps of (2, 2) is treated as
/// (1, 1, 2, 2).
///
/// Note : Although tile may be used for broadcasting, it is strongly
/// recommended to use numpy’s broadcasting operations and functions.
///
///
/// The number of repetitions of A along each axis.
///
///
/// The tiled output array.
///
public NDarray tile(NDarray reps)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
reps,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("tile", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Repeat elements of an array.
///
///
/// The number of repetitions for each element.
/// repeats is broadcasted
/// to fit the shape of the given axis.
///
///
/// The axis along which to repeat values.
/// By default, use the
/// flattened input array, and return a flat output array.
///
///
/// Output array which has the same shape as a, except along
/// the given axis.
///
public NDarray repeat(int[] repeats, int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
repeats,
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("repeat", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return a new array with sub-arrays along an axis deleted.
/// For a one
/// dimensional array, this returns those entries not returned by
/// arr[obj].
///
/// Notes
///
/// Often it is preferable to use a boolean mask.
/// For example:
///
/// Is equivalent to np.delete(arr, [0,2,4], axis=0), but allows further
/// use of mask.
///
///
/// Indicate which sub-arrays to remove.
///
///
/// The axis along which to delete the subarray defined by obj.
///
/// If axis is None, obj is applied to the flattened array.
///
///
/// A copy of arr with the elements specified by obj removed.
/// Note
/// that delete does not occur in-place.
/// If axis is None, out is
/// a flattened array.
///
public NDarray delete(Slice obj, int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
obj,
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("delete", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Append values to the end of an array.
///
///
/// These values are appended to a copy of arr.
/// It must be of the
/// correct shape (the same shape as arr, excluding axis).
/// If
/// axis is not specified, values can be any shape and will be
/// flattened before use.
///
///
/// The axis along which values are appended.
/// If axis is not
/// given, both arr and values are flattened before use.
///
///
/// A copy of arr with values appended to axis.
/// Note that
/// append does not occur in-place: a new array is allocated and
/// filled.
/// If axis is None, out is a flattened array.
///
public NDarray append(NDarray values, int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
values,
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("append", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Trim the leading and/or trailing zeros from a 1-D array or sequence.
///
///
/// A string with ‘f’ representing trim from front and ‘b’ to trim from
/// back.
/// Default is ‘fb’, trim zeros from both front and back of the
/// array.
///
///
/// The result of trimming the input.
/// The input data type is preserved.
///
public NDarray trim_zeros(string trim = "fb")
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (trim!="fb") kwargs["trim"]=ToPython(trim);
dynamic py = __self__.InvokeMethod("trim_zeros", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Find the unique elements of an array.
///
/// Returns the sorted unique elements of an array.
/// There are three optional
/// outputs in addition to the unique elements:
///
/// Notes
///
/// When an axis is specified the subarrays indexed by the axis are sorted.
///
/// This is done by making the specified axis the first dimension of the array
/// and then flattening the subarrays in C order.
/// The flattened subarrays are
/// then viewed as a structured type with each element given a label, with the
/// effect that we end up with a 1-D array of structured types that can be
/// treated in the same way as any other 1-D array.
/// The result is that the
/// flattened subarrays are sorted in lexicographic order starting with the
/// first element.
///
///
/// The axis to operate on.
/// If None, ar will be flattened.
/// If an integer,
/// the subarrays indexed by the given axis will be flattened and treated
/// as the elements of a 1-D array with the dimension of the given axis,
/// see the notes for more details.
/// Object arrays or structured arrays
/// that contain objects are not supported if the axis kwarg is used.
/// The
/// default is None.
///
///
/// The sorted unique values.
///
public NDarray unique(int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("unique", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Find the unique elements of an array.
///
/// Returns the sorted unique elements of an array.
/// There are three optional
/// outputs in addition to the unique elements:
///
/// Notes
///
/// When an axis is specified the subarrays indexed by the axis are sorted.
///
/// This is done by making the specified axis the first dimension of the array
/// and then flattening the subarrays in C order.
/// The flattened subarrays are
/// then viewed as a structured type with each element given a label, with the
/// effect that we end up with a 1-D array of structured types that can be
/// treated in the same way as any other 1-D array.
/// The result is that the
/// flattened subarrays are sorted in lexicographic order starting with the
/// first element.
///
///
/// If True, also return the indices of ar (along the specified axis,
/// if provided, or in the flattened array) that result in the unique array.
///
///
/// If True, also return the indices of the unique array (for the specified
/// axis, if provided) that can be used to reconstruct ar.
///
///
/// If True, also return the number of times each unique item appears
/// in ar.
///
///
/// The axis to operate on.
/// If None, ar will be flattened.
/// If an integer,
/// the subarrays indexed by the given axis will be flattened and treated
/// as the elements of a 1-D array with the dimension of the given axis,
/// see the notes for more details.
/// Object arrays or structured arrays
/// that contain objects are not supported if the axis kwarg is used.
/// The
/// default is None.
///
///
/// The sorted unique values.
///
public NDarray[] unique(bool return_index, bool return_inverse, bool return_counts, int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (return_index!=null) kwargs["return_index"]=ToPython(return_index);
if (return_inverse!=null) kwargs["return_inverse"]=ToPython(return_inverse);
if (return_counts!=null) kwargs["return_counts"]=ToPython(return_counts);
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("unique", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Reverse the order of elements in an array along the given axis.
///
/// The shape of the array is preserved, but the elements are reordered.
///
/// Notes
///
/// flip(m, 0) is equivalent to flipud(m).
///
/// flip(m, 1) is equivalent to fliplr(m).
///
/// flip(m, n) corresponds to m[...,::-1,...] with ::-1 at position n.
///
/// flip(m) corresponds to m[::-1,::-1,...,::-1] with ::-1 at all
/// positions.
///
/// flip(m, (0, 1)) corresponds to m[::-1,::-1,...] with ::-1 at
/// position 0 and position 1.
///
///
/// Axis or axes along which to flip over.
/// The default,
/// axis=None, will flip over all of the axes of the input array.
///
/// If axis is negative it counts from the last to the first axis.
///
/// If axis is a tuple of ints, flipping is performed on all of the axes
/// specified in the tuple.
///
///
/// A view of m with the entries of axis reversed.
/// Since a view is
/// returned, this operation is done in constant time.
///
public NDarray flip(Axis axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("flip", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Flip array in the left/right direction.
///
/// Flip the entries in each row in the left/right direction.
///
/// Columns are preserved, but appear in a different order than before.
///
/// Notes
///
/// Equivalent to m[:,::-1].
/// Requires the array to be at least 2-D.
///
///
/// A view of m with the columns reversed.
/// Since a view
/// is returned, this operation is .
///
public NDarray fliplr()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("fliplr");
return ToCsharp(py);
}
///
/// Flip array in the up/down direction.
///
/// Flip the entries in each column in the up/down direction.
///
/// Rows are preserved, but appear in a different order than before.
///
/// Notes
///
/// Equivalent to m[::-1,...].
///
/// Does not require the array to be two-dimensional.
///
///
/// A view of m with the rows reversed.
/// Since a view is
/// returned, this operation is .
///
public NDarray flipud()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("flipud");
return ToCsharp(py);
}
///
/// Roll array elements along a given axis.
///
/// Elements that roll beyond the last position are re-introduced at
/// the first.
///
/// Notes
///
/// Supports rolling over multiple dimensions simultaneously.
///
///
/// The number of places by which elements are shifted.
/// If a tuple,
/// then axis must be a tuple of the same size, and each of the
/// given axes is shifted by the corresponding number.
/// If an int
/// while axis is a tuple of ints, then the same value is used for
/// all given axes.
///
///
/// Axis or axes along which elements are shifted.
/// By default, the
/// array is flattened before shifting, after which the original
/// shape is restored.
///
///
/// Output array, with the same shape as a.
///
public NDarray roll(int[] shift, Axis axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
shift,
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("roll", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Rotate an array by 90 degrees in the plane specified by axes.
///
/// Rotation direction is from the first towards the second axis.
///
/// Notes
///
/// rot90(m, k=1, axes=(1,0)) is the reverse of rot90(m, k=1, axes=(0,1))
/// rot90(m, k=1, axes=(1,0)) is equivalent to rot90(m, k=-1, axes=(0,1))
///
///
/// Number of times the array is rotated by 90 degrees.
///
///
/// The array is rotated in the plane defined by the axes.
///
/// Axes must be different.
///
///
/// A rotated view of m.
///
public NDarray rot90(int k = 1, int[] axes = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (k!=1) kwargs["k"]=ToPython(k);
if (axes!=null) kwargs["axes"]=ToPython(axes);
dynamic py = __self__.InvokeMethod("rot90", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the bit-wise AND of two arrays element-wise.
///
/// Computes the bit-wise AND of the underlying binary representation of
/// the integers in the input arrays.
/// This ufunc implements the C/Python
/// operator &.
///
///
/// Only integer and boolean types are handled.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Result.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray bitwise_and(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("bitwise_and", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the bit-wise OR of two arrays element-wise.
///
/// Computes the bit-wise OR of the underlying binary representation of
/// the integers in the input arrays.
/// This ufunc implements the C/Python
/// operator |.
///
///
/// Only integer and boolean types are handled.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Result.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray bitwise_or(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("bitwise_or", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the bit-wise XOR of two arrays element-wise.
///
/// Computes the bit-wise XOR of the underlying binary representation of
/// the integers in the input arrays.
/// This ufunc implements the C/Python
/// operator ^.
///
///
/// Only integer and boolean types are handled.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Result.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray bitwise_xor(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("bitwise_xor", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute bit-wise inversion, or bit-wise NOT, element-wise.
///
/// Computes the bit-wise NOT of the underlying binary representation of
/// the integers in the input arrays.
/// This ufunc implements the C/Python
/// operator ~.
///
/// For signed integer inputs, the two’s complement is returned.
/// In a
/// two’s-complement system negative numbers are represented by the two’s
/// complement of the absolute value.
/// This is the most common method of
/// representing signed integers on computers [1].
/// A N-bit
/// two’s-complement system can represent every integer in the range
/// to .
///
/// Notes
///
/// bitwise_not is an alias for invert:
///
/// References
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Result.
///
/// This is a scalar if x is a scalar.
///
public NDarray invert(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("invert", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Shift the bits of an integer to the right.
///
/// Bits are shifted to the right x2. Because the internal
/// representation of numbers is in binary format, this operation is
/// equivalent to dividing x1 by 2**x2.
///
///
/// Number of bits to remove at the right of x1.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Return x1 with bits shifted x2 times to the right.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray right_shift(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("right_shift", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Packs the elements of a binary-valued array into bits in a uint8 array.
///
/// The result is padded to full bytes by inserting zero bits at the end.
///
///
/// The dimension over which bit-packing is done.
///
/// None implies packing the flattened array.
///
///
/// Array of type uint8 whose elements represent bits corresponding to the
/// logical (0 or nonzero) value of the input elements.
/// The shape of
/// packed has the same number of dimensions as the input (unless axis
/// is None, in which case the output is 1-D).
///
public NDarray packbits(int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("packbits", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Unpacks elements of a uint8 array into a binary-valued output array.
///
/// Each element of myarray represents a bit-field that should be unpacked
/// into a binary-valued output array.
/// The shape of the output array is either
/// 1-D (if axis is None) or the same shape as the input array with unpacking
/// done along the axis specified.
///
///
/// The dimension over which bit-unpacking is done.
///
/// None implies unpacking the flattened array.
///
///
/// The elements are binary-valued (0 or 1).
///
public NDarray unpackbits(int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("unpackbits", pyargs, kwargs);
return ToCsharp(py);
}
///
/// For scalar a, returns the data type with the smallest size
/// and smallest scalar kind which can hold its value.
/// For non-scalar
/// array a, returns the vector’s dtype unmodified.
///
/// Floating point values are not demoted to integers,
/// and complex values are not demoted to floats.
///
/// Notes
///
///
/// The minimal data type.
///
public Dtype min_scalar_type()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("min_scalar_type");
return ToCsharp(py);
}
///
/// Return a scalar type which is common to the input arrays.
///
/// The return type will always be an inexact (i.e.
/// floating point) scalar
/// type, even if all the arrays are integer arrays.
/// If one of the inputs is
/// an integer array, the minimum precision type that is returned is a
/// 64-bit floating point dtype.
///
/// All input arrays except int64 and uint64 can be safely cast to the
/// returned dtype without loss of information.
///
///
/// Input arrays.
///
///
/// Data type code.
///
public Dtype common_type(NDarray array1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
array1,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("common_type", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Modified Bessel function of the first kind, order 0.
///
/// Usually denoted . This function does broadcast, but will not
/// “up-cast” int dtype arguments unless accompanied by at least one float or
/// complex dtype argument (see Raises below).
///
/// Notes
///
/// We use the algorithm published by Clenshaw [1] and referenced by
/// Abramowitz and Stegun [2], for which the function domain is
/// partitioned into the two intervals [0,8] and (8,inf), and Chebyshev
/// polynomial expansions are employed in each interval.
/// Relative error on
/// the domain [0,30] using IEEE arithmetic is documented [3] as having a
/// peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).
///
/// References
///
///
/// The modified Bessel function evaluated at each of the elements of x.
///
public NDarray i0()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("i0");
return ToCsharp(py);
}
///
/// Compute the future value.
///
/// Notes
///
/// The future value is computed by solving the equation:
///
/// or, when rate == 0:
///
/// References
///
///
/// Number of compounding periods
///
///
/// Payment
///
///
/// Present value
///
///
/// When payments are due (‘begin’ (1) or ‘end’ (0)).
///
/// Defaults to {‘end’, 0}.
///
///
/// Future values.
/// If all input is scalar, returns a scalar float.
/// If
/// any input is array_like, returns future values for each input element.
///
/// If multiple inputs are array_like, they all must have the same shape.
///
public NDarray fv(NDarray nper, NDarray pmt, NDarray pv, string @when = "end")
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
nper,
pmt,
pv,
});
var kwargs=new PyDict();
if (@when!="end") kwargs["when"]=ToPython(@when);
dynamic py = __self__.InvokeMethod("fv", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the present value.
///
/// Notes
///
/// The present value is computed by solving the equation:
///
/// or, when rate = 0:
///
/// for pv, which is then returned.
///
/// References
///
///
/// Number of compounding periods
///
///
/// Payment
///
///
/// Future value
///
///
/// When payments are due (‘begin’ (1) or ‘end’ (0))
///
///
/// Present value of a series of payments or investments.
///
public NDarray pv(NDarray nper, NDarray pmt, NDarray fv = null, string @when = "end")
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
nper,
pmt,
});
var kwargs=new PyDict();
if (fv!=null) kwargs["fv"]=ToPython(fv);
if (@when!="end") kwargs["when"]=ToPython(@when);
dynamic py = __self__.InvokeMethod("pv", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the payment against loan principal plus interest.
///
/// Notes
///
/// The payment is computed by solving the equation:
///
/// or, when rate == 0:
///
/// for pmt.
///
/// Note that computing a monthly mortgage payment is only
/// one use for this function.
/// For example, pmt returns the
/// periodic deposit one must make to achieve a specified
/// future balance given an initial deposit, a fixed,
/// periodically compounded interest rate, and the total
/// number of periods.
///
/// References
///
///
/// Number of compounding periods
///
///
/// Present value
///
///
/// Future value (default = 0)
///
///
/// When payments are due (‘begin’ (1) or ‘end’ (0))
///
///
/// Payment against loan plus interest.
/// If all input is scalar, returns a
/// scalar float.
/// If any input is array_like, returns payment for each
/// input element.
/// If multiple inputs are array_like, they all must have
/// the same shape.
///
public NDarray pmt(NDarray nper, NDarray pv, NDarray fv = null, string @when = "end")
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
nper,
pv,
});
var kwargs=new PyDict();
if (fv!=null) kwargs["fv"]=ToPython(fv);
if (@when!="end") kwargs["when"]=ToPython(@when);
dynamic py = __self__.InvokeMethod("pmt", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the payment against loan principal.
///
///
/// Amount paid against the loan changes.
/// The per is the period of
/// interest.
///
///
/// Number of compounding periods
///
///
/// Present value
///
///
/// Future value
///
///
/// When payments are due (‘begin’ (1) or ‘end’ (0))
///
public void ppmt(NDarray per, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end")
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
per,
nper,
pv,
});
var kwargs=new PyDict();
if (fv!=null) kwargs["fv"]=ToPython(fv);
if (@when!="end") kwargs["when"]=ToPython(@when);
dynamic py = __self__.InvokeMethod("ppmt", pyargs, kwargs);
}
///
/// Compute the interest portion of a payment.
///
/// Notes
///
/// The total payment is made up of payment against principal plus interest.
///
/// pmt = ppmt + ipmt
///
///
/// Interest paid against the loan changes during the life or the loan.
///
/// The per is the payment period to calculate the interest amount.
///
///
/// Number of compounding periods
///
///
/// Present value
///
///
/// Future value
///
///
/// When payments are due (‘begin’ (1) or ‘end’ (0)).
///
/// Defaults to {‘end’, 0}.
///
///
/// Interest portion of payment.
/// If all input is scalar, returns a scalar
/// float.
/// If any input is array_like, returns interest payment for each
/// input element.
/// If multiple inputs are array_like, they all must have
/// the same shape.
///
public NDarray ipmt(NDarray per, NDarray nper, NDarray pv, NDarray fv = null, string @when = "end")
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
per,
nper,
pv,
});
var kwargs=new PyDict();
if (fv!=null) kwargs["fv"]=ToPython(fv);
if (@when!="end") kwargs["when"]=ToPython(@when);
dynamic py = __self__.InvokeMethod("ipmt", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the Internal Rate of Return (IRR).
///
/// This is the “average” periodically compounded rate of return
/// that gives a net present value of 0.0; for a more complete explanation,
/// see Notes below.
///
/// decimal.Decimal type is not supported.
///
/// Notes
///
/// The IRR is perhaps best understood through an example (illustrated
/// using np.irr in the Examples section below).
/// Suppose one invests 100
/// units and then makes the following withdrawals at regular (fixed)
/// intervals: 39, 59, 55, 20. Assuming the ending value is 0, one’s 100
/// unit investment yields 173 units; however, due to the combination of
/// compounding and the periodic withdrawals, the “average” rate of return
/// is neither simply 0.73/4 nor (1.73)^0.25-1. Rather, it is the solution
/// (for ) of the equation:
///
/// In general, for values ,
/// irr is the solution of the equation: [G]
///
/// References
///
///
/// Internal Rate of Return for periodic input values.
///
public float irr()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("irr");
return ToCsharp(py);
}
///
/// Modified internal rate of return.
///
///
/// Interest rate paid on the cash flows
///
///
/// Interest rate received on the cash flows upon reinvestment
///
///
/// Modified internal rate of return
///
public float mirr(ValueType finance_rate, ValueType reinvest_rate)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
finance_rate,
reinvest_rate,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("mirr", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the number of periodic payments.
///
/// decimal.Decimal type is not supported.
///
/// Notes
///
/// The number of periods nper is computed by solving the equation:
///
/// but if rate = 0 then:
///
///
/// Payment
///
///
/// Present value
///
///
/// Future value
///
///
/// When payments are due (‘begin’ (1) or ‘end’ (0))
///
public void nper(NDarray pmt, NDarray pv, NDarray fv = null, string @when = "end")
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
pmt,
pv,
});
var kwargs=new PyDict();
if (fv!=null) kwargs["fv"]=ToPython(fv);
if (@when!="end") kwargs["when"]=ToPython(@when);
dynamic py = __self__.InvokeMethod("nper", pyargs, kwargs);
}
///
/// Compute the rate of interest per period.
///
/// Notes
///
/// The rate of interest is computed by iteratively solving the
/// (non-linear) equation:
///
/// for rate.
///
/// References
///
/// Wheeler, D.
/// A., E.
/// Rathke, and R.
/// Weir (Eds.) (2009, May).
/// Open Document
/// Format for Office Applications (OpenDocument)v1.2, Part 2: Recalculated
/// Formula (OpenFormula) Format - Annotated Version, Pre-Draft 12.
/// Organization for the Advancement of Structured Information Standards
/// (OASIS).
/// Billerica, MA, USA.
/// [ODT Document].
/// Available:
/// http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula
/// OpenDocument-formula-20090508.odt
///
///
/// Payment
///
///
/// Present value
///
///
/// Future value
///
///
/// When payments are due (‘begin’ (1) or ‘end’ (0))
///
///
/// Starting guess for solving the rate of interest, default 0.1
///
///
/// Required tolerance for the solution, default 1e-6
///
///
/// Maximum iterations in finding the solution
///
public void rate(NDarray pmt, NDarray pv, NDarray fv, string @when = "end", double? guess = null, double? tol = null, int? maxiter = 100)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
pmt,
pv,
fv,
});
var kwargs=new PyDict();
if (@when!="end") kwargs["when"]=ToPython(@when);
if (guess!=null) kwargs["guess"]=ToPython(guess);
if (tol!=null) kwargs["tol"]=ToPython(tol);
if (maxiter!=100) kwargs["maxiter"]=ToPython(maxiter);
dynamic py = __self__.InvokeMethod("rate", pyargs, kwargs);
}
///
/// Return the indices of the elements that are non-zero.
///
/// Returns a tuple of arrays, one for each dimension of a,
/// containing the indices of the non-zero elements in that
/// dimension.
/// The values in a are always tested and returned in
/// row-major, C-style order.
/// The corresponding non-zero
/// values can be obtained with:
///
/// To group the indices by element, rather than dimension, use:
///
/// The result of this is always a 2-D array, with a row for
/// each non-zero element.
///
///
/// Indices of elements that are non-zero.
///
public NDarray[] nonzero()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("nonzero");
return ToCsharp(py);
}
///
/// Return elements chosen from x or y depending on condition.
///
/// Notes
///
/// If all the arrays are 1-D, where is equivalent to:
///
///
/// Values from which to choose.
/// x, y and condition need to be
/// broadcastable to some shape.
///
///
/// Values from which to choose.
/// x, y and condition need to be
/// broadcastable to some shape.
///
///
/// An array with elements from x where condition is True, and elements
/// from y elsewhere.
///
public NDarray @where(NDarray y, NDarray x)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
y,
x,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("where", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return elements chosen from x or y depending on condition.
///
/// Notes
///
/// If all the arrays are 1-D, where is equivalent to:
///
///
/// An array with elements from x where condition is True, and elements
/// from y elsewhere.
///
public NDarray[] @where()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("where");
return ToCsharp(py);
}
///
/// Converts a flat index or array of flat indices into a tuple
/// of coordinate arrays.
///
///
/// The shape of the array to use for unraveling indices.
///
///
/// Determines whether the indices should be viewed as indexing in
/// row-major (C-style) or column-major (Fortran-style) order.
///
///
/// Each array in the tuple has the same shape as the indices
/// array.
///
public NDarray[] unravel_index(Shape shape, string order = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
shape,
});
var kwargs=new PyDict();
if (order!=null) kwargs["order"]=ToPython(order);
dynamic py = __self__.InvokeMethod("unravel_index", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the indices to access the main diagonal of an n-dimensional array.
///
/// See diag_indices for full details.
///
/// Notes
///
public void diag_indices_from()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("diag_indices_from");
}
///
/// Return the indices for the lower-triangle of arr.
///
/// See tril_indices for full details.
///
/// Notes
///
///
/// Diagonal offset (see tril for details).
///
public void tril_indices_from(int? k = 0)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (k!=0) kwargs["k"]=ToPython(k);
dynamic py = __self__.InvokeMethod("tril_indices_from", pyargs, kwargs);
}
///
/// Return the indices for the upper-triangle of arr.
///
/// See triu_indices for full details.
///
/// Notes
///
///
/// Diagonal offset (see triu for details).
///
///
/// Indices for the upper-triangle of arr.
///
public NDarray[] triu_indices_from(int? k = 0)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (k!=0) kwargs["k"]=ToPython(k);
dynamic py = __self__.InvokeMethod("triu_indices_from", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Take values from the input array by matching 1d index and data slices.
///
/// This iterates over matching 1d slices oriented along the specified axis in
/// the index and data arrays, and uses the former to look up values in the
/// latter.
/// These slices can be different lengths.
///
/// Functions returning an index along an axis, like argsort and
/// argpartition, produce suitable indices for this function.
///
/// Notes
///
/// This is equivalent to (but faster than) the following use of ndindex and
/// s_, which sets each of ii and kk to a tuple of indices:
///
/// Equivalently, eliminating the inner loop, the last two lines would be:
///
///
/// Indices to take along each 1d slice of arr.
/// This must match the
/// dimension of arr, but dimensions Ni and Nj only need to broadcast
/// against arr.
///
///
/// The axis to take 1d slices along.
/// If axis is None, the input array is
/// treated as if it had first been flattened to 1d, for consistency with
/// sort and argsort.
///
public NDarray take_along_axis(NDarray indices, int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
indices,
axis,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("take_along_axis", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return specified diagonals.
///
/// If a is 2-D, returns the diagonal of a with the given offset,
/// i.e., the collection of elements of the form a[i, i+offset].
/// If
/// a has more than two dimensions, then the axes specified by axis1
/// and axis2 are used to determine the 2-D sub-array whose diagonal is
/// returned.
/// The shape of the resulting array can be determined by
/// removing axis1 and axis2 and appending an index to the right equal
/// to the size of the resulting diagonals.
///
/// In versions of NumPy prior to 1.7, this function always returned a new,
/// independent array containing a copy of the values in the diagonal.
///
/// In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal,
/// but depending on this fact is deprecated.
/// Writing to the resulting
/// array continues to work as it used to, but a FutureWarning is issued.
///
/// Starting in NumPy 1.9 it returns a read-only view on the original array.
///
/// Attempting to write to the resulting array will produce an error.
///
/// In some future release, it will return a read/write view and writing to
/// the returned array will alter your original array.
/// The returned array
/// will have the same type as the input array.
///
/// If you don’t write to the array returned by this function, then you can
/// just ignore all of the above.
///
/// If you depend on the current behavior, then we suggest copying the
/// returned array explicitly, i.e., use np.diagonal(a).copy() instead
/// of just np.diagonal(a).
/// This will work with both past and future
/// versions of NumPy.
///
///
/// Offset of the diagonal from the main diagonal.
/// Can be positive or
/// negative.
/// Defaults to main diagonal (0).
///
///
/// Axis to be used as the first axis of the 2-D sub-arrays from which
/// the diagonals should be taken.
/// Defaults to first axis (0).
///
///
/// Axis to be used as the second axis of the 2-D sub-arrays from
/// which the diagonals should be taken.
/// Defaults to second axis (1).
///
///
/// If a is 2-D, then a 1-D array containing the diagonal and of the
/// same type as a is returned unless a is a matrix, in which case
/// a 1-D array rather than a (2-D) matrix is returned in order to
/// maintain backward compatibility.
///
/// If a.ndim > 2, then the dimensions specified by axis1 and axis2
/// are removed, and a new axis inserted at the end corresponding to the
/// diagonal.
///
public NDarray diagonal(int? offset = 0, int? axis1 = 0, int? axis2 = 1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (offset!=0) kwargs["offset"]=ToPython(offset);
if (axis1!=0) kwargs["axis1"]=ToPython(axis1);
if (axis2!=1) kwargs["axis2"]=ToPython(axis2);
dynamic py = __self__.InvokeMethod("diagonal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Change elements of an array based on conditional and input values.
///
/// Similar to np.copyto(arr, vals, where=mask), the difference is that
/// place uses the first N elements of vals, where N is the number of
/// True values in mask, while copyto uses the elements where mask
/// is True.
///
/// Note that extract does the exact opposite of place.
///
///
/// Boolean mask array.
/// Must have the same size as a.
///
///
/// Values to put into a.
/// Only the first N elements are used, where
/// N is the number of True values in mask.
/// If vals is smaller
/// than N, it will be repeated, and if elements of a are to be masked,
/// this sequence must be non-empty.
///
public void place(NDarray mask, NDarray vals)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
mask,
vals,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("place", pyargs, kwargs);
}
///
/// Replaces specified elements of an array with given values.
///
/// The indexing works on the flattened target array.
/// put is roughly
/// equivalent to:
///
///
/// Target indices, interpreted as integers.
///
///
/// Values to place in a at target indices.
/// If v is shorter than
/// ind it will be repeated as necessary.
///
///
/// Specifies how out-of-bounds indices will behave.
///
/// ‘clip’ mode means that all indices that are too large are replaced
/// by the index that addresses the last element along that axis.
/// Note
/// that this disables indexing with negative numbers.
///
public void put(NDarray ind, NDarray v, string mode = "raise")
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
ind,
v,
});
var kwargs=new PyDict();
if (mode!="raise") kwargs["mode"]=ToPython(mode);
dynamic py = __self__.InvokeMethod("put", pyargs, kwargs);
}
///
/// Put values into the destination array by matching 1d index and data slices.
///
/// This iterates over matching 1d slices oriented along the specified axis in
/// the index and data arrays, and uses the former to place values into the
/// latter.
/// These slices can be different lengths.
///
/// Functions returning an index along an axis, like argsort and
/// argpartition, produce suitable indices for this function.
///
/// Notes
///
/// This is equivalent to (but faster than) the following use of ndindex and
/// s_, which sets each of ii and kk to a tuple of indices:
///
/// Equivalently, eliminating the inner loop, the last two lines would be:
///
///
/// Indices to change along each 1d slice of arr.
/// This must match the
/// dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast
/// against arr.
///
///
/// values to insert at those indices.
/// Its shape and dimension are
/// broadcast to match that of indices.
///
///
/// The axis to take 1d slices along.
/// If axis is None, the destination
/// array is treated as if a flattened 1d view had been created of it.
///
public void put_along_axis(NDarray indices, NDarray[] values, int axis)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
indices,
values,
axis,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("put_along_axis", pyargs, kwargs);
}
///
/// Changes elements of an array based on conditional and input values.
///
/// Sets a.flat[n] = values[n] for each n where mask.flat[n]==True.
///
/// If values is not the same size as a and mask then it will repeat.
///
/// This gives behavior different from a[mask] = values.
///
///
/// Boolean mask array.
/// It has to be the same shape as a.
///
///
/// Values to put into a where mask is True.
/// If values is smaller
/// than a it will be repeated.
///
public void putmask(NDarray mask, NDarray values)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
mask,
values,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("putmask", pyargs, kwargs);
}
///
/// Fill the main diagonal of the given array of any dimensionality.
///
/// For an array a with a.ndim >= 2, the diagonal is the list of
/// locations with indices a[i, ..., i] all identical.
/// This function
/// modifies the input array in-place, it does not return a value.
///
/// Notes
///
/// This functionality can be obtained via diag_indices, but internally
/// this version uses a much faster implementation that never constructs the
/// indices and uses simple slicing.
///
///
/// Value to be written on the diagonal, its type must be compatible with
/// that of the array a.
///
///
/// For tall matrices in NumPy version up to 1.6.2, the
/// diagonal “wrapped” after N columns.
/// You can have this behavior
/// with this option.
/// This affects only tall matrices.
///
public void fill_diagonal(ValueType val, bool wrap = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
val,
});
var kwargs=new PyDict();
if (wrap!=false) kwargs["wrap"]=ToPython(wrap);
dynamic py = __self__.InvokeMethod("fill_diagonal", pyargs, kwargs);
}
/*
///
/// Efficient multi-dimensional iterator object to iterate over arrays.
///
/// To get started using this object, see the
/// introductory guide to array iteration.
///
/// Notes
///
/// nditer supersedes flatiter.
/// The iterator implementation behind
/// nditer is also exposed by the NumPy C API.
///
/// The Python exposure supplies two iteration interfaces, one which follows
/// the Python iterator protocol, and another which mirrors the C-style
/// do-while pattern.
/// The native Python approach is better in most cases, but
/// if you need the iterator’s coordinates or index, use the C-style pattern.
///
///
/// Flags to control the behavior of the iterator.
///
///
/// This is a list of flags for each operand.
/// At minimum, one of
/// “readonly”, “readwrite”, or “writeonly” must be specified.
///
///
/// The required data type(s) of the operands.
/// If copying or buffering
/// is enabled, the data will be converted to/from their original types.
///
///
/// Controls the iteration order.
/// ‘C’ means C order, ‘F’ means
/// Fortran order, ‘A’ means ‘F’ order if all the arrays are Fortran
/// contiguous, ‘C’ order otherwise, and ‘K’ means as close to the
/// order the array elements appear in memory as possible.
/// This also
/// affects the element memory order of “allocate” operands, as they
/// are allocated to be compatible with iteration order.
///
/// Default is ‘K’.
///
///
/// Controls what kind of data casting may occur when making a copy
/// or buffering.
/// Setting this to ‘unsafe’ is not recommended,
/// as it can adversely affect accumulations.
///
///
/// If provided, is a list of ints or None for each operands.
///
/// The list of axes for an operand is a mapping from the dimensions
/// of the iterator to the dimensions of the operand.
/// A value of
/// -1 can be placed for entries, causing that dimension to be
/// treated as “newaxis”.
///
///
/// The desired shape of the iterator.
/// This allows “allocate” operands
/// with a dimension mapped by op_axes not corresponding to a dimension
/// of a different operand to get a value not equal to 1 for that
/// dimension.
///
///
/// When buffering is enabled, controls the size of the temporary
/// buffers.
/// Set to 0 for the default value.
///
public void nditer(string[] flags = null, list of list of str op_flags = null, dtype or tuple of dtype(s) op_dtypes = null, string order = null, string casting = null, list of list of ints op_axes = null, tuple of ints itershape = null, int? buffersize = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (flags!=null) kwargs["flags"]=ToPython(flags);
if (op_flags!=null) kwargs["op_flags"]=ToPython(op_flags);
if (op_dtypes!=null) kwargs["op_dtypes"]=ToPython(op_dtypes);
if (order!=null) kwargs["order"]=ToPython(order);
if (casting!=null) kwargs["casting"]=ToPython(casting);
if (op_axes!=null) kwargs["op_axes"]=ToPython(op_axes);
if (itershape!=null) kwargs["itershape"]=ToPython(itershape);
if (buffersize!=null) kwargs["buffersize"]=ToPython(buffersize);
dynamic py = __self__.InvokeMethod("nditer", pyargs, kwargs);
}
*/
///
/// Multidimensional index iterator.
///
/// Return an iterator yielding pairs of array coordinates and values.
///
public void ndenumerate()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("ndenumerate");
}
/*
///
/// Create nditers for use in nested loops
///
/// Create a tuple of nditer objects which iterate in nested loops over
/// different axes of the op argument.
/// The first iterator is used in the
/// outermost loop, the last in the innermost loop.
/// Advancing one will change
/// the subsequent iterators to point at its new element.
///
///
/// Each item is used as an “op_axes” argument to an nditer
///
///
/// An nditer for each item in axes, outermost first
///
public tuple of nditer nested_iters(params int[] axes)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axes!=null) kwargs["axes"]=ToPython(axes);
dynamic py = __self__.InvokeMethod("nested_iters", pyargs, kwargs);
return ToCsharp(py);
}
*/
/*
///
/// Return a string representation of an array.
///
/// Notes
///
/// If a formatter is specified for a certain type, the precision keyword is
/// ignored for that type.
///
/// This is a very flexible function; array_repr and array_str are using
/// array2string internally so keywords with the same name should work
/// identically in all three functions.
///
///
/// The maximum number of columns the string should span.
/// Newline
/// characters splits the string appropriately after array elements.
///
///
/// Floating point precision.
/// Default is the current printing
/// precision (usually 8), which can be altered using set_printoptions.
///
///
/// Represent very small numbers as zero.
/// A number is “very small” if it
/// is smaller than the current printing precision.
///
///
/// Inserted between elements.
///
///
/// The length of the prefix and suffix strings are used to respectively
/// align and wrap the output.
/// An array is typically printed as:
///
/// The output is left-padded by the length of the prefix string, and
/// wrapping is forced at the column max_line_width - len(suffix).
///
/// It should be noted that the content of prefix and suffix strings are
/// not included in the output.
///
///
/// If not None, the keys should indicate the type(s) that the respective
/// formatting function applies to.
/// Callables should return a string.
///
/// Types that are not specified (by their corresponding keys) are handled
/// by the default formatters.
/// Individual types for which a formatter
/// can be set are:
///
/// Other keys that can be used to set a group of types at once are:
///
///
/// Total number of array elements which trigger summarization
/// rather than full repr.
///
///
/// Number of array items in summary at beginning and end of
/// each dimension.
///
///
/// Controls printing of the sign of floating-point types.
/// If ‘+’, always
/// print the sign of positive values.
/// If ‘ ‘, always prints a space
/// (whitespace character) in the sign position of positive values.
/// If
/// ‘-‘, omit the sign character of positive values.
///
///
/// Controls the interpretation of the precision option for
/// floating-point types.
/// Can take the following values:
///
///
/// If set to the string ‘1.13’ enables 1.13 legacy printing mode.
/// This
/// approximates numpy 1.13 print output by including a space in the sign
/// position of floats and different behavior for 0d arrays.
/// If set to
/// False, disables legacy mode.
/// Unrecognized strings will be ignored
/// with a warning for forward compatibility.
///
///
/// String representation of the array.
///
public string array2string(int? max_line_width = null, int? precision = null, bool? suppress_small = null, string separator = " ", string prefix = "", string suffix = "", dict of callables formatter = null, int? threshold = null, int? edgeitems = null, string sign = null, string floatmode = null, string or False legacy = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (max_line_width!=null) kwargs["max_line_width"]=ToPython(max_line_width);
if (precision!=null) kwargs["precision"]=ToPython(precision);
if (suppress_small!=null) kwargs["suppress_small"]=ToPython(suppress_small);
if (separator!=" ") kwargs["separator"]=ToPython(separator);
if (prefix!="") kwargs["prefix"]=ToPython(prefix);
if (suffix!="") kwargs["suffix"]=ToPython(suffix);
if (formatter!=null) kwargs["formatter"]=ToPython(formatter);
if (threshold!=null) kwargs["threshold"]=ToPython(threshold);
if (edgeitems!=null) kwargs["edgeitems"]=ToPython(edgeitems);
if (sign!=null) kwargs["sign"]=ToPython(sign);
if (floatmode!=null) kwargs["floatmode"]=ToPython(floatmode);
if (legacy!=null) kwargs["legacy"]=ToPython(legacy);
dynamic py = __self__.InvokeMethod("array2string", pyargs, kwargs);
return ToCsharp(py);
}
*/
///
/// Return the string representation of an array.
///
///
/// The maximum number of columns the string should span.
/// Newline
/// characters split the string appropriately after array elements.
///
///
/// Floating point precision.
/// Default is the current printing precision
/// (usually 8), which can be altered using set_printoptions.
///
///
/// Represent very small numbers as zero, default is False.
/// Very small
/// is defined by precision, if the precision is 8 then
/// numbers smaller than 5e-9 are represented as zero.
///
///
/// The string representation of an array.
///
public string array_repr(int? max_line_width = null, int? precision = null, bool? suppress_small = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (max_line_width!=null) kwargs["max_line_width"]=ToPython(max_line_width);
if (precision!=null) kwargs["precision"]=ToPython(precision);
if (suppress_small!=null) kwargs["suppress_small"]=ToPython(suppress_small);
dynamic py = __self__.InvokeMethod("array_repr", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return a string representation of the data in an array.
///
/// The data in the array is returned as a single string.
/// This function is
/// similar to array_repr, the difference being that array_repr also
/// returns information on the kind of array and its data type.
///
///
/// Inserts newlines if text is longer than max_line_width.
/// The
/// default is, indirectly, 75.
///
///
/// Floating point precision.
/// Default is the current printing precision
/// (usually 8), which can be altered using set_printoptions.
///
///
/// Represent numbers “very close” to zero as zero; default is False.
///
/// Very close is defined by precision: if the precision is 8, e.g.,
/// numbers smaller (in absolute value) than 5e-9 are represented as
/// zero.
///
public void array_str(int? max_line_width = null, int? precision = null, bool? suppress_small = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (max_line_width!=null) kwargs["max_line_width"]=ToPython(max_line_width);
if (precision!=null) kwargs["precision"]=ToPython(precision);
if (suppress_small!=null) kwargs["suppress_small"]=ToPython(suppress_small);
dynamic py = __self__.InvokeMethod("array_str", pyargs, kwargs);
}
///
/// Dot product of two arrays.
/// Specifically,
///
///
/// Second argument.
///
///
/// Output argument.
/// This must have the exact kind that would be returned
/// if it was not used.
/// In particular, it must have the right type, must be
/// C-contiguous, and its dtype must be the dtype that would be returned
/// for dot(a,b).
/// This is a performance feature.
/// Therefore, if these
/// conditions are not met, an exception is raised, instead of attempting
/// to be flexible.
///
///
/// Returns the dot product of a and b.
/// If a and b are both
/// scalars or both 1-D arrays then a scalar is returned; otherwise
/// an array is returned.
///
/// If out is given, then it is returned.
///
public NDarray dot(NDarray b, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
b,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("dot", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the dot product of two vectors.
///
/// The vdot(a, b) function handles complex numbers differently than
/// dot(a, b).
/// If the first argument is complex the complex conjugate
/// of the first argument is used for the calculation of the dot product.
///
/// Note that vdot handles multidimensional arrays differently than dot:
/// it does not perform a matrix product, but flattens input arguments
/// to 1-D vectors first.
/// Consequently, it should only be used for vectors.
///
///
/// Second argument to the dot product.
///
///
/// Dot product of a and b.
/// Can be an int, float, or
/// complex depending on the types of a and b.
///
public NDarray vdot(NDarray b)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
b,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("vdot", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Inner product of two arrays.
///
/// Ordinary inner product of vectors for 1-D arrays (without complex
/// conjugation), in higher dimensions a sum product over the last axes.
///
/// Notes
///
/// For vectors (1-D arrays) it computes the ordinary inner-product:
///
/// More generally, if ndim(a) = r > 0 and ndim(b) = s > 0:
///
/// or explicitly:
///
/// In addition a or b may be scalars, in which case:
///
///
/// If a and b are nonscalar, their last dimensions must match.
///
///
/// out.shape = a.shape[:-1] + b.shape[:-1]
///
public NDarray inner(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("inner", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the outer product of two vectors.
///
/// Given two vectors, a = [a0, a1, ..., aM] and
/// b = [b0, b1, ..., bN],
/// the outer product [1] is:
///
/// References
///
///
/// Second input vector.
/// Input is flattened if
/// not already 1-dimensional.
///
///
/// A location where the result is stored
///
///
/// out[i, j] = a[i] * b[j]
///
public NDarray outer(NDarray b, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
b,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("outer", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Matrix product of two arrays.
///
/// Notes
///
/// The behavior depends on the arguments in the following way.
///
/// matmul differs from dot in two important ways:
///
/// The matmul function implements the semantics of the @ operator introduced
/// in Python 3.5 following PEP465.
///
///
/// Input arrays, scalars not allowed.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that matches the signature (n,k),(k,m)->(n,m).
/// If not
/// provided or None, a freshly-allocated array is returned.
///
///
/// The matrix product of the inputs.
///
/// This is a scalar only when both x1, x2 are 1-d vectors.
///
public NDarray matmul(NDarray x1, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("matmul", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute tensor dot product along specified axes for arrays >= 1-D.
///
/// Given two tensors (arrays of dimension greater than or equal to one),
/// a and b, and an array_like object containing two array_like
/// objects, (a_axes, b_axes), sum the products of a’s and b’s
/// elements (components) over the axes specified by a_axes and
/// b_axes.
/// The third argument can be a single non-negative
/// integer_like scalar, N; if it is such, then the last N
/// dimensions of a and the first N dimensions of b are summed
/// over.
///
/// Notes
///
/// When axes is integer_like, the sequence for evaluation will be: first
/// the -Nth axis in a and 0th axis in b, and the -1th axis in a and
/// Nth axis in b last.
///
/// When there is more than one axis to sum over - and they are not the last
/// (first) axes of a (b) - the argument axes should consist of
/// two sequences of the same length, with the first axis to sum over given
/// first in both sequences, the second axis second, and so forth.
///
///
/// Tensors to “dot”.
///
public NDarray tensordot(NDarray a, int[] axes = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a,
});
var kwargs=new PyDict();
if (axes!=null) kwargs["axes"]=ToPython(axes);
dynamic py = __self__.InvokeMethod("tensordot", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Kronecker product of two arrays.
///
/// Computes the Kronecker product, a composite array made of blocks of the
/// second array scaled by the first.
///
/// Notes
///
/// The function assumes that the number of dimensions of a and b
/// are the same, if necessary prepending the smallest with ones.
///
/// If a.shape = (r0,r1,..,rN) and b.shape = (s0,s1,…,sN),
/// the Kronecker product has shape (r0*s0, r1*s1, …, rN*SN).
///
/// The elements are products of elements from a and b, organized
/// explicitly by:
///
/// where:
///
/// In the common 2-D case (N=1), the block structure can be visualized:
///
public NDarray kron(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("kron", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the sum along diagonals of the array.
///
/// If a is 2-D, the sum along its diagonal with the given offset
/// is returned, i.e., the sum of elements a[i,i+offset] for all i.
///
/// If a has more than two dimensions, then the axes specified by axis1 and
/// axis2 are used to determine the 2-D sub-arrays whose traces are returned.
///
/// The shape of the resulting array is the same as that of a with axis1
/// and axis2 removed.
///
///
/// Offset of the diagonal from the main diagonal.
/// Can be both positive
/// and negative.
/// Defaults to 0.
///
///
/// Axes to be used as the first and second axis of the 2-D sub-arrays
/// from which the diagonals should be taken.
/// Defaults are the first two
/// axes of a.
///
///
/// Axes to be used as the first and second axis of the 2-D sub-arrays
/// from which the diagonals should be taken.
/// Defaults are the first two
/// axes of a.
///
///
/// Determines the data-type of the returned array and of the accumulator
/// where the elements are summed.
/// If dtype has the value None and a is
/// of integer type of precision less than the default integer
/// precision, then the default integer precision is used.
/// Otherwise,
/// the precision is the same as that of a.
///
///
/// Array into which the output is placed.
/// Its type is preserved and
/// it must be of the right shape to hold the output.
///
///
/// If a is 2-D, the sum along the diagonal is returned.
/// If a has
/// larger dimensions, then an array of sums along diagonals is returned.
///
public NDarray trace(int? offset = 0, int? axis2 = null, int? axis1 = null, Dtype dtype = null, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (offset!=0) kwargs["offset"]=ToPython(offset);
if (axis2!=null) kwargs["axis2"]=ToPython(axis2);
if (axis1!=null) kwargs["axis1"]=ToPython(axis1);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("trace", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test whether all array elements along a given axis evaluate to True.
///
/// Notes
///
/// Not a Number (NaN), positive infinity and negative infinity
/// evaluate to True because these are not equal to zero.
///
///
/// Axis or axes along which a logical AND reduction is performed.
///
/// The default (axis = None) is to perform a logical AND over all
/// the dimensions of the input array.
/// axis may be negative, in
/// which case it counts from the last to the first axis.
///
/// 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.
///
///
/// Alternate output array in which to place the result.
///
/// It must have the same shape as the expected output and its
/// type is preserved (e.g., if dtype(out) is float, the result
/// will consist of 0.0’s and 1.0’s).
/// See doc.ufuncs (Section
/// “Output arguments”) for more details.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the input array.
///
/// If the default value is passed, then keepdims will not be
/// passed through to the all method of sub-classes of
/// ndarray, however any non-default value will be.
/// If the
/// sub-class’ method does not implement keepdims any
/// exceptions will be raised.
///
///
/// A new boolean or array is returned unless out is specified,
/// in which case a reference to out is returned.
///
public NDarray all(Axis axis, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
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("all", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Test whether all array elements along a given axis evaluate to True.
///
/// Notes
///
/// Not a Number (NaN), positive infinity and negative infinity
/// evaluate to True because these are not equal to zero.
///
///
/// A new boolean or array is returned unless out is specified,
/// in which case a reference to out is returned.
///
public bool all()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("all");
return ToCsharp(py);
}
///
/// Test whether any array element along a given axis evaluates to True.
///
/// Returns single boolean unless axis is not None
///
/// Notes
///
/// Not a Number (NaN), positive infinity and negative infinity evaluate
/// to True because these are not equal to zero.
///
///
/// Axis or axes along which a logical OR reduction is performed.
///
/// The default (axis = None) is to perform a logical OR over all
/// the dimensions of the input array.
/// axis may be negative, in
/// which case it counts from the last to the first axis.
///
/// 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.
///
///
/// Alternate output array in which to place the result.
/// It must have
/// the same shape as the expected output and its type is preserved
/// (e.g., if it is of type float, then it will remain so, returning
/// 1.0 for True and 0.0 for False, regardless of the type of a).
///
/// See doc.ufuncs (Section “Output arguments”) for details.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the input array.
///
/// If the default value is passed, then keepdims will not be
/// passed through to the any method of sub-classes of
/// ndarray, however any non-default value will be.
/// If the
/// sub-class’ method does not implement keepdims any
/// exceptions will be raised.
///
///
/// A new boolean or ndarray is returned unless out is specified,
/// in which case a reference to out is returned.
///
public NDarray any(Axis axis, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
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("any", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Test whether any array element along a given axis evaluates to True.
///
/// Returns single boolean unless axis is not None
///
/// Notes
///
/// Not a Number (NaN), positive infinity and negative infinity evaluate
/// to True because these are not equal to zero.
///
///
/// A new boolean or ndarray is returned unless out is specified,
/// in which case a reference to out is returned.
///
public bool any()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("any");
return ToCsharp(py);
}
///
/// Test element-wise for finiteness (not infinity or not Not a Number).
///
/// The result is returned as a boolean array.
///
/// Notes
///
/// Not a Number, positive infinity and negative infinity are considered
/// to be non-finite.
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
/// This means that Not a Number is not equivalent to infinity.
///
/// Also that positive infinity is not equivalent to negative infinity.
/// But
/// infinity is equivalent to positive infinity.
/// Errors result if the
/// second argument is also supplied when x is a scalar input, or if
/// first and second arguments have different shapes.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// True where x is not positive infinity, negative infinity,
/// or NaN; false otherwise.
///
/// This is a scalar if x is a scalar.
///
public NDarray isfinite(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("isfinite", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test element-wise for positive or negative infinity.
///
/// Returns a boolean array of the same shape as x, True where x ==
/// +/-inf, otherwise False.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
///
/// Errors result if the second argument is supplied when the first
/// argument is a scalar, or if the first and second arguments have
/// different shapes.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// True where x is positive or negative infinity, false otherwise.
///
/// This is a scalar if x is a scalar.
///
public NDarray isinf(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("isinf", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Test element-wise for NaN and return result as a boolean array.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
/// This means that Not a Number is not equivalent to infinity.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// True where x is NaN, false otherwise.
///
/// This is a scalar if x is a scalar.
///
public NDarray isnan(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("isnan", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test element-wise for NaT (not a time) and return result as a boolean array.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// True where x is NaT, false otherwise.
///
/// This is a scalar if x is a scalar.
///
public NDarray isnat(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("isnat", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test element-wise for negative infinity, return result as bool array.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
///
/// Errors result if the second argument is also supplied when x is a scalar
/// input, if first and second arguments have different shapes, or if the
/// first argument has complex values.
///
///
/// A boolean array with the same shape and type as x to store the
/// result.
///
///
/// A boolean array with the same dimensions as the input.
///
/// If second argument is not supplied then a numpy boolean array is
/// returned with values True where the corresponding element of the
/// input is negative infinity and values False where the element of
/// the input is not negative infinity.
///
/// If a second argument is supplied the result is stored there.
/// If the
/// type of that array is a numeric type the result is represented as
/// zeros and ones, if the type is boolean then as False and True.
/// The
/// return value out is then a reference to that array.
///
public NDarray isneginf(NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("isneginf", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test element-wise for positive infinity, return result as bool array.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
///
/// Errors result if the second argument is also supplied when x is a scalar
/// input, if first and second arguments have different shapes, or if the
/// first argument has complex values
///
///
/// A boolean array with the same shape as x to store the result.
///
///
/// A boolean array with the same dimensions as the input.
///
/// If second argument is not supplied then a boolean array is returned
/// with values True where the corresponding element of the input is
/// positive infinity and values False where the element of the input is
/// not positive infinity.
///
/// If a second argument is supplied the result is stored there.
/// If the
/// type of that array is a numeric type the result is represented as zeros
/// and ones, if the type is boolean then as False and True.
///
/// The return value out is then a reference to that array.
///
public NDarray isposinf(NDarray y = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (y!=null) kwargs["y"]=ToPython(y);
dynamic py = __self__.InvokeMethod("isposinf", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns a bool array, where True if input element is complex.
///
/// What is tested is whether the input has a non-zero imaginary part, not if
/// the input type is complex.
///
///
/// Output array.
///
public NDarray iscomplex()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("iscomplex");
return ToCsharp(py);
}
///
/// Returns True if the array is Fortran contiguous but not C contiguous.
///
/// This function is obsolete and, because of changes due to relaxed stride
/// checking, its return value for the same array may differ for versions
/// of NumPy >= 1.10.0 and previous versions.
/// If you only want to check if an
/// array is Fortran contiguous use a.flags.f_contiguous instead.
///
public bool isfortran()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("isfortran");
return ToCsharp(py);
}
///
/// Returns a bool array, where True if input element is real.
///
/// If element has complex type with zero complex part, the return value
/// for that element is True.
///
///
/// Boolean array of same shape as x.
///
public NDarray isreal()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("isreal");
return ToCsharp(py);
}
///
/// Compute the truth value of x1 AND x2 element-wise.
///
///
/// Input arrays.
/// x1 and x2 must be of the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Boolean result with the same shape as x1 and x2 of the logical
/// AND operation on corresponding elements of x1 and x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray logical_and(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logical_and", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the truth value of x1 OR x2 element-wise.
///
///
/// Logical OR is applied to the elements of x1 and x2.
/// They have to be of the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Boolean result with the same shape as x1 and x2 of the logical
/// OR operation on elements of x1 and x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray logical_or(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logical_or", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the truth value of NOT x element-wise.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Boolean result with the same shape as x of the NOT operation
/// on elements of x.
///
/// This is a scalar if x is a scalar.
///
public NDarray logical_not(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logical_not", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Compute the truth value of x1 XOR x2, element-wise.
///
///
/// Logical XOR is applied to the elements of x1 and x2. They must
/// be broadcastable to the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Boolean result of the logical XOR operation applied to the elements
/// of x1 and x2; the shape is determined by whether or not
/// broadcasting of one or both arrays was required.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray logical_xor(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logical_xor", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Returns True if two arrays are element-wise equal within a tolerance.
///
/// The tolerance values are positive, typically very small numbers.
/// The
/// relative difference (rtol * abs(b)) and the absolute difference
/// atol are added together to compare against the absolute difference
/// between a and b.
///
/// If either array contains one or more NaNs, False is returned.
///
/// Infs are treated as equal if they are in the same place and of the same
/// sign in both arrays.
///
/// Notes
///
/// If the following equation is element-wise True, then allclose returns
/// True.
///
/// The above equation is not symmetric in a and b, so that
/// allclose(a, b) might be different from allclose(b, a) in
/// some rare cases.
///
/// The comparison of a and b uses standard broadcasting, which
/// means that a and b need not have the same shape in order for
/// allclose(a, b) to evaluate to True.
/// The same is true for
/// equal but not array_equal.
///
///
/// Input arrays to compare.
///
///
/// The relative tolerance parameter (see Notes).
///
///
/// The absolute tolerance parameter (see Notes).
///
///
/// Whether to compare NaN’s as equal.
/// If True, NaN’s in a will be
/// considered equal to NaN’s in b in the output array.
///
///
/// Returns True if the two arrays are equal within the given
/// tolerance; False otherwise.
///
public bool allclose(NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a,
});
var kwargs=new PyDict();
if (rtol!=1e-05f) kwargs["rtol"]=ToPython(rtol);
if (atol!=1e-08f) kwargs["atol"]=ToPython(atol);
if (equal_nan!=false) kwargs["equal_nan"]=ToPython(equal_nan);
dynamic py = __self__.InvokeMethod("allclose", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns a boolean array where two arrays are element-wise equal within a
/// tolerance.
///
/// The tolerance values are positive, typically very small numbers.
/// The
/// relative difference (rtol * abs(b)) and the absolute difference
/// atol are added together to compare against the absolute difference
/// between a and b.
///
/// Notes
///
/// For finite values, isclose uses the following equation to test whether
/// two floating point values are equivalent.
///
/// Unlike the built-in math.isclose, the above equation is not symmetric
/// in a and b – it assumes b is the reference value – so that
/// isclose(a, b) might be different from isclose(b, a).
/// Furthermore,
/// the default value of atol is not zero, and is used to determine what
/// small values should be considered close to zero.
/// The default value is
/// appropriate for expected values of order unity: if the expected values
/// are significantly smaller than one, it can result in false positives.
///
/// atol should be carefully selected for the use case at hand.
/// A zero value
/// for atol will result in False if either a or b is zero.
///
///
/// Input arrays to compare.
///
///
/// The relative tolerance parameter (see Notes).
///
///
/// The absolute tolerance parameter (see Notes).
///
///
/// Whether to compare NaN’s as equal.
/// If True, NaN’s in a will be
/// considered equal to NaN’s in b in the output array.
///
///
/// Returns a boolean array of where a and b are equal within the
/// given tolerance.
/// If both a and b are scalars, returns a single
/// boolean value.
///
public NDarray isclose(NDarray a, float rtol = 1e-05f, float atol = 1e-08f, bool equal_nan = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a,
});
var kwargs=new PyDict();
if (rtol!=1e-05f) kwargs["rtol"]=ToPython(rtol);
if (atol!=1e-08f) kwargs["atol"]=ToPython(atol);
if (equal_nan!=false) kwargs["equal_nan"]=ToPython(equal_nan);
dynamic py = __self__.InvokeMethod("isclose", pyargs, kwargs);
return ToCsharp(py);
}
///
/// True if two arrays have the same shape and elements, False otherwise.
///
///
/// Input arrays.
///
///
/// Returns True if the arrays are equal.
///
public bool array_equal(NDarray a1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a1,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("array_equal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns True if input arrays are shape consistent and all elements equal.
///
/// Shape consistent means they are either the same shape, or one input array
/// can be broadcasted to create the same shape as the other one.
///
///
/// Input arrays.
///
///
/// True if equivalent, False otherwise.
///
public bool array_equiv(NDarray a1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a1,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("array_equiv", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the truth value of (x1 > x2) element-wise.
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray greater(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("greater", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the truth value of (x1 >= x2) element-wise.
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray greater_equal(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("greater_equal", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Return the truth value of (x1 < x2) element-wise.
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray less(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("less", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the truth value of (x1 =< x2) element-wise.
///
///
/// Input arrays.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray less_equal(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("less_equal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return (x1 == x2) element-wise.
///
///
/// Input arrays of the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray equal(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("equal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return (x1 != x2) element-wise.
///
///
/// Input arrays.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise comparison of x1 and x2.
/// Typically of type bool, unless dtype=object is passed.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray not_equal(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("not_equal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Trigonometric sine, element-wise.
///
/// Notes
///
/// The sine is one of the fundamental functions of trigonometry (the
/// mathematical study of triangles).
/// Consider a circle of radius 1
/// centered on the origin.
/// A ray comes in from the axis, makes
/// an angle at the origin (measured counter-clockwise from that axis), and
/// departs from the origin.
/// The coordinate of the outgoing
/// ray’s intersection with the unit circle is the sine of that angle.
/// It
/// ranges from -1 for to +1 for The
/// function has zeroes where the angle is a multiple of .
/// Sines of angles between and are negative.
///
/// The numerous properties of the sine and related functions are included
/// in any standard trigonometry text.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The sine of each element of x.
///
/// This is a scalar if x is a scalar.
///
public NDarray sin(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("sin", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Cosine element-wise.
///
/// Notes
///
/// If out is provided, the function writes the result into it,
/// and returns a reference to out.
/// (See Examples)
///
/// References
///
/// M.
/// Abramowitz and I.
/// A.
/// Stegun, Handbook of Mathematical Functions.
///
/// New York, NY: Dover, 1972.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The corresponding cosine values.
///
/// This is a scalar if x is a scalar.
///
public NDarray cos(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("cos", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute tangent element-wise.
///
/// Equivalent to np.sin(x)/np.cos(x) element-wise.
///
/// Notes
///
/// If out is provided, the function writes the result into it,
/// and returns a reference to out.
/// (See Examples)
///
/// References
///
/// M.
/// Abramowitz and I.
/// A.
/// Stegun, Handbook of Mathematical Functions.
///
/// New York, NY: Dover, 1972.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The corresponding tangent values.
///
/// This is a scalar if x is a scalar.
///
public NDarray tan(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("tan", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Inverse sine, element-wise.
///
/// Notes
///
/// arcsin is a multivalued function: for each x there are infinitely
/// many numbers z such that . The convention is to
/// return the angle z whose real part lies in [-pi/2, pi/2].
///
/// For real-valued input data types, arcsin always returns real output.
///
/// For each value that cannot be expressed as a real number or infinity,
/// it yields nan and sets the invalid floating point error flag.
///
/// For complex-valued input, arcsin is a complex analytic function that
/// has, by convention, the branch cuts [-inf, -1] and [1, inf] and is
/// continuous from above on the former and from below on the latter.
///
/// The inverse sine is also known as asin or sin^{-1}.
///
/// References
///
/// Abramowitz, M.
/// and Stegun, I.
/// A., Handbook of Mathematical Functions,
/// 10th printing, New York: Dover, 1964, pp.
/// 79ff.
///
/// http://www.math.sfu.ca/~cbm/aands/
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The inverse sine of each element in x, in radians and in the
/// closed interval [-pi/2, pi/2].
///
/// This is a scalar if x is a scalar.
///
public NDarray arcsin(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("arcsin", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Trigonometric inverse cosine, element-wise.
///
/// The inverse of cos so that, if y = cos(x), then x = arccos(y).
///
/// Notes
///
/// arccos is a multivalued function: for each x there are infinitely
/// many numbers z such that cos(z) = x.
/// The convention is to return
/// the angle z whose real part lies in [0, pi].
///
/// For real-valued input data types, arccos always returns real output.
///
/// For each value that cannot be expressed as a real number or infinity,
/// it yields nan and sets the invalid floating point error flag.
///
/// For complex-valued input, arccos is a complex analytic function that
/// has branch cuts [-inf, -1] and [1, inf] and is continuous from
/// above on the former and from below on the latter.
///
/// The inverse cos is also known as acos or cos^-1.
///
/// References
///
/// M.
/// Abramowitz and I.A.
/// Stegun, “Handbook of Mathematical Functions”,
/// 10th printing, 1964, pp.
/// 79. http://www.math.sfu.ca/~cbm/aands/
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The angle of the ray intersecting the unit circle at the given
/// x-coordinate in radians [0, pi].
///
/// This is a scalar if x is a scalar.
///
public NDarray arccos(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("arccos", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Trigonometric inverse tangent, element-wise.
///
/// The inverse of tan, so that if y = tan(x) then x = arctan(y).
///
/// Notes
///
/// arctan is a multi-valued function: for each x there are infinitely
/// many numbers z such that tan(z) = x.
/// The convention is to return
/// the angle z whose real part lies in [-pi/2, pi/2].
///
/// For real-valued input data types, arctan always returns real output.
///
/// For each value that cannot be expressed as a real number or infinity,
/// it yields nan and sets the invalid floating point error flag.
///
/// For complex-valued input, arctan is a complex analytic function that
/// has [1j, infj] and [-1j, -infj] as branch cuts, and is continuous
/// from the left on the former and from the right on the latter.
///
/// The inverse tangent is also known as atan or tan^{-1}.
///
/// References
///
/// Abramowitz, M.
/// and Stegun, I.
/// A., Handbook of Mathematical Functions,
/// 10th printing, New York: Dover, 1964, pp.
/// 79.
/// http://www.math.sfu.ca/~cbm/aands/
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Out has the same shape as x.
/// Its real part is in
/// [-pi/2, pi/2] (arctan(+/-inf) returns +/-pi/2).
///
/// This is a scalar if x is a scalar.
///
public NDarray arctan(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("arctan", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Given the “legs” of a right triangle, return its hypotenuse.
///
/// Equivalent to sqrt(x1**2 + x2**2), element-wise.
/// If x1 or
/// x2 is scalar_like (i.e., unambiguously cast-able to a scalar type),
/// it is broadcast for use with each element of the other argument.
///
/// (See Examples)
///
///
/// Leg of the triangle(s).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The hypotenuse of the triangle(s).
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray hypot(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("hypot", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Element-wise arc tangent of x1/x2 choosing the quadrant correctly.
///
/// The quadrant (i.e., branch) is chosen so that arctan2(x1, x2) is
/// the signed angle in radians between the ray ending at the origin and
/// passing through the point (1,0), and the ray ending at the origin and
/// passing through the point (x2, x1).
/// (Note the role reversal: the
/// “y-coordinate” is the first function parameter, the “x-coordinate”
/// is the second.) By IEEE convention, this function is defined for
/// x2 = +/-0 and for either or both of x1 and x2 = +/-inf (see
/// Notes for specific values).
///
/// This function is not defined for complex-valued arguments; for the
/// so-called argument of complex values, use angle.
///
/// Notes
///
/// arctan2 is identical to the atan2 function of the underlying
/// C library.
/// The following special values are defined in the C
/// standard: [1]
///
/// Note that +0 and -0 are distinct floating point numbers, as are +inf
/// and -inf.
///
/// References
///
///
/// x-coordinates.
/// x2 must be broadcastable to match the shape of
/// x1 or vice versa.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Array of angles in radians, in the range [-pi, pi].
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray arctan2(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("arctan2", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Convert angles from radians to degrees.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The corresponding degree values; if out was supplied this is a
/// reference to it.
///
/// This is a scalar if x is a scalar.
///
public NDarray degrees(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("degrees", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Convert angles from degrees to radians.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The corresponding radian values.
///
/// This is a scalar if x is a scalar.
///
public NDarray radians(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("radians", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Unwrap by changing deltas between values to 2*pi complement.
///
/// Unwrap radian phase p by changing absolute jumps greater than
/// discont to their 2*pi complement along the given axis.
///
/// Notes
///
/// If the discontinuity in p is smaller than pi, but larger than
/// discont, no unwrapping is done because taking the 2*pi complement
/// would only make the discontinuity larger.
///
///
/// Maximum discontinuity between values, default is pi.
///
///
/// Axis along which unwrap will operate, default is the last axis.
///
///
/// Output array.
///
public NDarray unwrap(float? discont = 3.141592653589793f, int? axis = -1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (discont!=3.141592653589793f) kwargs["discont"]=ToPython(discont);
if (axis!=-1) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("unwrap", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Convert angles from degrees to radians.
///
/// Notes
///
/// deg2rad(x) is x * pi / 180.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The corresponding angle in radians.
///
/// This is a scalar if x is a scalar.
///
public NDarray deg2rad(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("deg2rad", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Convert angles from radians to degrees.
///
/// Notes
///
/// rad2deg(x) is 180 * x / pi.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The corresponding angle in degrees.
///
/// This is a scalar if x is a scalar.
///
public NDarray rad2deg(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("rad2deg", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Hyperbolic sine, element-wise.
///
/// Equivalent to 1/2 * (np.exp(x) - np.exp(-x)) or
/// -1j * np.sin(1j*x).
///
/// Notes
///
/// If out is provided, the function writes the result into it,
/// and returns a reference to out.
/// (See Examples)
///
/// References
///
/// M.
/// Abramowitz and I.
/// A.
/// Stegun, Handbook of Mathematical Functions.
///
/// New York, NY: Dover, 1972, pg.
/// 83.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The corresponding hyperbolic sine values.
///
/// This is a scalar if x is a scalar.
///
public NDarray sinh(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("sinh", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Hyperbolic cosine, element-wise.
///
/// Equivalent to 1/2 * (np.exp(x) + np.exp(-x)) and np.cos(1j*x).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array of same shape as x.
///
/// This is a scalar if x is a scalar.
///
public NDarray cosh(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("cosh", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute hyperbolic tangent element-wise.
///
/// Equivalent to np.sinh(x)/np.cosh(x) or -1j * np.tan(1j*x).
///
/// Notes
///
/// If out is provided, the function writes the result into it,
/// and returns a reference to out.
/// (See Examples)
///
/// References
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The corresponding hyperbolic tangent values.
///
/// This is a scalar if x is a scalar.
///
public NDarray tanh(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("tanh", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Inverse hyperbolic sine element-wise.
///
/// Notes
///
/// arcsinh is a multivalued function: for each x there are infinitely
/// many numbers z such that sinh(z) = x.
/// The convention is to return the
/// z whose imaginary part lies in [-pi/2, pi/2].
///
/// For real-valued input data types, arcsinh always returns real output.
///
/// For each value that cannot be expressed as a real number or infinity, it
/// returns nan and sets the invalid floating point error flag.
///
/// For complex-valued input, arccos is a complex analytical function that
/// has branch cuts [1j, infj] and [-1j, -infj] and is continuous from
/// the right on the former and from the left on the latter.
///
/// The inverse hyperbolic sine is also known as asinh or sinh^-1.
///
/// References
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Array of the same shape as x.
///
/// This is a scalar if x is a scalar.
///
public NDarray arcsinh(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("arcsinh", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Inverse hyperbolic cosine, element-wise.
///
/// Notes
///
/// arccosh is a multivalued function: for each x there are infinitely
/// many numbers z such that cosh(z) = x.
/// The convention is to return the
/// z whose imaginary part lies in [-pi, pi] and the real part in
/// [0, inf].
///
/// For real-valued input data types, arccosh always returns real output.
///
/// For each value that cannot be expressed as a real number or infinity, it
/// yields nan and sets the invalid floating point error flag.
///
/// For complex-valued input, arccosh is a complex analytical function that
/// has a branch cut [-inf, 1] and is continuous from above on it.
///
/// References
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Array of the same shape as x.
///
/// This is a scalar if x is a scalar.
///
public NDarray arccosh(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("arccosh", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Inverse hyperbolic tangent element-wise.
///
/// Notes
///
/// arctanh is a multivalued function: for each x there are infinitely
/// many numbers z such that tanh(z) = x.
/// The convention is to return
/// the z whose imaginary part lies in [-pi/2, pi/2].
///
/// For real-valued input data types, arctanh always returns real output.
///
/// For each value that cannot be expressed as a real number or infinity,
/// it yields nan and sets the invalid floating point error flag.
///
/// For complex-valued input, arctanh is a complex analytical function
/// that has branch cuts [-1, -inf] and [1, inf] and is continuous from
/// above on the former and from below on the latter.
///
/// The inverse hyperbolic tangent is also known as atanh or tanh^-1.
///
/// References
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Array of the same shape as x.
///
/// This is a scalar if x is a scalar.
///
public NDarray arctanh(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("arctanh", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Evenly round to the given number of decimals.
///
/// Notes
///
/// For values exactly halfway between rounded decimal values, NumPy
/// rounds to the nearest even value.
/// Thus 1.5 and 2.5 round to 2.0,
/// -0.5 and 0.5 round to 0.0, etc.
/// Results may also be surprising due
/// to the inexact representation of decimal fractions in the IEEE
/// floating point standard [1] and errors introduced when scaling
/// by powers of ten.
///
/// References
///
///
/// Number of decimal places to round to (default: 0).
/// If
/// decimals is negative, it specifies the number of positions to
/// the left of the decimal point.
///
///
/// Alternative output array in which to place the result.
/// It must have
/// the same shape as the expected output, but the type of the output
/// values will be cast if necessary.
/// See doc.ufuncs (Section
/// “Output arguments”) for details.
///
///
/// An array of the same type as a, containing the rounded values.
///
/// Unless out was specified, a new array is created.
/// A reference to
/// the result is returned.
///
/// The real and imaginary parts of complex numbers are rounded
/// separately.
/// The result of rounding a float is a float.
///
public NDarray around(int? decimals = 0, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (decimals!=0) kwargs["decimals"]=ToPython(decimals);
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("around", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Round elements of the array to the nearest integer.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array is same shape and type as x.
///
/// This is a scalar if x is a scalar.
///
public NDarray rint(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("rint", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Round to nearest integer towards zero.
///
/// Round an array of floats element-wise to nearest integer towards zero.
///
/// The rounded values are returned as floats.
///
///
/// Output array
///
///
/// The array of rounded numbers
///
public NDarray fix(NDarray y = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (y!=null) kwargs["y"]=ToPython(y);
dynamic py = __self__.InvokeMethod("fix", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the floor of the input, element-wise.
///
/// The floor of the scalar x is the largest integer i, such that
/// i <= x.
/// It is often denoted as .
///
/// Notes
///
/// Some spreadsheet programs calculate the “floor-towards-zero”, in other
/// words floor(-2.5) == -2. NumPy instead uses the definition of
/// floor where floor(-2.5) == -3.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The floor of each element in x.
///
/// This is a scalar if x is a scalar.
///
public NDarray floor(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("floor", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the ceiling of the input, element-wise.
///
/// The ceil of the scalar x is the smallest integer i, such that
/// i >= x.
/// It is often denoted as .
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The ceiling of each element in x, with float dtype.
///
/// This is a scalar if x is a scalar.
///
public NDarray ceil(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("ceil", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the truncated value of the input, element-wise.
///
/// The truncated value of the scalar x is the nearest integer i which
/// is closer to zero than x is.
/// In short, the fractional part of the
/// signed number x is discarded.
///
/// Notes
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The truncated value of each element in x.
///
/// This is a scalar if x is a scalar.
///
public NDarray trunc(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("trunc", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the product of array elements over a given axis.
///
/// Notes
///
/// Arithmetic is modular when using integer types, and no error is
/// raised on overflow.
/// That means that, on a 32-bit platform:
///
/// The product of an empty array is the neutral element 1:
///
///
/// Axis or axes along which a product is performed.
/// The default,
/// axis=None, will calculate the product of all the elements in the
/// input array.
/// If axis is negative it counts from the last to the
/// first axis.
///
/// If axis is a tuple of ints, a product is performed on all of the
/// axes specified in the tuple instead of a single axis or all the
/// axes as before.
///
///
/// The type of the returned array, as well as of the accumulator in
/// which the elements are multiplied.
/// The dtype of a is used by
/// default unless a has an integer dtype of less precision than the
/// default platform integer.
/// In that case, if a is signed then the
/// platform integer is used while if a is unsigned then an unsigned
/// integer of the same precision as the platform integer is used.
///
///
/// Alternative output array in which to place the result.
/// It must have
/// the same shape as the expected output, but the type of the output
/// values will be cast if necessary.
///
///
/// If this is set to True, the axes which are reduced are left in the
/// result as dimensions with size one.
/// With this option, the result
/// will broadcast correctly against the input array.
///
/// If the default value is passed, then keepdims will not be
/// passed through to the prod method of sub-classes of
/// ndarray, however any non-default value will be.
/// If the
/// sub-class’ method does not implement keepdims any
/// exceptions will be raised.
///
///
/// The starting value for this product.
/// See reduce for details.
///
///
/// An array shaped as a but with the specified axis removed.
///
/// Returns a reference to out if specified.
///
public NDarray prod(Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
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("prod", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Sum of array elements over a given axis.
///
/// Notes
///
/// Arithmetic is modular when using integer types, and no error is
/// raised on overflow.
///
/// The sum of an empty array is the neutral element 0:
///
///
/// Axis or axes along which a sum is performed.
/// The default,
/// axis=None, will sum all of the elements of the input array.
/// If
/// axis is negative it counts from the last to the first axis.
///
/// If axis is a tuple of ints, a sum is performed on all of the axes
/// specified in the tuple instead of a single axis or all the axes as
/// before.
///
///
/// The type of the returned array and of the accumulator in which the
/// elements are summed.
/// The dtype of a is used by default unless a
/// has an integer dtype of less precision than the default platform
/// integer.
/// In that case, if a is signed then the platform integer
/// is used while if a is unsigned then an unsigned integer of the
/// same precision as the platform integer is used.
///
///
/// Alternative output array in which to place the result.
/// It must have
/// the same shape as the expected output, but the type of the output
/// values will be cast if necessary.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the input array.
///
/// If the default value is passed, then keepdims will not be
/// passed through to the sum method of sub-classes of
/// ndarray, however any non-default value will be.
/// If the
/// sub-class’ method does not implement keepdims any
/// exceptions will be raised.
///
///
/// Starting value for the sum.
/// See reduce for details.
///
///
/// An array with the same shape as a, with the specified
/// axis removed.
/// If a is a 0-d array, or if axis is None, a scalar
/// is returned.
/// If an output array is specified, a reference to
/// out is returned.
///
public NDarray sum(Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null, ValueType initial = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
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("sum", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the product of array elements over a given axis treating Not a
/// Numbers (NaNs) as ones.
///
/// One is returned for slices that are all-NaN or empty.
///
///
/// Axis or axes along which the product is computed.
/// The default is to compute
/// the product of the flattened array.
///
///
/// The type of the returned array and of the accumulator in which the
/// elements are summed.
/// By default, the dtype of a is used.
/// An
/// exception is when a has an integer type with less precision than
/// the platform (u)intp.
/// In that case, the default will be either
/// (u)int32 or (u)int64 depending on whether the platform is 32 or 64
/// bits.
/// For inexact inputs, dtype must be inexact.
///
///
/// Alternate output array in which to place the result.
/// The default
/// is None.
/// If provided, it must have the same shape as the
/// expected output, but the type will be cast if necessary.
/// See
/// doc.ufuncs for details.
/// The casting of NaN to integer can yield
/// unexpected results.
///
///
/// If True, the axes which are reduced are left in the result as
/// dimensions with size one.
/// With this option, the result will
/// broadcast correctly against the original arr.
///
///
/// A new array holding the result is returned unless out is
/// specified, in which case it is returned.
///
public NDarray nanprod(Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
if (@out!=null) kwargs["out"]=ToPython(@out);
if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);
dynamic py = __self__.InvokeMethod("nanprod", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the sum of array elements over a given axis treating Not a
/// Numbers (NaNs) as zero.
///
/// In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or
/// empty.
/// In later versions zero is returned.
///
/// Notes
///
/// If both positive and negative infinity are present, the sum will be Not
/// A Number (NaN).
///
///
/// Axis or axes along which the sum is computed.
/// The default is to compute the
/// sum of the flattened array.
///
///
/// The type of the returned array and of the accumulator in which the
/// elements are summed.
/// By default, the dtype of a is used.
/// An
/// exception is when a has an integer type with less precision than
/// the platform (u)intp.
/// In that case, the default will be either
/// (u)int32 or (u)int64 depending on whether the platform is 32 or 64
/// bits.
/// For inexact inputs, dtype must be inexact.
///
///
/// Alternate output array in which to place the result.
/// The default
/// is None.
/// If provided, it must have the same shape as the
/// expected output, but the type will be cast if necessary.
/// See
/// doc.ufuncs for details.
/// The casting of NaN to integer can yield
/// unexpected results.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the original a.
///
/// If the value is anything but the default, then
/// keepdims will be passed through to the mean or sum methods
/// of sub-classes of ndarray.
/// If the sub-classes methods
/// does not implement keepdims any exceptions will be raised.
///
///
/// A new array holding the result is returned unless out is
/// specified, in which it is returned.
/// The result has the same
/// size as a, and the same shape as a if axis is not None
/// or a is a 1-d array.
///
public NDarray nansum(Axis axis = null, Dtype dtype = null, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
if (@out!=null) kwargs["out"]=ToPython(@out);
if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);
dynamic py = __self__.InvokeMethod("nansum", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the cumulative product of elements along a given axis.
///
/// Notes
///
/// Arithmetic is modular when using integer types, and no error is
/// raised on overflow.
///
///
/// Axis along which the cumulative product is computed.
/// By default
/// the input is flattened.
///
///
/// Type of the returned array, as well as of the accumulator in which
/// the elements are multiplied.
/// If dtype is not specified, it
/// defaults to the dtype of a, unless a has an integer dtype with
/// a precision less than that of the default platform integer.
/// In
/// that case, the default platform integer is used instead.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output
/// but the type of the resulting values will be cast if necessary.
///
///
/// A new array holding the result is returned unless out is
/// specified, in which case a reference to out is returned.
///
public NDarray cumprod(int? axis = null, Dtype dtype = null, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("cumprod", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the cumulative sum of the elements along a given axis.
///
/// Notes
///
/// Arithmetic is modular when using integer types, and no error is
/// raised on overflow.
///
///
/// Axis along which the cumulative sum is computed.
/// The default
/// (None) is to compute the cumsum over the flattened array.
///
///
/// Type of the returned array and of the accumulator in which the
/// elements are summed.
/// If dtype is not specified, it defaults
/// to the dtype of a, unless a has an integer dtype with a
/// precision less than that of the default platform integer.
/// In
/// that case, the default platform integer is used.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output
/// but the type will be cast if necessary.
/// See doc.ufuncs
/// (Section “Output arguments”) for more details.
///
///
/// A new array holding the result is returned unless out is
/// specified, in which case a reference to out is returned.
/// The
/// result has the same size as a, and the same shape as a if
/// axis is not None or a is a 1-d array.
///
public NDarray cumsum(int? axis = null, Dtype dtype = null, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("cumsum", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the cumulative product of array elements over a given axis treating Not a
/// Numbers (NaNs) as one.
/// The cumulative product does not change when NaNs are
/// encountered and leading NaNs are replaced by ones.
///
/// Ones are returned for slices that are all-NaN or empty.
///
///
/// Axis along which the cumulative product is computed.
/// By default
/// the input is flattened.
///
///
/// Type of the returned array, as well as of the accumulator in which
/// the elements are multiplied.
/// If dtype is not specified, it
/// defaults to the dtype of a, unless a has an integer dtype with
/// a precision less than that of the default platform integer.
/// In
/// that case, the default platform integer is used instead.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output
/// but the type of the resulting values will be cast if necessary.
///
///
/// A new array holding the result is returned unless out is
/// specified, in which case it is returned.
///
public NDarray nancumprod(int? axis = null, Dtype dtype = null, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("nancumprod", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the cumulative sum of array elements over a given axis treating Not a
/// Numbers (NaNs) as zero.
/// The cumulative sum does not change when NaNs are
/// encountered and leading NaNs are replaced by zeros.
///
/// Zeros are returned for slices that are all-NaN or empty.
///
///
/// Axis along which the cumulative sum is computed.
/// The default
/// (None) is to compute the cumsum over the flattened array.
///
///
/// Type of the returned array and of the accumulator in which the
/// elements are summed.
/// If dtype is not specified, it defaults
/// to the dtype of a, unless a has an integer dtype with a
/// precision less than that of the default platform integer.
/// In
/// that case, the default platform integer is used.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output
/// but the type will be cast if necessary.
/// See doc.ufuncs
/// (Section “Output arguments”) for more details.
///
///
/// A new array holding the result is returned unless out is
/// specified, in which it is returned.
/// The result has the same
/// size as a, and the same shape as a if axis is not None
/// or a is a 1-d array.
///
public NDarray nancumsum(int? axis = null, Dtype dtype = null, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("nancumsum", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Calculate the n-th discrete difference along the given axis.
///
/// The first difference is given by out[n] = a[n+1] - a[n] along
/// the given axis, higher differences are calculated by using diff
/// recursively.
///
/// Notes
///
/// Type is preserved for boolean arrays, so the result will contain
/// False when consecutive elements are the same and True when they
/// differ.
///
/// For unsigned integer arrays, the results will also be unsigned.
/// This
/// should not be surprising, as the result is consistent with
/// calculating the difference directly:
///
/// If this is not desirable, then the array should be cast to a larger
/// integer type first:
///
///
/// The number of times values are differenced.
/// If zero, the input
/// is returned as-is.
///
///
/// The axis along which the difference is taken, default is the
/// last axis.
///
///
/// Values to prepend or append to “a” along axis prior to
/// performing the difference.
/// Scalar values are expanded to
/// arrays with length 1 in the direction of axis and the shape
/// of the input array in along all other axes.
/// Otherwise the
/// dimension and shape must match “a” except along axis.
///
///
/// Values to prepend or append to “a” along axis prior to
/// performing the difference.
/// Scalar values are expanded to
/// arrays with length 1 in the direction of axis and the shape
/// of the input array in along all other axes.
/// Otherwise the
/// dimension and shape must match “a” except along axis.
///
///
/// The n-th differences.
/// The shape of the output is the same as a
/// except along axis where the dimension is smaller by n.
/// The
/// type of the output is the same as the type of the difference
/// between any two elements of a.
/// This is the same as the type of
/// a in most cases.
/// A notable exception is datetime64, which
/// results in a timedelta64 output array.
///
public NDarray diff(int? n = 1, int? axis = -1, NDarray append = null, NDarray prepend = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (n!=1) kwargs["n"]=ToPython(n);
if (axis!=-1) kwargs["axis"]=ToPython(axis);
if (append!=null) kwargs["append"]=ToPython(append);
if (prepend!=null) kwargs["prepend"]=ToPython(prepend);
dynamic py = __self__.InvokeMethod("diff", pyargs, kwargs);
return ToCsharp(py);
}
///
/// The differences between consecutive elements of an array.
///
/// Notes
///
/// When applied to masked arrays, this function drops the mask information
/// if the to_begin and/or to_end parameters are used.
///
///
/// Number(s) to append at the end of the returned differences.
///
///
/// Number(s) to prepend at the beginning of the returned differences.
///
///
/// The differences.
/// Loosely, this is ary.flat[1:] - ary.flat[:-1].
///
public NDarray ediff1d(NDarray to_end = null, NDarray to_begin = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (to_end!=null) kwargs["to_end"]=ToPython(to_end);
if (to_begin!=null) kwargs["to_begin"]=ToPython(to_begin);
dynamic py = __self__.InvokeMethod("ediff1d", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the cross product of two (arrays of) vectors.
///
/// The cross product of a and b in is a vector perpendicular
/// to both a and b.
/// If a and b are arrays of vectors, the vectors
/// are defined by the last axis of a and b by default, and these axes
/// can have dimensions 2 or 3.
/// Where the dimension of either a or b is
/// 2, the third component of the input vector is assumed to be zero and the
/// cross product calculated accordingly.
/// In cases where both input vectors
/// have dimension 2, the z-component of the cross product is returned.
///
/// Notes
///
/// Supports full broadcasting of the inputs.
///
///
/// Components of the second vector(s).
///
///
/// Axis of a that defines the vector(s).
/// By default, the last axis.
///
///
/// Axis of b that defines the vector(s).
/// By default, the last axis.
///
///
/// Axis of c containing the cross product vector(s).
/// Ignored if
/// both input vectors have dimension 2, as the return is scalar.
///
/// By default, the last axis.
///
///
/// If defined, the axis of a, b and c that defines the vector(s)
/// and cross product(s).
/// Overrides axisa, axisb and axisc.
///
///
/// Vector cross product(s).
///
public NDarray cross(NDarray b, int? axisa = -1, int? axisb = -1, int? axisc = -1, int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
b,
});
var kwargs=new PyDict();
if (axisa!=-1) kwargs["axisa"]=ToPython(axisa);
if (axisb!=-1) kwargs["axisb"]=ToPython(axisb);
if (axisc!=-1) kwargs["axisc"]=ToPython(axisc);
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("cross", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Integrate along the given axis using the composite trapezoidal rule.
///
/// Integrate y (x) along given axis.
///
/// Notes
///
/// Image [2] illustrates trapezoidal rule – y-axis locations of points
/// will be taken from y array, by default x-axis distances between
/// points will be 1.0, alternatively they can be provided with x array
/// or with dx scalar.
/// Return value will be equal to combined area under
/// the red lines.
///
/// References
///
///
/// The sample points corresponding to the y values.
/// If x is None,
/// the sample points are assumed to be evenly spaced dx apart.
/// The
/// default is None.
///
///
/// The spacing between sample points when x is None.
/// The default is 1.
///
///
/// The axis along which to integrate.
///
///
/// Definite integral as approximated by trapezoidal rule.
///
public float trapz(NDarray x = null, float? dx = 1.0f, int? axis = -1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (x!=null) kwargs["x"]=ToPython(x);
if (dx!=1.0f) kwargs["dx"]=ToPython(dx);
if (axis!=-1) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("trapz", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Calculate the exponential of all elements in the input array.
///
/// Notes
///
/// The irrational number e is also known as Euler’s number.
/// It is
/// approximately 2.718281, and is the base of the natural logarithm,
/// ln (this means that, if ,
/// then . For real input, exp(x) is always positive.
///
/// For complex arguments, x = a + ib, we can write
/// . The first term, , is already
/// known (it is the real argument, described above).
/// The second term,
/// , is , a function with
/// magnitude 1 and a periodic phase.
///
/// References
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, element-wise exponential of x.
///
/// This is a scalar if x is a scalar.
///
public NDarray exp(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("exp", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Calculate exp(x) - 1 for all elements in the array.
///
/// Notes
///
/// This function provides greater precision than exp(x) - 1
/// for small values of x.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Element-wise exponential minus one: out = exp(x) - 1.
///
/// This is a scalar if x is a scalar.
///
public NDarray expm1(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("expm1", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Calculate 2**p for all p in the input array.
///
/// Notes
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Element-wise 2 to the power x.
///
/// This is a scalar if x is a scalar.
///
public NDarray exp2(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("exp2", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Natural logarithm, element-wise.
///
/// The natural logarithm log is the inverse of the exponential function,
/// so that log(exp(x)) = x.
/// The natural logarithm is logarithm in base
/// e.
///
/// Notes
///
/// Logarithm is a multivalued function: for each x there is an infinite
/// number of z such that exp(z) = x.
/// The convention is to return the
/// z whose imaginary part lies in [-pi, pi].
///
/// For real-valued input data types, log always returns real output.
/// For
/// each value that cannot be expressed as a real number or infinity, it
/// yields nan and sets the invalid floating point error flag.
///
/// For complex-valued input, log is a complex analytical function that
/// has a branch cut [-inf, 0] and is continuous from above on it.
/// log
/// handles the floating-point negative zero as an infinitesimal negative
/// number, conforming to the C99 standard.
///
/// References
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The natural logarithm of x, element-wise.
///
/// This is a scalar if x is a scalar.
///
public NDarray log(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("log", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the base 10 logarithm of the input array, element-wise.
///
/// Notes
///
/// Logarithm is a multivalued function: for each x there is an infinite
/// number of z such that 10**z = x.
/// The convention is to return the
/// z whose imaginary part lies in [-pi, pi].
///
/// For real-valued input data types, log10 always returns real output.
///
/// For each value that cannot be expressed as a real number or infinity,
/// it yields nan and sets the invalid floating point error flag.
///
/// For complex-valued input, log10 is a complex analytical function that
/// has a branch cut [-inf, 0] and is continuous from above on it.
///
/// log10 handles the floating-point negative zero as an infinitesimal
/// negative number, conforming to the C99 standard.
///
/// References
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The logarithm to the base 10 of x, element-wise.
/// NaNs are
/// returned where x is negative.
///
/// This is a scalar if x is a scalar.
///
public NDarray log10(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("log10", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Base-2 logarithm of x.
///
/// Notes
///
/// Logarithm is a multivalued function: for each x there is an infinite
/// number of z such that 2**z = x.
/// The convention is to return the z
/// whose imaginary part lies in [-pi, pi].
///
/// For real-valued input data types, log2 always returns real output.
///
/// For each value that cannot be expressed as a real number or infinity,
/// it yields nan and sets the invalid floating point error flag.
///
/// For complex-valued input, log2 is a complex analytical function that
/// has a branch cut [-inf, 0] and is continuous from above on it.
/// log2
/// handles the floating-point negative zero as an infinitesimal negative
/// number, conforming to the C99 standard.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Base-2 logarithm of x.
///
/// This is a scalar if x is a scalar.
///
public NDarray log2(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("log2", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the natural logarithm of one plus the input array, element-wise.
///
/// Calculates log(1 + x).
///
/// Notes
///
/// For real-valued input, log1p is accurate also for x so small
/// that 1 + x == 1 in floating-point accuracy.
///
/// Logarithm is a multivalued function: for each x there is an infinite
/// number of z such that exp(z) = 1 + x.
/// The convention is to return
/// the z whose imaginary part lies in [-pi, pi].
///
/// For real-valued input data types, log1p always returns real output.
///
/// For each value that cannot be expressed as a real number or infinity,
/// it yields nan and sets the invalid floating point error flag.
///
/// For complex-valued input, log1p is a complex analytical function that
/// has a branch cut [-inf, -1] and is continuous from above on it.
///
/// log1p handles the floating-point negative zero as an infinitesimal
/// negative number, conforming to the C99 standard.
///
/// References
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Natural logarithm of 1 + x, element-wise.
///
/// This is a scalar if x is a scalar.
///
public NDarray log1p(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("log1p", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Logarithm of the sum of exponentiations of the inputs.
///
/// Calculates log(exp(x1) + exp(x2)).
/// This function is useful in
/// statistics where the calculated probabilities of events may be so small
/// as to exceed the range of normal floating point numbers.
/// In such cases
/// the logarithm of the calculated probability is stored.
/// This function
/// allows adding probabilities stored in such a fashion.
///
/// Notes
///
///
/// Input values.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Logarithm of exp(x1) + exp(x2).
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray logaddexp(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logaddexp", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Logarithm of the sum of exponentiations of the inputs in base-2.
///
/// Calculates log2(2**x1 + 2**x2).
/// This function is useful in machine
/// learning when the calculated probabilities of events may be so small as
/// to exceed the range of normal floating point numbers.
/// In such cases
/// the base-2 logarithm of the calculated probability can be used instead.
///
/// This function allows adding probabilities stored in such a fashion.
///
/// Notes
///
///
/// Input values.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Base-2 logarithm of 2**x1 + 2**x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray logaddexp2(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("logaddexp2", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the sinc function.
///
/// The sinc function is .
///
/// Notes
///
/// sinc(0) is the limit value 1.
///
/// The name sinc is short for “sine cardinal” or “sinus cardinalis”.
///
/// The sinc function is used in various signal processing applications,
/// including in anti-aliasing, in the construction of a Lanczos resampling
/// filter, and in interpolation.
///
/// For bandlimited interpolation of discrete-time signals, the ideal
/// interpolation kernel is proportional to the sinc function.
///
/// References
///
///
/// sinc(x), which has the same shape as the input.
///
public NDarray sinc()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("sinc");
return ToCsharp(py);
}
///
/// Returns element-wise True where signbit is set (less than zero).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Output array, or reference to out if that was supplied.
///
/// This is a scalar if x is a scalar.
///
public NDarray signbit(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("signbit", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Change the sign of x1 to that of x2, element-wise.
///
/// If both arguments are arrays or sequences, they have to be of the same
/// length.
/// If x2 is a scalar, its sign will be copied to all elements of
/// x1.
///
///
/// The sign of x2 is copied to x1.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The values of x1 with the sign of x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray copysign(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("copysign", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Decompose the elements of x into mantissa and twos exponent.
///
/// Returns (mantissa, exponent), where x = mantissa * 2**exponent`.
/// The mantissa is lies in the open interval(-1, 1), while the twos
/// exponent is a signed integer.
///
/// Notes
///
/// Complex dtypes are not supported, they will raise a TypeError.
///
///
/// Output array for the mantissa.
/// Must have the same shape as x.
///
///
/// Output array for the exponent.
/// Must have the same shape as x.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// A tuple of:
/// mantissa
/// Floating values between -1 and 1.
/// This is a scalar if x is a scalar.
/// exponent
/// Integer exponents of 2.
/// This is a scalar if x is a scalar.
///
public (NDarray, NDarray) frexp(NDarray out1 = null, NDarray out2 = null, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (out1!=null) kwargs["out1"]=ToPython(out1);
if (out2!=null) kwargs["out2"]=ToPython(out2);
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("frexp", pyargs, kwargs);
return (ToCsharp(py[0]), ToCsharp(py[1]));
}
///
/// Returns x1 * 2**x2, element-wise.
///
/// The mantissas x1 and twos exponents x2 are used to construct
/// floating point numbers x1 * 2**x2.
///
/// Notes
///
/// Complex dtypes are not supported, they will raise a TypeError.
///
/// ldexp is useful as the inverse of frexp, if used by itself it is
/// more clear to simply use the expression x1 * 2**x2.
///
///
/// Array of twos exponents.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The result of x1 * 2**x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray ldexp(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("ldexp", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the next floating-point value after x1 towards x2, element-wise.
///
///
/// The direction where to look for the next representable value of x1.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The next representable values of x1 in the direction of x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray nextafter(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("nextafter", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the distance between x and the nearest adjacent number.
///
/// Notes
///
/// It can be considered as a generalization of EPS:
/// spacing(np.float64(1)) == np.finfo(np.float64).eps, and there
/// should not be any representable number between x + spacing(x) and
/// x for any finite x.
///
/// Spacing of +- inf and NaN is NaN.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The spacing of values of x.
///
/// This is a scalar if x is a scalar.
///
public NDarray spacing(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("spacing", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns the lowest common multiple of |x1| and |x2|
///
///
/// Arrays of values
///
///
/// The lowest common multiple of the absolute value of the inputs
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray lcm(NDarray x1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("lcm", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns the greatest common divisor of |x1| and |x2|
///
///
/// Arrays of values
///
///
/// The greatest common divisor of the absolute value of the inputs
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray gcd(NDarray x1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("gcd", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Add arguments element-wise.
///
/// Notes
///
/// Equivalent to x1 + x2 in terms of array broadcasting.
///
///
/// The arrays to be added.
/// If x1.shape != x2.shape, they must be
/// broadcastable to a common shape (which may be the shape of one or
/// the other).
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The sum of x1 and x2, element-wise.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray @add(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("add", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the reciprocal of the argument, element-wise.
///
/// Calculates 1/x.
///
/// Notes
///
/// For integer arguments with absolute value larger than 1 the result is
/// always zero because of the way Python handles integer division.
/// For
/// integer zero the result is an overflow.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Return array.
///
/// This is a scalar if x is a scalar.
///
public NDarray reciprocal(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("reciprocal", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Numerical positive, element-wise.
///
/// Notes
///
/// Equivalent to x.copy(), but only defined for types that support
/// arithmetic.
///
///
/// Returned array or scalar: y = +x.
///
/// This is a scalar if x is a scalar.
///
public NDarray positive()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("positive");
return ToCsharp(py);
}
///
/// Numerical negative, element-wise.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Returned array or scalar: y = -x.
///
/// This is a scalar if x is a scalar.
///
public NDarray negative(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("negative", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Multiply arguments element-wise.
///
/// Notes
///
/// Equivalent to x1 * x2 in terms of array broadcasting.
///
///
/// Input arrays to be multiplied.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The product of x1 and x2, element-wise.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray multiply(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("multiply", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns a true division of the inputs, element-wise.
///
/// Instead of the Python traditional ‘floor division’, this returns a true
/// division.
/// True division adjusts the output type to present the best
/// answer, regardless of input types.
///
/// Notes
///
/// The floor division operator // was added in Python 2.2 making
/// // and / equivalent operators.
/// The default floor division
/// operation of / can be replaced by true division with from
/// __future__ import division.
///
/// In Python 3.0, // is the floor division operator and / the
/// true division operator.
/// The true_divide(x1, x2) function is
/// equivalent to true division in Python.
///
///
/// Divisor array.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray divide(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("divide", pyargs, kwargs);
return ToCsharp(py);
}
///
/// First array elements raised to powers from second array, element-wise.
///
/// Raise each base in x1 to the positionally-corresponding power in
/// x2. x1 and x2 must be broadcastable to the same shape.
/// Note that an
/// integer type raised to a negative integer power will raise a ValueError.
///
///
/// The exponents.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The bases in x1 raised to the exponents in x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray power(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("power", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Subtract arguments, element-wise.
///
/// Notes
///
/// Equivalent to x1 - x2 in terms of array broadcasting.
///
///
/// The arrays to be subtracted from each other.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The difference of x1 and x2, element-wise.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray subtract(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("subtract", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns a true division of the inputs, element-wise.
///
/// Instead of the Python traditional ‘floor division’, this returns a true
/// division.
/// True division adjusts the output type to present the best
/// answer, regardless of input types.
///
/// Notes
///
/// The floor division operator // was added in Python 2.2 making
/// // and / equivalent operators.
/// The default floor division
/// operation of / can be replaced by true division with from
/// __future__ import division.
///
/// In Python 3.0, // is the floor division operator and / the
/// true division operator.
/// The true_divide(x1, x2) function is
/// equivalent to true division in Python.
///
///
/// Divisor array.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray true_divide(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("true_divide", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the largest integer smaller or equal to the division of the inputs.
///
/// It is equivalent to the Python // operator and pairs with the
/// Python % (remainder), function so that b = a % b + b * (a // b)
/// up to roundoff.
///
///
/// Denominator.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// y = floor(x1/x2)
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray floor_divide(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("floor_divide", pyargs, kwargs);
return ToCsharp(py);
}
///
/// First array elements raised to powers from second array, element-wise.
///
/// Raise each base in x1 to the positionally-corresponding power in x2.
/// x1 and x2 must be broadcastable to the same shape.
/// This differs from
/// the power function in that integers, float16, and float32 are promoted to
/// floats with a minimum precision of float64 so that the result is always
/// inexact.
/// The intent is that the function will return a usable result for
/// negative powers and seldom overflow for positive powers.
///
///
/// The exponents.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The bases in x1 raised to the exponents in x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray float_power(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("float_power", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the element-wise remainder of division.
///
/// This is the NumPy implementation of the C library function fmod, the
/// remainder has the same sign as the dividend x1. It is equivalent to
/// the Matlab(TM) rem function and should not be confused with the
/// Python modulus operator x1 % x2.
///
/// Notes
///
/// The result of the modulo operation for negative dividend and divisors
/// is bound by conventions.
/// For fmod, the sign of result is the sign of
/// the dividend, while for remainder the sign of the result is the sign
/// of the divisor.
/// The fmod function is equivalent to the Matlab(TM)
/// rem function.
///
///
/// Divisor.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The remainder of the division of x1 by x2.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray fmod(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("fmod", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return element-wise remainder of division.
///
/// Computes the remainder complementary to the floor_divide function.
/// It is
/// equivalent to the Python modulus operator``x1 % x2`` and has the same sign
/// as the divisor x2. The MATLAB function equivalent to np.remainder
/// is mod.
///
/// Notes
///
/// Returns 0 when x2 is 0 and both x1 and x2 are (arrays of)
/// integers.
///
///
/// Divisor array.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The element-wise remainder of the quotient floor_divide(x1, x2).
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray mod(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("mod", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the fractional and integral parts of an array, element-wise.
///
/// The fractional and integral parts are negative if the given number is
/// negative.
///
/// Notes
///
/// For integer input the return values are floats.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// A tuple of:
/// y1
/// Fractional part of x.
/// This is a scalar if x is a scalar.
/// y2
/// Integral part of x.
/// This is a scalar if x is a scalar.
///
public (NDarray, NDarray) modf(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("modf", pyargs, kwargs);
return (ToCsharp(py[0]), ToCsharp(py[1]));
}
///
/// Return element-wise remainder of division.
///
/// Computes the remainder complementary to the floor_divide function.
/// It is
/// equivalent to the Python modulus operator``x1 % x2`` and has the same sign
/// as the divisor x2. The MATLAB function equivalent to np.remainder
/// is mod.
///
/// Notes
///
/// Returns 0 when x2 is 0 and both x1 and x2 are (arrays of)
/// integers.
///
///
/// Divisor array.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The element-wise remainder of the quotient floor_divide(x1, x2).
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray remainder(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("remainder", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return element-wise quotient and remainder simultaneously.
///
/// np.divmod(x, y) is equivalent to (x // y, x % y), but faster
/// because it avoids redundant work.
/// It is used to implement the Python
/// built-in function divmod on NumPy arrays.
///
///
/// Divisor array.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// A tuple of:
/// out1
/// Element-wise quotient resulting from floor division.
/// This is a scalar if both x1 and x2 are scalars.
/// out2
/// Element-wise remainder from floor division.
/// This is a scalar if both x1 and x2 are scalars.
///
public (NDarray, NDarray) divmod(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("divmod", pyargs, kwargs);
return (ToCsharp(py[0]), ToCsharp(py[1]));
}
///
/// Return the angle of the complex argument.
///
///
/// Return angle in degrees if True, radians if False (default).
///
///
/// The counterclockwise angle from the positive real axis on
/// the complex plane, with dtype as numpy.float64.
///
public NDarray angle(bool? deg = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (deg!=false) kwargs["deg"]=ToPython(deg);
dynamic py = __self__.InvokeMethod("angle", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the complex conjugate, element-wise.
///
/// The complex conjugate of a complex number is obtained by changing the
/// sign of its imaginary part.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The complex conjugate of x, with same dtype as y.
///
/// This is a scalar if x is a scalar.
///
public NDarray conj(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("conj", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns the discrete, linear convolution of two one-dimensional sequences.
///
/// The convolution operator is often seen in signal processing, where it
/// models the effect of a linear time-invariant system on a signal [1].
/// In
/// probability theory, the sum of two independent random variables is
/// distributed according to the convolution of their individual
/// distributions.
///
/// If v is longer than a, the arrays are swapped before computation.
///
/// Notes
///
/// The discrete convolution operation is defined as
///
/// It can be shown that a convolution in time/space
/// is equivalent to the multiplication in the Fourier
/// domain, after appropriate padding (padding is necessary to prevent
/// circular convolution).
/// Since multiplication is more efficient (faster)
/// than convolution, the function scipy.signal.fftconvolve exploits the
/// FFT to calculate the convolution of large data-sets.
///
/// References
///
///
/// Second one-dimensional input array.
///
///
/// Discrete, linear convolution of a and v.
///
public NDarray convolve(NDarray v, string mode = "full")
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
v,
});
var kwargs=new PyDict();
if (mode!="full") kwargs["mode"]=ToPython(mode);
dynamic py = __self__.InvokeMethod("convolve", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Clip (limit) the values in an array.
///
/// Given an interval, values outside the interval are clipped to
/// the interval edges.
/// For example, if an interval of [0, 1]
/// is specified, values smaller than 0 become 0, and values larger
/// than 1 become 1.
///
///
/// Minimum value.
/// If None, clipping is not performed on lower
/// interval edge.
/// Not more than one of a_min and a_max may be
/// None.
///
///
/// Maximum value.
/// If None, clipping is not performed on upper
/// interval edge.
/// Not more than one of a_min and a_max may be
/// None.
/// If a_min or a_max are array_like, then the three
/// arrays will be broadcasted to match their shapes.
///
///
/// The results will be placed in this array.
/// It may be the input
/// array for in-place clipping.
/// out must be of the right shape
/// to hold the output.
/// Its type is preserved.
///
///
/// An array with the elements of a, but where values
/// < a_min are replaced with a_min, and those > a_max
/// with a_max.
///
public NDarray clip(NDarray a_min, NDarray a_max, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
a_min,
a_max,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
dynamic py = __self__.InvokeMethod("clip", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the non-negative square-root of an array, element-wise.
///
/// Notes
///
/// sqrt has–consistent with common convention–as its branch cut the
/// real “interval” [-inf, 0), and is continuous from above on it.
///
/// A branch cut is a curve in the complex plane across which a given
/// complex function fails to be continuous.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// An array of the same shape as x, containing the positive
/// square-root of each element in x.
/// If any element in x is
/// complex, a complex array is returned (and the square-roots of
/// negative reals are calculated).
/// If all of the elements in x
/// are real, so is y, with negative elements returning nan.
///
/// If out was provided, y is a reference to it.
///
/// This is a scalar if x is a scalar.
///
public NDarray sqrt(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("sqrt", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the cube-root of an array, element-wise.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// An array of the same shape as x, containing the cube
/// cube-root of each element in x.
///
/// If out was provided, y is a reference to it.
///
/// This is a scalar if x is a scalar.
///
public NDarray cbrt(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("cbrt", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return the element-wise square of the input.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// Element-wise x*x, of the same shape and dtype as x.
///
/// This is a scalar if x is a scalar.
///
public NDarray square(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("square", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Calculate the absolute value element-wise.
///
/// np.abs is a shorthand for this function.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// An ndarray containing the absolute value of
/// each element in x.
/// For complex input, a + ib, the
/// absolute value is .
/// This is a scalar if x is a scalar.
///
public NDarray absolute(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("absolute", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the absolute values element-wise.
///
/// This function returns the absolute values (positive magnitude) of the
/// data in x.
/// Complex values are not handled, use absolute to find the
/// absolute values of complex data.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The absolute values of x, the returned values are always floats.
///
/// This is a scalar if x is a scalar.
///
public NDarray fabs(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("fabs", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns an element-wise indication of the sign of a number.
///
/// The sign function returns -1 if x < 0, 0 if x==0, 1 if x > 0.
/// nan
/// is returned for nan inputs.
///
/// For complex inputs, the sign function returns
/// sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j.
///
/// complex(nan, 0) is returned for complex nan inputs.
///
/// Notes
///
/// There is more than one definition of sign in common use for complex
/// numbers.
/// The definition used here is equivalent to
/// which is different from a common alternative, .
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The sign of x.
///
/// This is a scalar if x is a scalar.
///
public NDarray sign(NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("sign", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the Heaviside step function.
///
/// The Heaviside step function is defined as:
///
/// where x2 is often taken to be 0.5, but 0 and 1 are also sometimes used.
///
/// Notes
///
/// References
///
///
/// The value of the function when x1 is 0.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The output array, element-wise Heaviside step function of x1.
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray heaviside(NDarray x2, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x2,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("heaviside", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Element-wise maximum of array elements.
///
/// Compare two arrays and returns a new array containing the element-wise
/// maxima.
/// If one of the elements being compared is a NaN, then that
/// element is returned.
/// If both elements are NaNs then the first is
/// returned.
/// The latter distinction is important for complex NaNs, which
/// are defined as at least one of the real or imaginary parts being a NaN.
///
/// The net effect is that NaNs are propagated.
///
/// Notes
///
/// The maximum is equivalent to np.where(x1 >= x2, x1, x2) when
/// neither x1 nor x2 are nans, but it is faster and does proper
/// broadcasting.
///
///
/// The arrays holding the elements to be compared.
/// They must have
/// the same shape, or shapes that can be broadcast to a single shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The maximum of x1 and x2, element-wise.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray maximum(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("maximum", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Element-wise minimum of array elements.
///
/// Compare two arrays and returns a new array containing the element-wise
/// minima.
/// If one of the elements being compared is a NaN, then that
/// element is returned.
/// If both elements are NaNs then the first is
/// returned.
/// The latter distinction is important for complex NaNs, which
/// are defined as at least one of the real or imaginary parts being a NaN.
///
/// The net effect is that NaNs are propagated.
///
/// Notes
///
/// The minimum is equivalent to np.where(x1 <= x2, x1, x2) when
/// neither x1 nor x2 are NaNs, but it is faster and does proper
/// broadcasting.
///
///
/// The arrays holding the elements to be compared.
/// They must have
/// the same shape, or shapes that can be broadcast to a single shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The minimum of x1 and x2, element-wise.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray minimum(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("minimum", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Element-wise maximum of array elements.
///
/// Compare two arrays and returns a new array containing the element-wise
/// maxima.
/// If one of the elements being compared is a NaN, then the
/// non-nan element is returned.
/// If both elements are NaNs then the first
/// is returned.
/// The latter distinction is important for complex NaNs,
/// which are defined as at least one of the real or imaginary parts being
/// a NaN.
/// The net effect is that NaNs are ignored when possible.
///
/// Notes
///
/// The fmax is equivalent to np.where(x1 >= x2, x1, x2) when neither
/// x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
///
///
/// The arrays holding the elements to be compared.
/// They must have
/// the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The maximum of x1 and x2, element-wise.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray fmax(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("fmax", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Element-wise minimum of array elements.
///
/// Compare two arrays and returns a new array containing the element-wise
/// minima.
/// If one of the elements being compared is a NaN, then the
/// non-nan element is returned.
/// If both elements are NaNs then the first
/// is returned.
/// The latter distinction is important for complex NaNs,
/// which are defined as at least one of the real or imaginary parts being
/// a NaN.
/// The net effect is that NaNs are ignored when possible.
///
/// Notes
///
/// The fmin is equivalent to np.where(x1 <= x2, x1, x2) when neither
/// x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
///
///
/// The arrays holding the elements to be compared.
/// They must have
/// the same shape.
///
///
/// A location into which the result is stored.
/// If provided, it must have
/// a shape that the inputs broadcast to.
/// If not provided or None,
/// a freshly-allocated array is returned.
/// A tuple (possible only as a
/// keyword argument) must have length equal to the number of outputs.
///
///
/// Values of True indicate to calculate the ufunc at that position, values
/// of False indicate to leave the value in the output alone.
///
///
/// The minimum of x1 and x2, element-wise.
///
/// This is a scalar if both x1 and x2 are scalars.
///
public NDarray fmin(NDarray x1, NDarray @out = null, NDarray @where = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
x1,
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (@where!=null) kwargs["where"]=ToPython(@where);
dynamic py = __self__.InvokeMethod("fmin", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Replace NaN with zero and infinity with large finite numbers.
///
/// If x is inexact, NaN is replaced by zero, and infinity and -infinity
/// replaced by the respectively largest and most negative finite floating
/// point values representable by x.dtype.
///
/// For complex dtypes, the above is applied to each of the real and
/// imaginary components of x separately.
///
/// If x is not inexact, then no replacements are made.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
/// This means that Not a Number is not equivalent to infinity.
///
///
/// Whether to create a copy of x (True) or to replace values
/// in-place (False).
/// The in-place operation only occurs if
/// casting to an array does not require a copy.
///
/// Default is True.
///
///
/// x, with the non-finite values replaced.
/// If copy is False, this may
/// be x itself.
///
public NDarray nan_to_num(bool? copy = true)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (copy!=true) kwargs["copy"]=ToPython(copy);
dynamic py = __self__.InvokeMethod("nan_to_num", pyargs, kwargs);
return ToCsharp(py);
}
///
/// If complex input returns a real array if complex parts are close to zero.
///
/// “Close to zero” is defined as tol * (machine epsilon of the type for
/// a).
///
/// Notes
///
/// Machine epsilon varies from machine to machine and between data types
/// but Python floats on most platforms have a machine epsilon equal to
/// 2.2204460492503131e-16. You can use ‘np.finfo(float).eps’ to print
/// out the machine epsilon for floats.
///
///
/// Tolerance in machine epsilons for the complex part of the elements
/// in the array.
///
///
/// If a is real, the type of a is used for the output.
/// If a
/// has complex elements, the returned type is float.
///
public NDarray real_if_close(float tol = 100)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (tol!=100) kwargs["tol"]=ToPython(tol);
dynamic py = __self__.InvokeMethod("real_if_close", pyargs, kwargs);
return ToCsharp(py);
}
/*
///
/// One-dimensional linear interpolation.
///
/// Returns the one-dimensional piecewise linear interpolant to a function
/// with given discrete data points (xp, fp), evaluated at x.
///
/// Notes
///
/// Does not check that the x-coordinate sequence xp is increasing.
///
/// If xp is not increasing, the results are nonsense.
///
/// A simple check for increasing is:
///
///
/// The x-coordinates of the data points, must be increasing if argument
/// period is not specified.
/// Otherwise, xp is internally sorted after
/// normalizing the periodic boundaries with xp = xp % period.
///
///
/// The y-coordinates of the data points, same length as xp.
///
///
/// Value to return for x < xp[0], default is fp[0].
///
///
/// Value to return for x > xp[-1], default is fp[-1].
///
///
/// A period for the x-coordinates.
/// This parameter allows the proper
/// interpolation of angular x-coordinates.
/// Parameters left and right
/// are ignored if period is specified.
///
///
/// The interpolated values, same shape as x.
///
public float or complex (corresponding to fp) or ndarray interp(1-D sequence of floats xp, 1-D sequence of float or complex fp, optional float or complex corresponding to fp left = null, optional float or complex corresponding to fp right = null, None or float period = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
xp,
fp,
});
var kwargs=new PyDict();
if (left!=null) kwargs["left"]=ToPython(left);
if (right!=null) kwargs["right"]=ToPython(right);
if (period!=null) kwargs["period"]=ToPython(period);
dynamic py = __self__.InvokeMethod("interp", pyargs, kwargs);
return ToCsharp(py);
}
*/
///
/// Pads an array.
///
/// Notes
///
/// For an array with rank greater than 1, some of the padding of later
/// axes is calculated from padding of previous axes.
/// This is easiest to
/// think about with a rank 2 array where the corners of the padded array
/// are calculated by using padded values from the first axis.
///
/// The padding function, if used, should return a rank 1 array equal in
/// length to the vector argument with padded values replaced.
/// It has the
/// following signature:
///
/// where
///
///
/// Number of values padded to the edges of each axis.
///
/// ((before_1, after_1), … (before_N, after_N)) unique pad widths
/// for each axis.
///
/// ((before, after),) yields same before and after pad for each axis.
///
/// (pad,) or int is a shortcut for before = after = pad width for all
/// axes.
///
///
/// One of the following string values or a user supplied function.
///
///
/// Used in ‘maximum’, ‘mean’, ‘median’, and ‘minimum’. Number of
/// values at edge of each axis used to calculate the statistic value.
///
/// ((before_1, after_1), … (before_N, after_N)) unique statistic
/// lengths for each axis.
///
/// ((before, after),) yields same before and after statistic lengths
/// for each axis.
///
/// (stat_length,) or int is a shortcut for before = after = statistic
/// length for all axes.
///
/// Default is None, to use the entire axis.
///
///
/// Used in ‘constant’. The values to set the padded values for each
/// axis.
///
/// ((before_1, after_1), … (before_N, after_N)) unique pad constants
/// for each axis.
///
/// ((before, after),) yields same before and after constants for each
/// axis.
///
/// (constant,) or int is a shortcut for before = after = constant for
/// all axes.
///
/// Default is 0.
///
///
/// Used in ‘linear_ramp’. The values used for the ending value of the
/// linear_ramp and that will form the edge of the padded array.
///
/// ((before_1, after_1), … (before_N, after_N)) unique end values
/// for each axis.
///
/// ((before, after),) yields same before and after end values for each
/// axis.
///
/// (constant,) or int is a shortcut for before = after = end value for
/// all axes.
///
/// Default is 0.
///
///
/// Used in ‘reflect’, and ‘symmetric’. The ‘even’ style is the
/// default with an unaltered reflection around the edge value.
/// For
/// the ‘odd’ style, the extended part of the array is created by
/// subtracting the reflected values from two times the edge value.
///
///
/// Padded array of rank equal to array with shape increased
/// according to pad_width.
///
public NDarray pad(NDarray pad_width, string mode, int[] stat_length = null, int[] constant_values = null, int[] end_values = null, string reflect_type = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
pad_width,
mode,
});
var kwargs=new PyDict();
if (stat_length!=null) kwargs["stat_length"]=ToPython(stat_length);
if (constant_values!=null) kwargs["constant_values"]=ToPython(constant_values);
if (end_values!=null) kwargs["end_values"]=ToPython(end_values);
if (reflect_type!=null) kwargs["reflect_type"]=ToPython(reflect_type);
dynamic py = __self__.InvokeMethod("pad", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Test whether each element of a 1-D array is also present in a second array.
///
/// Returns a boolean array the same length as ar1 that is True
/// where an element of ar1 is in ar2 and False otherwise.
///
/// We recommend using isin instead of in1d for new code.
///
/// Notes
///
/// in1d can be considered as an element-wise function version of the
/// python keyword in, for 1-D sequences.
/// in1d(a, b) is roughly
/// equivalent to np.array([item in b for item in a]).
///
/// However, this idea fails if ar2 is a set, or similar (non-sequence)
/// container: As ar2 is converted to an array, in those cases
/// asarray(ar2) is an object array rather than the expected array of
/// contained values.
///
///
/// The values against which to test each value of ar1.
///
///
/// If True, the input arrays are both assumed to be unique, which
/// can speed up the calculation.
/// Default is False.
///
///
/// If True, the values in the returned array are inverted (that is,
/// False where an element of ar1 is in ar2 and True otherwise).
///
/// Default is False.
/// np.in1d(a, b, invert=True) is equivalent
/// to (but is faster than) np.invert(in1d(a, b)).
///
///
/// The values ar1[in1d] are in ar2.
///
public NDarray in1d(NDarray ar2, bool? assume_unique = false, bool? invert = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
ar2,
});
var kwargs=new PyDict();
if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique);
if (invert!=false) kwargs["invert"]=ToPython(invert);
dynamic py = __self__.InvokeMethod("in1d", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Find the intersection of two arrays.
///
/// Return the sorted, unique values that are in both of the input arrays.
///
///
/// Input arrays.
/// Will be flattened if not already 1D.
///
///
/// If True, the input arrays are both assumed to be unique, which
/// can speed up the calculation.
/// Default is False.
///
///
/// If True, the indices which correspond to the intersection of the two
/// arrays are returned.
/// The first instance of a value is used if there are
/// multiple.
/// Default is False.
///
///
/// A tuple of:
/// intersect1d
/// Sorted 1D array of common and unique elements.
/// comm1
/// The indices of the first occurrences of the common values in ar1.
/// Only provided if return_indices is True.
/// comm2
/// The indices of the first occurrences of the common values in ar2.
/// Only provided if return_indices is True.
///
public (NDarray, NDarray, NDarray) intersect1d(NDarray ar1, bool assume_unique = false, bool return_indices = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
ar1,
});
var kwargs=new PyDict();
if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique);
if (return_indices!=false) kwargs["return_indices"]=ToPython(return_indices);
dynamic py = __self__.InvokeMethod("intersect1d", pyargs, kwargs);
return (ToCsharp(py[0]), ToCsharp(py[1]), ToCsharp(py[2]));
}
///
/// Calculates element in test_elements, broadcasting over element only.
///
/// Returns a boolean array of the same shape as element that is True
/// where an element of element is in test_elements and False otherwise.
///
/// Notes
///
/// isin is an element-wise function version of the python keyword in.
///
/// isin(a, b) is roughly equivalent to
/// np.array([item in b for item in a]) if a and b are 1-D sequences.
///
/// element and test_elements are converted to arrays if they are not
/// already.
/// If test_elements is a set (or other non-sequence collection)
/// it will be converted to an object array with one element, rather than an
/// array of the values contained in test_elements.
/// This is a consequence
/// of the array constructor’s way of handling non-sequence collections.
///
/// Converting the set to a list usually gives the desired behavior.
///
///
/// The values against which to test each value of element.
///
/// This argument is flattened if it is an array or array_like.
///
/// See notes for behavior with non-array-like parameters.
///
///
/// If True, the input arrays are both assumed to be unique, which
/// can speed up the calculation.
/// Default is False.
///
///
/// If True, the values in the returned array are inverted, as if
/// calculating element not in test_elements.
/// Default is False.
///
/// np.isin(a, b, invert=True) is equivalent to (but faster
/// than) np.invert(np.isin(a, b)).
///
///
/// Has the same shape as element.
/// The values element[isin]
/// are in test_elements.
///
public NDarray isin(NDarray test_elements, bool? assume_unique = false, bool? invert = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
test_elements,
});
var kwargs=new PyDict();
if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique);
if (invert!=false) kwargs["invert"]=ToPython(invert);
dynamic py = __self__.InvokeMethod("isin", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Find the set difference of two arrays.
///
/// Return the unique values in ar1 that are not in ar2.
///
///
/// Input comparison array.
///
///
/// If True, the input arrays are both assumed to be unique, which
/// can speed up the calculation.
/// Default is False.
///
///
/// 1D array of values in ar1 that are not in ar2. The result
/// is sorted when assume_unique=False, but otherwise only sorted
/// if the input is sorted.
///
public NDarray setdiff1d(NDarray ar2, bool assume_unique = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
ar2,
});
var kwargs=new PyDict();
if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique);
dynamic py = __self__.InvokeMethod("setdiff1d", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Find the set exclusive-or of two arrays.
///
/// Return the sorted, unique values that are in only one (not both) of the
/// input arrays.
///
///
/// Input arrays.
///
///
/// If True, the input arrays are both assumed to be unique, which
/// can speed up the calculation.
/// Default is False.
///
///
/// Sorted 1D array of unique values that are in only one of the input
/// arrays.
///
public NDarray setxor1d(NDarray ar1, bool assume_unique = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
ar1,
});
var kwargs=new PyDict();
if (assume_unique!=false) kwargs["assume_unique"]=ToPython(assume_unique);
dynamic py = __self__.InvokeMethod("setxor1d", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Find the union of two arrays.
///
/// Return the unique, sorted array of values that are in either of the two
/// input arrays.
///
///
/// Input arrays.
/// They are flattened if they are not already 1D.
///
///
/// Unique, sorted union of the input arrays.
///
public NDarray union1d(NDarray ar1)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
ar1,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("union1d", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return a sorted copy of an array.
///
/// Notes
///
/// The various sorting algorithms are characterized by their average speed,
/// worst case performance, work space size, and whether they are stable.
/// A
/// stable sort keeps items with the same key in the same relative
/// order.
/// 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.
/// Consequently, sorting along
/// the last axis is faster and uses less space than sorting along
/// any other axis.
///
/// The sort order for complex numbers is lexicographic.
/// 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.
///
/// Previous to numpy 1.4.0 sorting real and complex arrays containing nan
/// values led to undefined behaviour.
/// In numpy versions >= 1.4.0 nan
/// values are sorted to the end.
/// The extended sort order is:
///
/// where R is a non-nan real value.
/// Complex values with the same nan
/// placements are sorted according to the non-nan part if it exists.
///
/// Non-nan values are sorted as before.
///
/// quicksort has been changed to an introsort which will switch
/// heapsort when it does not make enough progress.
/// This makes its
/// worst case O(n*log(n)).
///
/// ‘stable’ automatically choses the best stable sorting algorithm
/// for the data type being sorted.
/// It is currently mapped to
/// merge sort.
///
///
/// Axis along which to sort.
/// If None, the array is flattened before
/// sorting.
/// The default is -1, which sorts along the last axis.
///
///
/// Sorting algorithm.
/// Default is ‘quicksort’.
///
///
/// When a is an array with fields defined, this argument specifies
/// which fields to compare first, second, etc.
/// 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.
///
///
/// Array of the same type and shape as a.
///
public NDarray sort(int? axis = -1, string kind = "quicksort", 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!="quicksort") kwargs["kind"]=ToPython(kind);
if (order!=null) kwargs["order"]=ToPython(order);
dynamic py = __self__.InvokeMethod("sort", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Perform an indirect stable sort using a sequence of keys.
///
/// 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.
/// 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.
/// The keys argument must be a sequence of objects that
/// can be converted to arrays of the same shape.
/// 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.
///
///
/// Axis to be indirectly sorted.
/// By default, sort over the last axis.
///
///
/// Array of indices that sort the keys along the specified axis.
///
public NDarray lexsort(int? axis = -1)
{
//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);
dynamic py = __self__.InvokeMethod("lexsort", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns the indices that would sort an array.
///
/// Perform an indirect sort along the given axis using the algorithm specified
/// by the kind keyword.
/// It returns an array of indices of the same shape as
/// a that index data along the given axis in sorted order.
///
/// Notes
///
/// See sort for notes on the different sorting algorithms.
///
/// As of NumPy 1.4.0 argsort works with real/complex arrays containing
/// nan values.
/// The enhanced sort order is documented in sort.
///
///
/// Axis along which to sort.
/// The default is -1 (the last axis).
/// If None,
/// the flattened array is used.
///
///
/// Sorting algorithm.
///
///
/// When a is an array with fields defined, this argument specifies
/// which fields to compare first, second, etc.
/// 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.
///
///
/// Array of indices that sort a along the specified axis.
///
/// If a is one-dimensional, a[index_array] yields a sorted a.
///
/// More generally, np.take_along_axis(a, index_array, axis=a) always
/// yields the sorted a, irrespective of dimensionality.
///
public NDarray argsort(int? axis = -1, string kind = "quicksort", 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!="quicksort") kwargs["kind"]=ToPython(kind);
if (order!=null) kwargs["order"]=ToPython(order);
dynamic py = __self__.InvokeMethod("argsort", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Return a copy of an array sorted along the first axis.
///
/// Notes
///
/// np.msort(a) is equivalent to np.sort(a, axis=0).
///
///
/// Array of the same type and shape as a.
///
public NDarray msort()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("msort");
return ToCsharp(py);
}
///
/// Sort a complex array using the real part first, then the imaginary part.
///
///
/// Always returns a sorted complex array.
///
public NDarray sort_complex()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("sort_complex");
return ToCsharp(py);
}
///
/// Return a partitioned copy of an array.
///
/// 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.
/// All elements smaller than
/// the k-th element are moved before this element and all equal or
/// greater are moved behind it.
/// The ordering of the elements in the two
/// partitions is undefined.
///
/// Notes
///
/// The various selection algorithms are characterized by their average
/// speed, worst case performance, work space size, and whether they are
/// stable.
/// A stable sort keeps items with the same key in the same
/// relative order.
/// 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.
/// Consequently,
/// partitioning along the last axis is faster and uses less space than
/// partitioning along any other axis.
///
/// The sort order for complex numbers is lexicographic.
/// 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.
///
///
/// Element index to partition by.
/// 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.
/// The order of all elements in the partitions is undefined.
/// 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.
///
///
/// Axis along which to sort.
/// If None, the array is flattened before
/// sorting.
/// The default is -1, which sorts along the last axis.
///
///
/// Selection algorithm.
/// Default is ‘introselect’.
///
///
/// When a is an array with fields defined, this argument
/// specifies which fields to compare first, second, etc.
/// A single
/// field can be specified as a string.
/// 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.
///
///
/// Array of the same type and shape as a.
///
public NDarray partition(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[]
{
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(py);
}
///
/// Perform an indirect partition along the given axis using the
/// algorithm specified by the kind keyword.
/// It returns an array of
/// indices of the same shape as a that index data along the given
/// axis in partitioned order.
///
/// Notes
///
/// See partition for notes on the different selection algorithms.
///
///
/// Element index to partition by.
/// 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.
/// The order all
/// elements in the partitions is undefined.
/// If provided with a
/// sequence of k-th it will partition all of them into their sorted
/// position at once.
///
///
/// Axis along which to sort.
/// The default is -1 (the last axis).
/// If
/// None, the flattened array is used.
///
///
/// Selection algorithm.
/// Default is ‘introselect’
///
///
/// When a is an array with fields defined, this argument
/// specifies which fields to compare first, second, etc.
/// 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.
///
///
/// Array of indices that partition a along the specified axis.
///
/// If a is one-dimensional, a[index_array] yields a partitioned a.
///
/// More generally, np.take_along_axis(a, index_array, axis=a) always
/// yields the partitioned a, irrespective of dimensionality.
///
public NDarray argpartition(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[]
{
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(py);
}
///
/// Returns the indices of the maximum values along an axis.
///
/// Notes
///
/// In case of multiple occurrences of the maximum values, the indices
/// corresponding to the first occurrence are returned.
///
///
/// By default, the index is into the flattened array, otherwise
/// along the specified axis.
///
///
/// If provided, the result will be inserted into this array.
/// It should
/// be of the appropriate shape and dtype.
///
///
/// Array of indices into the array.
/// It has the same shape as a.shape
/// with the dimension along axis removed.
///
public NDarray argmax(int? axis = null, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
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(py);
}
///
/// Return the indices of the maximum values in the specified axis ignoring
/// NaNs.
/// For all-NaN slices ValueError is raised.
/// Warning: the
/// results cannot be trusted if a slice contains only NaNs and -Infs.
///
///
/// Axis along which to operate.
/// By default flattened input is used.
///
///
/// An array of indices or a single index value.
///
public NDarray nanargmax(int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("nanargmax", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Returns the indices of the minimum values along an axis.
///
/// Notes
///
/// In case of multiple occurrences of the minimum values, the indices
/// corresponding to the first occurrence are returned.
///
///
/// By default, the index is into the flattened array, otherwise
/// along the specified axis.
///
///
/// If provided, the result will be inserted into this array.
/// It should
/// be of the appropriate shape and dtype.
///
///
/// Array of indices into the array.
/// It has the same shape as a.shape
/// with the dimension along axis removed.
///
public NDarray argmin(int? axis = null, NDarray @out = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
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(py);
}
///
/// Return the indices of the minimum values in the specified axis ignoring
/// NaNs.
/// For all-NaN slices ValueError is raised.
/// Warning: the results
/// cannot be trusted if a slice contains only NaNs and Infs.
///
///
/// Axis along which to operate.
/// By default flattened input is used.
///
///
/// An array of indices or a single index value.
///
public NDarray nanargmin(int? axis = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("nanargmin", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Find the indices of array elements that are non-zero, grouped by element.
///
/// Notes
///
/// np.argwhere(a) is the same as np.transpose(np.nonzero(a)).
///
/// The output of argwhere is not suitable for indexing arrays.
///
/// For this purpose use nonzero(a) instead.
///
///
/// Indices of elements that are non-zero.
/// Indices are grouped by element.
///
public NDarray argwhere()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("argwhere");
return ToCsharp(py);
}
///
/// Return indices that are non-zero in the flattened version of a.
///
/// This is equivalent to np.nonzero(np.ravel(a))[0].
///
///
/// Output array, containing the indices of the elements of a.ravel()
/// that are non-zero.
///
public NDarray flatnonzero()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("flatnonzero");
return ToCsharp(py);
}
///
/// Find indices where elements should be inserted to maintain order.
///
/// 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.
///
/// Assuming that a is sorted:
///
/// Notes
///
/// Binary search is used to find the required insertion points.
///
/// As of NumPy 1.4.0 searchsorted works with real/complex arrays containing
/// nan values.
/// The enhanced sort order is documented in sort.
///
/// 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.
///
///
/// Values to insert into a.
///
///
/// If ‘left’, the index of the first suitable location found is given.
///
/// If ‘right’, return the last such index.
/// If there is no suitable
/// index, return either 0 or N (where N is the length of a).
///
///
/// Optional array of integer indices that sort array a into ascending
/// order.
/// They are typically the result of argsort.
///
///
/// Array of insertion points with the same shape as v.
///
public NDarray searchsorted(NDarray v, string side = "left", NDarray sorter = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
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>(py);
}
///
/// Return the elements of an array that satisfy some condition.
///
/// This is equivalent to np.compress(ravel(condition), ravel(arr)).
/// If
/// condition is boolean np.extract is equivalent to arr[condition].
///
/// Note that place does the exact opposite of extract.
///
///
/// Input array of the same size as condition.
///
///
/// Rank 1 array of values from arr where condition is True.
///
public NDarray extract(NDarray arr)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
arr,
});
var kwargs=new PyDict();
dynamic py = __self__.InvokeMethod("extract", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Counts the number of non-zero values in the array a.
///
/// 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.
/// Thus, this function
/// (recursively) counts how many elements in a (and in
/// sub-arrays thereof) have their __nonzero__() or __bool__()
/// method evaluated to True.
///
///
/// Axis or tuple of axes along which to count non-zeros.
///
/// Default is None, meaning that non-zeros will be counted
/// along a flattened version of a.
///
///
/// Number of non-zero values in the array along a given axis.
///
/// Otherwise, the total number of non-zero values in the array
/// is returned.
///
public NDarray count_nonzero(Axis axis)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
dynamic py = __self__.InvokeMethod("count_nonzero", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Counts the number of non-zero values in the array a.
///
/// 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.
/// Thus, this function
/// (recursively) counts how many elements in a (and in
/// sub-arrays thereof) have their __nonzero__() or __bool__()
/// method evaluated to True.
///
///
/// Number of non-zero values in the array along a given axis.
///
/// Otherwise, the total number of non-zero values in the array
/// is returned.
///
public int count_nonzero()
{
//auto-generated code, do not change
var __self__=self;
dynamic py = __self__.InvokeMethod("count_nonzero");
return ToCsharp(py);
}
///
/// Return minimum of an array or minimum along an axis, ignoring any NaNs.
///
/// When all-NaN slices are encountered a RuntimeWarning is raised and
/// Nan is returned for that slice.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
/// This means that Not a Number is not equivalent to infinity.
///
/// Positive infinity is treated as a very large number and negative
/// infinity is treated as a very small (i.e.
/// negative) number.
///
/// If the input has a integer type the function is equivalent to np.min.
///
///
/// Axis or axes along which the minimum is computed.
/// The default is to compute
/// the minimum of the flattened array.
///
///
/// Alternate output array in which to place the result.
/// The default
/// is None; if provided, it must have the same shape as the
/// expected output, but the type will be cast if necessary.
/// See
/// doc.ufuncs for details.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the original a.
///
/// If the value is anything but the default, then
/// keepdims will be passed through to the min method
/// of sub-classes of ndarray.
/// If the sub-classes methods
/// does not implement keepdims any exceptions will be raised.
///
///
/// An array with the same shape as a, with the specified axis
/// removed.
/// If a is a 0-d array, or if axis is None, an ndarray
/// scalar is returned.
/// The same dtype as a is returned.
///
public NDarray nanmin(Axis axis = null, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
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(py);
}
///
/// Return the maximum of an array or maximum along an axis, ignoring any
/// NaNs.
/// When all-NaN slices are encountered a RuntimeWarning is
/// raised and NaN is returned for that slice.
///
/// Notes
///
/// NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
/// (IEEE 754).
/// This means that Not a Number is not equivalent to infinity.
///
/// Positive infinity is treated as a very large number and negative
/// infinity is treated as a very small (i.e.
/// negative) number.
///
/// If the input has a integer type the function is equivalent to np.max.
///
///
/// Axis or axes along which the maximum is computed.
/// The default is to compute
/// the maximum of the flattened array.
///
///
/// Alternate output array in which to place the result.
/// The default
/// is None; if provided, it must have the same shape as the
/// expected output, but the type will be cast if necessary.
/// See
/// doc.ufuncs for details.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the original a.
///
/// If the value is anything but the default, then
/// keepdims will be passed through to the max method
/// of sub-classes of ndarray.
/// If the sub-classes methods
/// does not implement keepdims any exceptions will be raised.
///
///
/// An array with the same shape as a, with the specified axis removed.
///
/// If a is a 0-d array, or if axis is None, an ndarray scalar is
/// returned.
/// The same dtype as a is returned.
///
public NDarray nanmax(Axis axis = null, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
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(py);
}
///
/// Range of values (maximum - minimum) along an axis.
///
/// The name of the function comes from the acronym for ‘peak to peak’.
///
///
/// Axis along which to find the peaks.
/// By default, flatten the
/// array.
/// axis may be negative, in
/// which case it counts from the last to the first axis.
///
/// 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.
///
///
/// Alternative output array in which to place the result.
/// 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.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the input array.
///
/// 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.
/// If the
/// sub-class’ method does not implement keepdims any
/// exceptions will be raised.
///
///
/// A new array holding the result, unless out was
/// specified, in which case a reference to out is returned.
///
public NDarray ptp(Axis axis = null, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
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(py);
}
///
/// Compute the q-th percentile of the data along the specified axis.
///
/// Returns the q-th percentile(s) of the array elements.
///
/// 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.
/// 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.
/// 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.
///
///
/// Percentile or sequence of percentiles to compute, which must be between
/// 0 and 100 inclusive.
///
///
/// Axis or axes along which the percentiles are computed.
/// The
/// default is to compute the percentile(s) along a flattened
/// version of the array.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow the input array a to be modified by intermediate
/// calculations, to save memory.
/// In this case, the contents of the input
/// a after this function completes is undefined.
///
///
/// This optional parameter specifies the interpolation method to
/// use when the desired percentile lies between two data points
/// i < j:
///
///
/// If this is set to True, the axes which are reduced are left in
/// the result as dimensions with size one.
/// With this option, the
/// result will broadcast correctly against the original array a.
///
///
/// If q is a single percentile and axis=None, then the result
/// is a scalar.
/// If multiple percentiles are given, first axis of
/// the result corresponds to the percentiles.
/// The other axes are
/// the axes that remain after the reduction of a.
/// 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.
/// If out is specified, that array is
/// returned instead.
///
public NDarray percentile(NDarray q, Axis 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[]
{
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>(py);
}
///
/// Compute the q-th percentile of the data along the specified axis.
///
/// Returns the q-th percentile(s) of the array elements.
///
/// 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.
/// 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.
/// 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.
///
///
/// Percentile or sequence of percentiles to compute, which must be between
/// 0 and 100 inclusive.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow the input array a to be modified by intermediate
/// calculations, to save memory.
/// In this case, the contents of the input
/// a after this function completes is undefined.
///
///
/// This optional parameter specifies the interpolation method to
/// use when the desired percentile lies between two data points
/// i < j:
///
///
/// If q is a single percentile and axis=None, then the result
/// is a scalar.
/// If multiple percentiles are given, first axis of
/// the result corresponds to the percentiles.
/// The other axes are
/// the axes that remain after the reduction of a.
/// 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.
/// If out is specified, that array is
/// returned instead.
///
public double percentile(NDarray 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[]
{
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(py);
}
///
/// Compute the qth percentile of the data along the specified axis,
/// while ignoring nan values.
///
/// Returns the qth percentile(s) of the array elements.
///
/// 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.
/// 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.
/// 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.
///
///
/// Percentile or sequence of percentiles to compute, which must be between
/// 0 and 100 inclusive.
///
///
/// Axis or axes along which the percentiles are computed.
/// The
/// default is to compute the percentile(s) along a flattened
/// version of the array.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow the input array a to be modified by intermediate
/// calculations, to save memory.
/// In this case, the contents of the input
/// a after this function completes is undefined.
///
///
/// This optional parameter specifies the interpolation method to
/// use when the desired percentile lies between two data points
/// i < j:
///
///
/// If this is set to True, the axes which are reduced are left in
/// the result as dimensions with size one.
/// With this option, the
/// result will broadcast correctly against the original array a.
///
/// 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.
/// If the array is
/// a sub-class and mean does not have the kwarg keepdims this
/// will raise a RuntimeError.
///
///
/// If q is a single percentile and axis=None, then the result
/// is a scalar.
/// If multiple percentiles are given, first axis of
/// the result corresponds to the percentiles.
/// The other axes are
/// the axes that remain after the reduction of a.
/// 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.
/// If out is specified, that array is
/// returned instead.
///
public NDarray nanpercentile(NDarray q, Axis 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[]
{
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>(py);
}
///
/// Compute the qth percentile of the data along the specified axis,
/// while ignoring nan values.
///
/// Returns the qth percentile(s) of the array elements.
///
/// 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.
/// 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.
/// 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.
///
///
/// Percentile or sequence of percentiles to compute, which must be between
/// 0 and 100 inclusive.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow the input array a to be modified by intermediate
/// calculations, to save memory.
/// In this case, the contents of the input
/// a after this function completes is undefined.
///
///
/// This optional parameter specifies the interpolation method to
/// use when the desired percentile lies between two data points
/// i < j:
///
///
/// If q is a single percentile and axis=None, then the result
/// is a scalar.
/// If multiple percentiles are given, first axis of
/// the result corresponds to the percentiles.
/// The other axes are
/// the axes that remain after the reduction of a.
/// 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.
/// If out is specified, that array is
/// returned instead.
///
public double nanpercentile(NDarray 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[]
{
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(py);
}
///
/// Compute the q-th quantile of the data along the specified axis.
///
/// ..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.
/// 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.
/// 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.
///
///
/// Quantile or sequence of quantiles to compute, which must be between
/// 0 and 1 inclusive.
///
///
/// Axis or axes along which the quantiles are computed.
/// The
/// default is to compute the quantile(s) along a flattened
/// version of the array.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow the input array a to be modified by intermediate
/// calculations, to save memory.
/// In this case, the contents of the input
/// a after this function completes is undefined.
///
///
/// This optional parameter specifies the interpolation method to
/// use when the desired quantile lies between two data points
/// i < j:
///
///
/// If this is set to True, the axes which are reduced are left in
/// the result as dimensions with size one.
/// With this option, the
/// result will broadcast correctly against the original array a.
///
///
/// If q is a single quantile and axis=None, then the result
/// is a scalar.
/// If multiple quantiles are given, first axis of
/// the result corresponds to the quantiles.
/// The other axes are
/// the axes that remain after the reduction of a.
/// 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.
/// If out is specified, that array is
/// returned instead.
///
public NDarray quantile(NDarray q, Axis 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[]
{
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>(py);
}
///
/// Compute the q-th quantile of the data along the specified axis.
///
/// ..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.
/// 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.
/// 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.
///
///
/// Quantile or sequence of quantiles to compute, which must be between
/// 0 and 1 inclusive.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow the input array a to be modified by intermediate
/// calculations, to save memory.
/// In this case, the contents of the input
/// a after this function completes is undefined.
///
///
/// This optional parameter specifies the interpolation method to
/// use when the desired quantile lies between two data points
/// i < j:
///
///
/// If q is a single quantile and axis=None, then the result
/// is a scalar.
/// If multiple quantiles are given, first axis of
/// the result corresponds to the quantiles.
/// The other axes are
/// the axes that remain after the reduction of a.
/// 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.
/// If out is specified, that array is
/// returned instead.
///
public double quantile(NDarray 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[]
{
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(py);
}
///
/// Compute the qth quantile of the data along the specified axis,
/// while ignoring nan values.
///
/// Returns the qth quantile(s) of the array elements.
///
/// .. versionadded:: 1.15.0
///
///
/// Quantile or sequence of quantiles to compute, which must be between
/// 0 and 1 inclusive.
///
///
/// Axis or axes along which the quantiles are computed.
/// The
/// default is to compute the quantile(s) along a flattened
/// version of the array.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow the input array a to be modified by intermediate
/// calculations, to save memory.
/// In this case, the contents of the input
/// a after this function completes is undefined.
///
///
/// This optional parameter specifies the interpolation method to
/// use when the desired quantile lies between two data points
/// i < j:
///
///
/// If this is set to True, the axes which are reduced are left in
/// the result as dimensions with size one.
/// With this option, the
/// result will broadcast correctly against the original array a.
///
/// 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.
/// If the array is
/// a sub-class and mean does not have the kwarg keepdims this
/// will raise a RuntimeError.
///
///
/// If q is a single percentile and axis=None, then the result
/// is a scalar.
/// If multiple quantiles are given, first axis of
/// the result corresponds to the quantiles.
/// The other axes are
/// the axes that remain after the reduction of a.
/// 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.
/// If out is specified, that array is
/// returned instead.
///
public NDarray nanquantile(NDarray q, Axis 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[]
{
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>(py);
}
///
/// Compute the qth quantile of the data along the specified axis,
/// while ignoring nan values.
///
/// Returns the qth quantile(s) of the array elements.
///
/// .. versionadded:: 1.15.0
///
///
/// Quantile or sequence of quantiles to compute, which must be between
/// 0 and 1 inclusive.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow the input array a to be modified by intermediate
/// calculations, to save memory.
/// In this case, the contents of the input
/// a after this function completes is undefined.
///
///
/// This optional parameter specifies the interpolation method to
/// use when the desired quantile lies between two data points
/// i < j:
///
///
/// If q is a single percentile and axis=None, then the result
/// is a scalar.
/// If multiple quantiles are given, first axis of
/// the result corresponds to the quantiles.
/// The other axes are
/// the axes that remain after the reduction of a.
/// 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.
/// If out is specified, that array is
/// returned instead.
///
public double nanquantile(NDarray 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[]
{
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("nanquantile", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the median along the specified axis.
///
/// Returns the median of the array elements.
///
/// Notes
///
/// Given a vector V of length N, the median of V is the
/// middle value of a sorted copy of V, V_sorted - i
/// e., V_sorted[(N-1)/2], when N is odd, and the average of the
/// two middle values of V_sorted when N is even.
///
///
/// Axis or axes along which the medians are computed.
/// The default
/// is to compute the median along a flattened version of the array.
///
/// A sequence of axes is supported since version 1.9.0.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow use of memory of input array a for
/// calculations.
/// The input array will be modified by the call to
/// median.
/// This will save memory when you do not need to preserve
/// the contents of the input array.
/// Treat the input as undefined,
/// but it will probably be fully or partially sorted.
/// Default is
/// False.
/// If overwrite_input is True and a is not already an
/// ndarray, an error will be raised.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the original arr.
///
///
/// A new array holding the result.
/// If the input contains integers
/// or floats smaller than float64, then the output data-type is
/// np.float64. Otherwise, the data-type of the output is the
/// same as that of the input.
/// If out is specified, that array is
/// returned instead.
///
public NDarray median(Axis axis, NDarray @out = null, bool? overwrite_input = false, bool? keepdims = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
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 (keepdims!=false) kwargs["keepdims"]=ToPython(keepdims);
dynamic py = __self__.InvokeMethod("median", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Compute the median along the specified axis.
///
/// Returns the median of the array elements.
///
/// Notes
///
/// Given a vector V of length N, the median of V is the
/// middle value of a sorted copy of V, V_sorted - i
/// e., V_sorted[(N-1)/2], when N is odd, and the average of the
/// two middle values of V_sorted when N is even.
///
///
/// Alternative output array in which to place the result.
/// It must
/// have the same shape and buffer length as the expected output,
/// but the type (of the output) will be cast if necessary.
///
///
/// If True, then allow use of memory of input array a for
/// calculations.
/// The input array will be modified by the call to
/// median.
/// This will save memory when you do not need to preserve
/// the contents of the input array.
/// Treat the input as undefined,
/// but it will probably be fully or partially sorted.
/// Default is
/// False.
/// If overwrite_input is True and a is not already an
/// ndarray, an error will be raised.
///
///
/// A new array holding the result.
/// If the input contains integers
/// or floats smaller than float64, then the output data-type is
/// np.float64. Otherwise, the data-type of the output is the
/// same as that of the input.
/// If out is specified, that array is
/// returned instead.
///
public double median(NDarray @out = null, bool? overwrite_input = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (@out!=null) kwargs["out"]=ToPython(@out);
if (overwrite_input!=false) kwargs["overwrite_input"]=ToPython(overwrite_input);
dynamic py = __self__.InvokeMethod("median", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the weighted average along the specified axis.
///
///
/// Axis or axes along which to average a.
/// The default,
/// axis=None, will average over all of the elements of the input array.
///
/// If axis is negative it counts from the last to the first axis.
///
/// If axis is a tuple of ints, averaging is performed on all of the axes
/// specified in the tuple instead of a single axis or all the axes as
/// before.
///
///
/// An array of weights associated with the values in a.
/// Each value in
/// a contributes to the average according to its associated weight.
///
/// The weights array can either be 1-D (in which case its length must be
/// the size of a along the given axis) or of the same shape as a.
///
/// If weights=None, then all data in a are assumed to have a
/// weight equal to one.
///
///
/// Default is False.
/// If True, the tuple (average, sum_of_weights)
/// is returned, otherwise only the average is returned.
///
/// If weights=None, sum_of_weights is equivalent to the number of
/// elements over which the average is taken.
///
///
/// Return the average along the specified axis.
/// When returned is True,
/// return a tuple with the average as the first element and the sum
/// of the weights as the second element.
/// sum_of_weights is of the
/// same type as retval.
/// The result dtype follows a genereal pattern.
///
/// If weights is None, the result dtype will be that of a , or float64
/// if a is integral.
/// Otherwise, if weights is not None and a is non-
/// integral, the result type will be the type of lowest precision capable of
/// representing values of both a and weights.
/// If a happens to be
/// integral, the previous rules still applies but the result dtype will
/// at least be float64.
///
public NDarray average(Axis axis, NDarray weights = null, bool? returned = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (weights!=null) kwargs["weights"]=ToPython(weights);
if (returned!=false) kwargs["returned"]=ToPython(returned);
dynamic py = __self__.InvokeMethod("average", pyargs, kwargs);
return ToCsharp>(py);
}
///
/// Compute the weighted average along the specified axis.
///
///
/// An array of weights associated with the values in a.
/// Each value in
/// a contributes to the average according to its associated weight.
///
/// The weights array can either be 1-D (in which case its length must be
/// the size of a along the given axis) or of the same shape as a.
///
/// If weights=None, then all data in a are assumed to have a
/// weight equal to one.
///
///
/// Default is False.
/// If True, the tuple (average, sum_of_weights)
/// is returned, otherwise only the average is returned.
///
/// If weights=None, sum_of_weights is equivalent to the number of
/// elements over which the average is taken.
///
///
/// Return the average along the specified axis.
/// When returned is True,
/// return a tuple with the average as the first element and the sum
/// of the weights as the second element.
/// sum_of_weights is of the
/// same type as retval.
/// The result dtype follows a genereal pattern.
///
/// If weights is None, the result dtype will be that of a , or float64
/// if a is integral.
/// Otherwise, if weights is not None and a is non-
/// integral, the result type will be the type of lowest precision capable of
/// representing values of both a and weights.
/// If a happens to be
/// integral, the previous rules still applies but the result dtype will
/// at least be float64.
///
public double average(NDarray weights = null, bool? returned = false)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (weights!=null) kwargs["weights"]=ToPython(weights);
if (returned!=false) kwargs["returned"]=ToPython(returned);
dynamic py = __self__.InvokeMethod("average", pyargs, kwargs);
return ToCsharp(py);
}
///
/// Compute the arithmetic mean along the specified axis.
///
/// Returns the average of the array elements.
/// The average is taken over
/// the flattened array by default, otherwise over the specified axis.
///
/// float64 intermediate and return values are used for integer inputs.
///
/// Notes
///
/// The arithmetic mean is the sum of the elements along the axis divided
/// by the number of elements.
///
/// Note that for floating-point input, the mean is computed using the
/// same precision the input has.
/// Depending on the input data, this can
/// cause the results to be inaccurate, especially for float32 (see
/// example below).
/// Specifying a higher-precision accumulator using the
/// dtype keyword can alleviate this issue.
///
/// By default, float16 results are computed using float32 intermediates
/// for extra precision.
///
///
/// Axis or axes along which the means are computed.
/// The default is to
/// compute the mean of the flattened array.
///
/// If this is a tuple of ints, a mean is performed over multiple axes,
/// instead of a single axis or all the axes as before.
///
///
/// Type to use in computing the mean.
/// For integer inputs, the default
/// is float64; for floating point inputs, it is the same as the
/// input dtype.
///
///
/// Alternate output array in which to place the result.
/// The default
/// is None; if provided, it must have the same shape as the
/// expected output, but the type will be cast if necessary.
///
/// See doc.ufuncs for details.
///
///
/// If this is set to True, the axes which are reduced are left
/// in the result as dimensions with size one.
/// With this option,
/// the result will broadcast correctly against the input array.
///
/// If the default value is passed, then keepdims will not be
/// passed through to the mean method of sub-classes of
/// ndarray, however any non-default value will be.
/// If the
/// sub-class’ method does not implement keepdims any
/// exceptions will be raised.
///
///
/// If out=None, returns a new array containing the mean values,
/// otherwise a reference to the output array is returned.
///
public NDarray mean(Axis axis, Dtype dtype = null, NDarray @out = null, bool? keepdims = null)
{
//auto-generated code, do not change
var __self__=self;
var pyargs=ToTuple(new object[]
{
});
var kwargs=new PyDict();
if (axis!=null) kwargs["axis"]=ToPython(axis);
if (dtype!=null) kwargs["dtype"]=ToPython(dtype);
if (@out!=null) kwargs["out"]=ToPython(@out);
if (keepdims!=null) kwargs["keepdims"]=ToPython(keepdims);
dynamic py = __self__.InvokeMethod("mean", pyargs, kwargs);
return ToCsharp>(py);
}
///