Class np

Namespace

NumSharp

Assembly

NumSharp.dll

API bridge between NumSharp and Python NumPy

[SuppressMessage("ReSharper", "StaticMemberInitializerReferesToMemberBelow")]
public static class np

Inheritance

object

np

Inherited Members

object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

object.ToString()

Fields

bool

public static readonly Type @bool

Field Value

Type

bool8

public static readonly Type bool8

Field Value

Type

bool_

public static readonly Type bool_

Field Value

Type

byte

public static readonly Type @byte

Field Value

Type

cdouble

public static readonly Type cdouble

Field Value

Type

char

public static readonly Type @char

Field Value

Type

clongdouble

public static readonly Type clongdouble

Field Value

Type

complex128

public static readonly Type complex128

Field Value

Type

complex_

public static readonly Type complex_

Field Value

Type

decimal

public static readonly Type @decimal

Field Value

Type

double

public static readonly Type @double

Field Value

Type

float16

public static readonly Type float16

Field Value

Type

float32

public static readonly Type float32

Field Value

Type

float64

public static readonly Type float64

Field Value

Type

float_

public static readonly Type float_

Field Value

Type

half

public static readonly Type half

Field Value

Type

int0

public static readonly Type int0

Field Value

Type

int16

public static readonly Type int16

Field Value

Type

int32

public static readonly Type int32

Field Value

Type

int64

public static readonly Type int64

Field Value

Type

int8

public static readonly Type int8

Field Value

Type

int_

public static readonly Type int_

Field Value

Type

intc

public static readonly Type intc

Field Value

Type

intp

public static readonly Type intp

Field Value

Type

long

public static readonly Type @long

Field Value

Type

longlong

public static readonly Type longlong

Field Value

Type

newaxis

A convenient alias for None, useful for indexing arrays.

public static readonly Slice newaxis

Field Value

Slice

Remarks

https://numpy.org/doc/stable/user/basics.indexing.html

https://stackoverflow.com/questions/42190783/what-does-three-dots-in-python-mean-when-indexing-what-looks-like-a-number

sbyte

public static readonly Type @sbyte

Field Value

Type

short

public static readonly Type @short

Field Value

Type

single

public static readonly Type single

Field Value

Type

ubyte

public static readonly Type ubyte

Field Value

Type

uint

public static readonly Type @uint

Field Value

Type

uint0

public static readonly Type uint0

Field Value

Type

uint16

public static readonly Type uint16

Field Value

Type

uint32

public static readonly Type uint32

Field Value

Type

uint64

public static readonly Type uint64

Field Value

Type

uint8

public static readonly Type uint8

Field Value

Type

uintc

public static readonly Type uintc

Field Value

Type

uintp

public static readonly Type uintp

Field Value

Type

ulong

public static readonly Type @ulong

Field Value

Type

ulonglong

public static readonly Type ulonglong

Field Value

Type

ushort

public static readonly Type @ushort

Field Value

Type

Properties

BackendEngine

public static BackendType BackendEngine { get; set; }

Property Value

BackendType

Inf

public static double Inf { get; }

Property Value

double

Infinity

public static double Infinity { get; }

Property Value

double

NAN

public static double NAN { get; }

Property Value

double

NINF

public static double NINF { get; }

Property Value

double

NaN

public static double NaN { get; }

Property Value

double

PINF

public static double PINF { get; }

Property Value

double

chars

public static Type chars { get; }

Property Value

Type

complex64

NumSharp does not support complex64 (two 32-bit floats). The only complex type available is complex128 (two 64-bit floats, backed by Complex). Accessing this property throws NotSupportedException; use complex128 or complex_ instead.

public static Type complex64 { get; }

Property Value

Type

csingle

NumPy alias for complex64. Same as complex64 — throws because NumSharp does not support complex64.

public static Type csingle { get; }

Property Value

Type

e

public static double e { get; }

Property Value

double

euler_gamma

public static double euler_gamma { get; }

Property Value

double

inf

public static double inf { get; }

Property Value

double

infinity

public static double infinity { get; }

Property Value

double

infty

public static double infty { get; }

Property Value

double

nan

public static double nan { get; }

Property Value

double

pi

public static double pi { get; }

Property Value

double

random

public static NumPyRandom random { get; }

Property Value

NumPyRandom

Methods

LoadJagged(byte[])

public static Array LoadJagged(byte[] bytes)

Parameters

bytes byte[]

Returns

Array

LoadJagged(Stream, bool)

public static Array LoadJagged(Stream stream, bool trim = true)

Parameters

stream Stream

trim bool

Returns

Array

LoadJagged(string)

public static Array LoadJagged(string path)

Parameters

path string

Returns

Array

LoadJagged_Npz(byte[])

public static NpzDictionary<Array> LoadJagged_Npz(byte[] bytes)

Parameters

bytes byte[]

Returns

NpzDictionary<Array>

LoadJagged_Npz(Stream, bool)

public static NpzDictionary<Array> LoadJagged_Npz(Stream stream, bool trim = true)

Parameters

stream Stream

trim bool

Returns

NpzDictionary<Array>

LoadJagged_Npz(string)

public static NpzDictionary<Array> LoadJagged_Npz(string path)

Parameters

path string

Returns

NpzDictionary<Array>

LoadMatrix(byte[])

public static Array LoadMatrix(byte[] bytes)

Parameters

bytes byte[]

Returns

Array

LoadMatrix(Stream)

public static Array LoadMatrix(Stream stream)

Parameters

stream Stream

Returns

Array

LoadMatrix(string)

public static Array LoadMatrix(string path)

Parameters

path string

Returns

Array

LoadMatrix_Npz(byte[])

public static NpzDictionary<Array> LoadMatrix_Npz(byte[] bytes)

Parameters

bytes byte[]

Returns

NpzDictionary<Array>

LoadMatrix_Npz(Stream)

public static NpzDictionary<Array> LoadMatrix_Npz(Stream stream)

Parameters

stream Stream

Returns

NpzDictionary<Array>

LoadMatrix_Npz(string)

public static NpzDictionary<Array> LoadMatrix_Npz(string path)

Parameters

path string

Returns

NpzDictionary<Array>

Load_Npz<T>(byte[])

public static NpzDictionary<T> Load_Npz<T>(byte[] bytes) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

bytes byte[]

Returns

NpzDictionary<T>

Type Parameters

T

Load_Npz<T>(byte[], out T)

public static void Load_Npz<T>(byte[] bytes, out T value) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

bytes byte[]

value T

Type Parameters

T

Load_Npz<T>(Stream)

public static NpzDictionary<T> Load_Npz<T>(Stream stream) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

stream Stream

Returns

NpzDictionary<T>

Type Parameters

T

Load_Npz<T>(Stream, out NpzDictionary<T>)

public static NpzDictionary<T> Load_Npz<T>(Stream stream, out NpzDictionary<T> value) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

stream Stream

value NpzDictionary<T>

Returns

NpzDictionary<T>

Type Parameters

T

Load_Npz<T>(Stream, out T)

public static void Load_Npz<T>(Stream stream, out T value) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

stream Stream

value T

Type Parameters

T

Load_Npz<T>(string)

public static NpzDictionary<T> Load_Npz<T>(string path) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

path string

Returns

NpzDictionary<T>

Type Parameters

T

Load_Npz<T>(string, out NpzDictionary<T>)

public static NpzDictionary<T> Load_Npz<T>(string path, out NpzDictionary<T> value) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

path string

value NpzDictionary<T>

Returns

NpzDictionary<T>

Type Parameters

T

Load_Npz<T>(string, out T)

public static void Load_Npz<T>(string path, out T value) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

path string

value T

Type Parameters

T

Load<T>(byte[])

public static T Load<T>(byte[] bytes) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

bytes byte[]

Returns

T

Type Parameters

T

Load<T>(byte[], out T)

public static T Load<T>(byte[] bytes, out T value) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

bytes byte[]

value T

Returns

T

Type Parameters

T

Load<T>(Stream)

public static T Load<T>(Stream stream) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

stream Stream

Returns

T

Type Parameters

T

Load<T>(Stream, out T)

public static T Load<T>(Stream stream, out T value) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

stream Stream

value T

Returns

T

Type Parameters

T

Load<T>(string)

public static T Load<T>(string path) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

path string

Returns

T

Type Parameters

T

Load<T>(string, out T)

public static T Load<T>(string path, out T value) where T : class, ICloneable, IList, ICollection, IEnumerable, IStructuralComparable, IStructuralEquatable

Parameters

path string

value T

Returns

T

Type Parameters

T

Save(Array)

public static byte[] Save(Array array)

Parameters

array Array

Returns

byte[]

Save(Array, Stream)

public static ulong Save(Array array, Stream stream)

Parameters

array Array

stream Stream

Returns

ulong

Save(Array, string)

public static ulong Save(Array array, string path)

Parameters

array Array

path string

Returns

ulong

Save_Npz(Array, CompressionLevel)

public static byte[] Save_Npz(Array array, CompressionLevel compression = CompressionLevel.Fastest)

Parameters

array Array

compression CompressionLevel

Returns

byte[]

Save_Npz(Array, Stream, CompressionLevel, bool)

public static void Save_Npz(Array array, Stream stream, CompressionLevel compression = CompressionLevel.Fastest, bool leaveOpen = false)

Parameters

array Array

stream Stream

compression CompressionLevel

leaveOpen bool

Save_Npz(Array, string, CompressionLevel)

public static void Save_Npz(Array array, string path, CompressionLevel compression = CompressionLevel.Fastest)

Parameters

array Array

path string

compression CompressionLevel

Save_Npz(Dictionary<string, Array>, CompressionLevel)

public static byte[] Save_Npz(Dictionary<string, Array> arrays, CompressionLevel compression = CompressionLevel.Fastest)

Parameters

arrays Dictionary<string, Array>

compression CompressionLevel

Returns

byte[]

Save_Npz(Dictionary<string, Array>, Stream, CompressionLevel, bool)

public static void Save_Npz(Dictionary<string, Array> arrays, Stream stream, CompressionLevel compression = CompressionLevel.Fastest, bool leaveOpen = false)

Parameters

arrays Dictionary<string, Array>

stream Stream

compression CompressionLevel

leaveOpen bool

Save_Npz(Dictionary<string, Array>, string, CompressionLevel)

public static void Save_Npz(Dictionary<string, Array> arrays, string path, CompressionLevel compression = CompressionLevel.Fastest)

Parameters

arrays Dictionary<string, Array>

path string

compression CompressionLevel

abs(NDArray)

Calculate the absolute value element-wise.
np.abs is a shorthand for this function.

public static NDArray abs(NDArray a)

Parameters

a NDArray

Input value.

Returns

NDArray

An ndarray containing the absolute value of each element in x.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.absolute.html

abs(NDArray, NDArray, NDArray, NPTypeCode?)

Calculate the absolute value element-wise (alias of absolute(NDArray, NDArray, NDArray, NPTypeCode?)). Mirrors NumPy's ufunc signature: absolute(x, /, out=None, *, where=True, dtype=None).

public static NDArray abs(NDArray a, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Input value.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the input must be same_kind-castable to it; for complex input it selects the magnitude dtype (float kinds only).

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.absolute.html

abs(NDArray, NPTypeCode?)

Calculate the absolute value element-wise.
np.abs is a shorthand for this function.

public static NDArray abs(NDArray a, NPTypeCode? dtype)

Parameters

a NDArray

Input value.

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

An ndarray containing the absolute value of each element in x.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.absolute.html

abs(NDArray, Type)

Calculate the absolute value element-wise.
np.abs is a shorthand for this function.

public static NDArray abs(NDArray a, Type dtype)

Parameters

a NDArray

Input value.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

An ndarray containing the absolute value of each element in x.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.absolute.html

absolute(NDArray)

Calculate the absolute value element-wise.
np.abs is a shorthand for this function.

public static NDArray absolute(NDArray a)

Parameters

a NDArray

Input value.

Returns

NDArray

An ndarray containing the absolute value of each element in x.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.absolute.html

absolute(NDArray, NDArray, NDArray, NPTypeCode?)

Calculate the absolute value element-wise. Mirrors NumPy's ufunc signature: absolute(x, /, out=None, *, where=True, dtype=None).

public static NDArray absolute(NDArray a, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Input value.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the input must be same_kind-castable to it; for complex input it selects the magnitude dtype (float kinds only).

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.absolute.html

absolute(NDArray, NPTypeCode?)

Calculate the absolute value element-wise.
np.abs is a shorthand for this function.

public static NDArray absolute(NDArray a, NPTypeCode? dtype)

Parameters

a NDArray

Input value.

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

An ndarray containing the absolute value of each element in x.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.absolute.html

absolute(NDArray, Type)

Calculate the absolute value element-wise.
np.abs is a shorthand for this function.

public static NDArray absolute(NDArray a, Type dtype)

Parameters

a NDArray

Input value.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

An ndarray containing the absolute value of each element in x.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.absolute.html

add(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

public static NDArray add(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

x2 NDArray

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.add.html

all(NDArray)

Test whether all array elements evaluate to True.

public static bool all(NDArray a)

Parameters

a NDArray

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

Returns

bool

True if all elements evaluate to True (non-zero).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.all.html

all(NDArray, bool)

Test whether all array elements evaluate to True, optionally keeping reduced dimensions. Reduces over all axes (axis = None semantics).

public static NDArray<bool> all(NDArray nd, bool keepdims)

Parameters

nd NDArray

Input array.

keepdims bool

If True, the result is broadcast-compatible with the input (every dimension becomes size 1). Otherwise the result is a 0-d array.

Returns

NDArray<bool>

A new boolean ndarray.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.all.html

all(NDArray, int, bool)

Test whether all array elements along a given axis evaluate to True.

public static NDArray<bool> all(NDArray nd, int axis, bool keepdims = false)

Parameters

nd NDArray

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

axis int

Axis along which a logical AND reduction is performed.

keepdims bool

If True, the reduced axes are left in the result as dimensions with size one.

Returns

NDArray<bool>

A new boolean ndarray is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.all.html

all(NDArray, int[], NDArray, bool, NDArray)

Tuple-axis variant of the full np.all overload (with out and where).

public static NDArray all(NDArray a, int[] axis, NDArray @out, bool keepdims = false, NDArray where = null)

Parameters

a NDArray

Input array.

axis int[]

Axes along which to reduce.

out NDArray

Destination array. Its dtype is preserved.

keepdims bool

If True, reduced axes are left as size-one dimensions.

where NDArray

Boolean mask, broadcastable against a.

Returns

NDArray

The reduced array, or out when supplied.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.all.html

all(NDArray, int[], bool)

Test whether all array elements along the given axes evaluate to True. Multiple axes can be specified by passing an array of ints.

public static NDArray<bool> all(NDArray nd, int[] axis, bool keepdims = false)

Parameters

nd NDArray

Input array.

axis int[]

Tuple of axes along which a logical AND reduction is performed. An empty array returns the input cast to bool (no reduction).

keepdims bool

If True, the reduced axes are left in the result as dimensions with size one.

Returns

NDArray<bool>

A new boolean ndarray is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.all.html

all(NDArray, int?, NDArray, bool, NDArray)

Test whether all array elements along the given axis evaluate to True, with optional out= destination and where= mask. Matches NumPy 2.x: all(a, axis=None, out=None, keepdims=False, *, where=True).

public static NDArray all(NDArray a, int? axis = null, NDArray @out = null, bool keepdims = false, NDArray where = null)

Parameters

a NDArray

Input array.

axis int?

Axis along which to reduce. Pass null for axis=None (all axes).

out NDArray

Destination array. Its dtype is preserved (e.g. an int out stores 0/1 instead of bool). Pass null to allocate a fresh boolean array.

keepdims bool

If True, the reduced axes are left as dimensions with size one.

where NDArray

Boolean (or numeric-treated-as-bool) mask, broadcastable against a. Elements where where=False are excluded from the reduction and contribute the identity value (True for all). Pass null for no mask.

Returns

NDArray

The reduced array, or out when supplied.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.all.html

allclose(NDArray, NDArray, double, double, bool)

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.

public static bool allclose(NDArray a, NDArray b, double rtol = 1E-05, double atol = 1E-08, bool equal_nan = false)

Parameters

a NDArray

Input array to compare with b

b NDArray

Input array to compare with a.

rtol double

The relative tolerance parameter(see Notes)

atol double

The absolute tolerance parameter(see Notes)

equal_nan bool

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

bool

amax(NDArray, int?, bool, Type)

Return the maximum of an array or maximum along an axis.

public static NDArray amax(NDArray a, int? axis = null, bool keepdims = false, Type dtype = null)

Parameters

a NDArray

axis int?

Axis or axes along which to operate.

keepdims bool

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.

dtype Type

the type expected as a return, null will remain the same dtype.

Returns

NDArray

Maximum of a. If axis is None, the result is a scalar value. If axis is given, the result is an array of dimension a.ndim - 1.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.amax.html

amax<T>(NDArray)

Return the maximum of an array or maximum along an axis.

public static T amax<T>(NDArray a) where T : unmanaged

Parameters

a NDArray

Returns

T

Maximum of a. If axis is None, the result is a scalar value. If axis is given, the result is an array of dimension a.ndim - 1.

Type Parameters

T

the type expected as a return, cast is performed if necessary.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.amax.html

amin(NDArray, int?, bool, Type)

Return the minimum of an array or minimum along an axis.

public static NDArray amin(NDArray a, int? axis = null, bool keepdims = false, Type dtype = null)

Parameters

a NDArray

Input data.

axis int?

Axis or axes along which to operate.

keepdims bool

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.

dtype Type

the type expected as a return, null will remain the same dtype.

Returns

NDArray

Minimum of a. If axis is None, the result is a scalar value. If axis is given, the result is an array of dimension a.ndim - 1.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.amin.html

amin<T>(NDArray)

Return the minimum of an array or minimum along an axis.

public static T amin<T>(NDArray a) where T : unmanaged

Parameters

a NDArray

Input data.

Returns

T

Minimum of a. If axis is None, the result is a scalar value. If axis is given, the result is an array of dimension a.ndim - 1.

Type Parameters

T

the type expected as a return, cast is performed if necessary.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.amin.html

any(NDArray)

Test whether any array element evaluates to True.

public static bool any(NDArray a)

Parameters

a NDArray

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

Returns

bool

True if any element evaluates to True (non-zero).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.any.html

any(NDArray, bool)

Test whether any array element evaluates to True, optionally keeping reduced dimensions. Reduces over all axes (axis = None semantics).

public static NDArray<bool> any(NDArray nd, bool keepdims)

Parameters

nd NDArray

Input array.

keepdims bool

If True, the result has all dimensions as size 1 (broadcast-compatible with the input). Otherwise the result is a 0-d array.

Returns

NDArray<bool>

A new boolean ndarray.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.any.html

any(NDArray, int, bool)

Test whether any array element along a given axis evaluates to True.

public static NDArray<bool> any(NDArray nd, int axis, bool keepdims = false)

Parameters

nd NDArray

Input array.

axis int

Axis along which a logical OR reduction is performed.

keepdims bool

If True, the reduced axes are left in the result as dimensions with size one.

Returns

NDArray<bool>

A new boolean ndarray is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.any.html

any(NDArray, int[], NDArray, bool, NDArray)

Tuple-axis variant of the full np.any overload (with out and where).

public static NDArray any(NDArray a, int[] axis, NDArray @out, bool keepdims = false, NDArray where = null)

Parameters

a NDArray

Input array.

axis int[]

Axes along which to reduce.

out NDArray

Destination array. Its dtype is preserved.

keepdims bool

If True, reduced axes are left as size-one dimensions.

where NDArray

Boolean mask, broadcastable against a.

Returns

NDArray

The reduced array, or out when supplied.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.any.html

any(NDArray, int[], bool)

Test whether any array element along the given axes evaluates to True. Multiple axes can be specified by passing an array of ints.

public static NDArray<bool> any(NDArray nd, int[] axis, bool keepdims = false)

Parameters

nd NDArray

Input array.

axis int[]

Tuple of axes along which a logical OR reduction is performed. An empty array returns the input cast to bool (no reduction).

keepdims bool

If True, the reduced axes are left in the result as dimensions with size one.

Returns

NDArray<bool>

A new boolean ndarray is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.any.html

any(NDArray, int?, NDArray, bool, NDArray)

Test whether any array element along the given axis evaluates to True, with optional out= destination and where= mask. Matches NumPy 2.x: any(a, axis=None, out=None, keepdims=False, *, where=True).

public static NDArray any(NDArray a, int? axis = null, NDArray @out = null, bool keepdims = false, NDArray where = null)

Parameters

a NDArray

Input array.

axis int?

Axis along which to reduce. Pass null for axis=None (all axes).

out NDArray

Destination array. Its dtype is preserved. Pass null to allocate fresh.

keepdims bool

If True, the reduced axes are left as size-one dimensions.

where NDArray

Boolean (or numeric-treated-as-bool) mask, broadcastable against a. Elements where where=False are excluded from the reduction and contribute the identity value (False for any). Pass null for no mask.

Returns

NDArray

The reduced array, or out when supplied.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.any.html

append(NDArray, NDArray, int?)

Append values to the end of arr.

public static NDArray append(NDArray arr, NDArray values, int? axis = null)

Parameters

arr NDArray

Input array.

values NDArray

Values to append. Shape must match arr on all dimensions except axis when axis is given; otherwise it is flattened.

axis int?

Axis along which to append. null (default) flattens both arr and values to 1-D before concatenation.

Returns

NDArray

A new array with values appended to arr along axis.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.append.html

append(NDArray, object, int?)

Scalar / generic-value overload that wraps the value via asanyarray(in object, Type) before delegating. Matches NumPy's np.append([1,2,3], 4) idiom — the scalar is auto-coerced to a 0-D ndarray (whose ravel is shape (1,)).

public static NDArray append(NDArray arr, object values, int? axis = null)

Parameters

arr NDArray

values object

axis int?

Returns

NDArray

arange(double)

Return evenly spaced values within a given interval.

public static NDArray arange(double stop)

Parameters

stop double

End of interval (exclusive).

Returns

NDArray

Array of evenly spaced double values.

arange(double, NPTypeCode)

Return evenly spaced values within a given interval.

public static NDArray arange(double stop, NPTypeCode dtype)

Parameters

stop double

End of interval (exclusive).

dtype NPTypeCode

The type of the output array.

Returns

NDArray

Array of evenly spaced values from 0 to stop-1.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arange.html

arange(double, double, NPTypeCode)

Return evenly spaced values within a given interval.

public static NDArray arange(double start, double stop, NPTypeCode dtype)

Parameters

start double

Start of interval (inclusive).

stop double

End of interval (exclusive).

dtype NPTypeCode

The type of the output array.

Returns

NDArray

Array of evenly spaced values.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arange.html

arange(double, double, double)

Return evenly spaced values within a given interval.

public static NDArray arange(double start, double stop, double step = 1)

Parameters

start double

Start of interval (inclusive).

stop double

End of interval (exclusive).

step double

Spacing between values. Default is 1.

Returns

NDArray

Array of evenly spaced double values.

arange(double, double, double, NPTypeCode)

Return evenly spaced values within a given interval.

Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop).

public static NDArray arange(double start, double stop, double step, NPTypeCode dtype)

Parameters

start double

Start of interval. The interval includes this value.

stop double

End of interval. The interval does not include this value.

step double

Spacing between values. Default is 1.

dtype NPTypeCode

The type of the output array. If Empty, infers from inputs (int64 for integers, float64 for floats).

Returns

NDArray

Array of evenly spaced values.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arange.html

arange(double, double, double, Type)

Return evenly spaced values within a given interval.

Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop).

public static NDArray arange(double start, double stop, double step, Type dtype)

Parameters

start double

Start of interval. The interval includes this value.

stop double

End of interval. The interval does not include this value.

step double

Spacing between values. Default is 1.

dtype Type

The type of the output array. If null, infers from inputs (int64 for integers, float64 for floats).

Returns

NDArray

Array of evenly spaced values.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arange.html

arange(double, double, Type)

Return evenly spaced values within a given interval.

public static NDArray arange(double start, double stop, Type dtype)

Parameters

start double

Start of interval (inclusive).

stop double

End of interval (exclusive).

dtype Type

The type of the output array.

Returns

NDArray

Array of evenly spaced values.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arange.html

arange(double, Type)

Return evenly spaced values within a given interval.

public static NDArray arange(double stop, Type dtype)

Parameters

stop double

End of interval (exclusive).

dtype Type

The type of the output array.

Returns

NDArray

Array of evenly spaced values from 0 to stop-1.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arange.html

arange(int)

Return evenly spaced values within a given interval.

public static NDArray arange(int stop)

Parameters

stop int

End of interval (exclusive).

Returns

NDArray

Array of evenly spaced int64 values.

Remarks

NumPy 2.x returns int64 for integer arange.

arange(int, int, int)

Return evenly spaced values within a given interval.

public static NDArray arange(int start, int stop, int step = 1)

Parameters

start int

Start of interval (inclusive).

stop int

End of interval (exclusive).

step int

Spacing between values. Default is 1.

Returns

NDArray

Array of evenly spaced int64 values.

Remarks

NumPy 2.x returns int64 for integer arange.

arange(long)

Return evenly spaced values within a given interval.

public static NDArray arange(long stop)

Parameters

stop long

End of interval (exclusive).

Returns

NDArray

Array of evenly spaced int64 values.

Remarks

NumPy 2.x returns int64 for integer arange.

arange(long, long, long)

Return evenly spaced values within a given interval.

public static NDArray arange(long start, long stop, long step = 1)

Parameters

start long

Start of interval (inclusive).

stop long

End of interval (exclusive).

step long

Spacing between values. Default is 1.

Returns

NDArray

Array of evenly spaced int64 values.

Remarks

NumPy 2.x returns int64 for integer arange.

arange(float)

Return evenly spaced values within a given interval.

public static NDArray arange(float stop)

Parameters

stop float

End of interval (exclusive).

Returns

NDArray

Array of evenly spaced float values.

arange(float, float, float)

Return evenly spaced values within a given interval.

public static NDArray arange(float start, float stop, float step = 1)

Parameters

start float

Start of interval (inclusive).

stop float

End of interval (exclusive).

step float

Spacing between values. Default is 1.

Returns

NDArray

Array of evenly spaced float values.

arccos(NDArray, NDArray, NDArray, NPTypeCode?)

Trigonometric inverse cosine, element-wise.
The inverse of cos so that, if y = cos(x), then x = arccos(y).

public static NDArray arccos(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arccos.html

arccos(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray arccos(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arccos.html

arccos(NDArray, Type)

Trigonometric inverse cosine, element-wise.
The inverse of cos so that, if y = cos(x), then x = arccos(y).

public static NDArray arccos(NDArray x, Type dtype)

Parameters

x NDArray

Input array.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arccos.html

arcsin(NDArray, NDArray, NDArray, NPTypeCode?)

Inverse sine, element-wise.
The convention is to return the angle z whose real part lies in [-pi/2, pi/2].

public static NDArray arcsin(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arcsin.html

arcsin(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray arcsin(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arcsin.html

arcsin(NDArray, Type)

Inverse sine, element-wise.
The convention is to return the angle z whose real part lies in [-pi/2, pi/2].

public static NDArray arcsin(NDArray x, Type dtype)

Parameters

x NDArray

Input array.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arcsin.html

arctan(NDArray, NDArray, NDArray, NPTypeCode?)

Compute trigonometric inverse tangent, element-wise.
The inverse of tan, so that if y = tan(x) then x = arctan(y).

public static NDArray arctan(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

Return 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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arctan.html

arctan(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray arctan(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arctan.html

arctan(NDArray, Type)

Compute trigonometric inverse tangent, element-wise.
The inverse of tan, so that if y = tan(x) then x = arctan(y).

public static NDArray arctan(NDArray x, Type dtype)

Parameters

x NDArray

Input array.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

Return 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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arctan.html

arctan2(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Compute Element-wise arc tangent of x1/x2 choosing the quadrant correctly.
By IEEE convention, this function is defined for x2 = +/-0 and for either or both of x1 and x2 = +/-inf

public static NDArray arctan2(NDArray y, NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

y NDArray

x NDArray

Input array y-coordinates.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The Array of angles in radians, in the range [-pi, pi]. This is a scalar if both x1 and x2 are scalars.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arctan2.html

arctan2(NDArray, NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray arctan2(NDArray y, NDArray x, NPTypeCode dtype)

Parameters

y NDArray

x NDArray

dtype NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arctan2.html

arctan2(NDArray, NDArray, Type)

Compute Element-wise arc tangent of x1/x2 choosing the quadrant correctly.
By IEEE convention, this function is defined for x2 = +/-0 and for either or both of x1 and x2 = +/-inf

public static NDArray arctan2(NDArray y, NDArray x, Type dtype)

Parameters

y NDArray

x NDArray

Input array y-coordinates.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The Array of angles in radians, in the range [-pi, pi]. This is a scalar if both x1 and x2 are scalars.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.arctan2.html

are_broadcastable(NDArray, NDArray)

Tests if these two two arrays are broadcastable against each other.

public static bool are_broadcastable(NDArray lhs, NDArray rhs)

Parameters

lhs NDArray

An array to test for broadcasting.

rhs NDArray

An array to test for broadcasting.

Returns

bool

True if these can be broadcasted against each other.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_arrays.html

are_broadcastable(params NDArray[])

Tests if these two two arrays are broadcastable against each other.

public static bool are_broadcastable(params NDArray[] ndArrays)

Parameters

ndArrays NDArray[]

The arrays to test for broadcasting.

Returns

bool

True if these can be broadcasted against each other.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_arrays.html

are_broadcastable(params Shape[])

Tests if these two two arrays are broadcastable against each other.

public static bool are_broadcastable(params Shape[] shapes)

Parameters

shapes Shape[]

The shapes to test for broadcasting.

Returns

bool

True if these can be broadcasted against each other.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_arrays.html

are_broadcastable(params int[][])

Tests if these two two arrays are broadcastable against each other.

public static bool are_broadcastable(params int[][] shapes)

Parameters

shapes int[][]

The shapes to test for broadcasting.

Returns

bool

True if these can be broadcasted against each other.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_arrays.html

are_broadcastable(long[], long[])

Tests if these two shapes are broadcastable against each other.

public static bool are_broadcastable(long[] shape1, long[] shape2)

Parameters

shape1 long[]

First shape to test.

shape2 long[]

Second shape to test.

Returns

bool

True if these can be broadcasted against each other.

Remarks

https://docs.scipy.org/doc/numpy/reference/generated/numpy.broadcast_arrays.html

argmax(NDArray)

Returns the index of the maximum value.

public static long argmax(NDArray a)

Parameters

a NDArray

Input array.

Returns

long

Index of the maximum value in the flattened array.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.argmax.html

argmax(NDArray, int, bool)

Returns the indices of the maximum values along an axis.

public static NDArray argmax(NDArray a, int axis, bool keepdims = false)

Parameters

a NDArray

Input array.

axis int

By default, the index is into the flattened array, otherwise along the specified axis.

keepdims bool

If this is set to True, the axes which are reduced are left in the result as dimensions with size one.

Returns

NDArray

Array of indices into the array. It has the same shape as a.shape with the dimension along axis removed (unless keepdims is True).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.argmax.html

argmin(NDArray)

Returns the index of the minimum value.

public static long argmin(NDArray a)

Parameters

a NDArray

Input array.

Returns

long

Index of the minimum value in the flattened array.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.argmin.html

argmin(NDArray, int, bool)

Returns the indices of the minimum values along an axis.

public static NDArray argmin(NDArray a, int axis, bool keepdims = false)

Parameters

a NDArray

Input array.

axis int

By default, the index is into the flattened array, otherwise along the specified axis.

keepdims bool

If this is set to True, the axes which are reduced are left in the result as dimensions with size one.

Returns

NDArray

Array of indices into the array. It has the same shape as a.shape with the dimension along axis removed (unless keepdims is True).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.argmin.html

argsort(NDArray, int?)

Returns the indices that would sort nd along axis (default last; null flattens). Returns int64 indices. NumPy np.argsort.

public static NDArray argsort(NDArray nd, int? axis = -1)

Parameters

nd NDArray

axis int?

Returns

NDArray

argsort<T>(NDArray, int)

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.

public static NDArray argsort<T>(NDArray nd, int axis = -1) where T : unmanaged

Parameters

nd NDArray

axis int

Returns

NDArray

Type Parameters

T

argwhere(NDArray)

Find the indices of array elements that are non-zero, grouped by element.

public static NDArray argwhere(NDArray a)

Parameters

a NDArray

Input array.

Returns

NDArray

Indices of elements that are non-zero, grouped per element. The result is a 2-D array of shape (N, a.ndim) where N is the number of non-zero elements. Each row contains the coordinates of one non-zero element. Result dtype is int64. For 0-d input, returns shape (1, 0) when the value is truthy and (0, 0) otherwise. For empty input of shape (0, d1, ..., dn), returns shape (0, ndim).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.argwhere.html Equivalent to np.transpose(np.nonzero(a)) with a special case for 0-d input. Distinct from nonzero(NDArray) which returns a tuple of column arrays.

around(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload. NumPy's np.round/np.around accept out= only (they are functions, not ufuncs — no where=/dtype= kwargs; probed 2.4.2).

public static NDArray around(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

dtype NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

around(NDArray, int, NDArray)

Evenly round to the given number of decimals.

public static NDArray around(NDArray x, int decimals = 0, NDArray @out = null)

Parameters

x NDArray

Input array

decimals int

out NDArray

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

around(NDArray, int, NPTypeCode)

Evenly round to the given number of decimals.

public static NDArray around(NDArray x, int decimals, NPTypeCode dtype)

Parameters

x NDArray

Input array

decimals int

Number of decimal places to round to

dtype NPTypeCode

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

around(NDArray, int, Type)

Evenly round to the given number of decimals.

public static NDArray around(NDArray x, int decimals, Type dtype)

Parameters

x NDArray

Input array

decimals int

Number of decimal places to round to

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

around(NDArray, Type)

Evenly round to the given number of decimals.

public static NDArray around(NDArray x, Type dtype)

Parameters

x NDArray

Input array

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

array(NDArray, bool)

Create an array from an existing NDArray. Matches NumPy's default np.array(a) which always copies (NumPy 2.x: copy=True by default).

public static NDArray array(NDArray nd, bool copy = true)

Parameters

nd NDArray

Source array.

copy bool

When true (default) the source storage is cloned; when false the storage is shared (alias). For "copy only if needed" semantics use asarray(NDArray, Type, char, bool?, NDArray, string).

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array(Array, Type, int, bool, char)

Creates an NDArray from an array with an unknown size or dtype.

[SuppressMessage("ReSharper", "InvalidXmlDocComment")]
public static NDArray array(Array array, Type dtype = null, int ndmin = 1, bool copy = true, char order = 'C')

Parameters

array Array

dtype Type

ndmin int

Specifies the minimum number of dimensions that the resulting array should have. Ones will be pre-pended to the shape as needed to meet this requirement.

copy bool

Always copies if the array is larger than 1-d.

order char

Memory layout: 'C' (row-major, default), 'F' (column-major), 'A'/'K' (resolved from source).

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array(string)

Create a vector NDArray of dtype char.

public static NDArray array(string chars)

Parameters

chars string

Returns

NDArray

array(string[])

Create a vector ndarray of type <xref href="System.String" data-throw-if-not-resolved="false"></xref>.

Encode string array. format: [numOfRow lenOfRow1 lenOfRow2 contents] sample: [2 2 4 aacccc]

public static NDArray array(string[] strArray)

Parameters

strArray string[]

Returns

NDArray

array2string(NDArray, int?, int?, bool?, string, string, int?, int?, char?, string, string)

Return a string representation of an array (NumPy's np.array2string).

public static string array2string(NDArray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null, string separator = " ", string prefix = "", int? threshold = null, int? edgeitems = null, char? sign = null, string floatmode = null, string suffix = "")

Parameters

a NDArray

Input array.

max_line_width int?

Inserts newlines if text is longer than this. Defaults to the current linewidth.

precision int?

Floating point precision. Defaults to the current precision.

suppress_small bool?

Represent numbers very close to zero as zero. Defaults to the current option.

separator string

Inserted between elements (default " ").

prefix string

Used to align/wrap the output; its content is not included.

threshold int?

Total number of elements which trigger summarization.

edgeitems int?

Number of items at the beginning and end of each dimension in summary.

sign char?

'-', '+', or ' '.

floatmode string

One of "fixed", "unique", "maxprec", "maxprec_equal".

suffix string

Used to wrap the output; its content is not included.

Returns

string

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array2string.html

array_equal(NDArray, NDArray)

True if two arrays have the same shape and elements, False otherwise.

public static bool array_equal(NDArray a, NDArray b)

Parameters

a NDArray

Input array.

b NDArray

Input array.

Returns

bool

Returns True if the arrays are equal.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array_equal.html

array_repr(NDArray, int?, int?, bool?)

Return the string representation of an array (NumPy's np.array_repr).

public static string array_repr(NDArray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null)

Parameters

a NDArray

max_line_width int?

precision int?

suppress_small bool?

Returns

string

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array_repr.html

array_split(NDArray, int, int)

Split an array into multiple sub-arrays.

public static NDArray[] array_split(NDArray ary, int indices_or_sections, int axis = 0)

Parameters

ary NDArray

indices_or_sections int

axis int

Returns

NDArray[]

Remarks

The only difference between split and array_split is that array_split allows indices_or_sections to be an integer that does not equally divide the axis. https://numpy.org/doc/stable/reference/generated/numpy.array_split.html

array_split(NDArray, int[], int)

Split an array into multiple sub-arrays.

public static NDArray[] array_split(NDArray ary, int[] indices, int axis = 0)

Parameters

ary NDArray

indices int[]

axis int

Returns

NDArray[]

array_split(NDArray, long[], int)

Split an array into multiple sub-arrays.

public static NDArray[] array_split(NDArray ary, long[] indices, int axis = 0)

Parameters

ary NDArray

indices long[]

axis int

Returns

NDArray[]

array_str(NDArray, int?, int?, bool?)

Return a string representation of the data in an array (NumPy's np.array_str).

public static string array_str(NDArray a, int? max_line_width = null, int? precision = null, bool? suppress_small = null)

Parameters

a NDArray

max_line_width int?

precision int?

suppress_small bool?

Returns

string

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array_str.html

array<T>(IEnumerable<T>)

Creates a Vector NDArray from given data.

public static NDArray array<T>(IEnumerable<T> data) where T : unmanaged

Parameters

data IEnumerable<T>

The enumeration of data to create NDArray from.

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html
Always performs a copy.

array<T>(IEnumerable<T>, int)

Creates a Vector NDArray from given data.

public static NDArray array<T>(IEnumerable<T> data, int size) where T : unmanaged

Parameters

data IEnumerable<T>

The enumeration of data to create NDArray from.

size int

Maximum number of items to read from data.

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html
Always performs a copy.
size can be used to limit the amount of items to read form data. Reading stops on either size or data ends.

array<T>(IEnumerable<T>, long)

Creates a Vector NDArray from given data.

public static NDArray array<T>(IEnumerable<T> data, long size) where T : unmanaged

Parameters

data IEnumerable<T>

The enumeration of data to create NDArray from.

size long

Maximum number of items to read from data.

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html
Always performs a copy.
size can be used to limit the amount of items to read form data. Reading stops on either size or data ends.

array<T>(T)

Creates a scalar (0-dimensional) NDArray from a single value.

public static NDArray array<T>(T scalar) where T : unmanaged

Parameters

scalar T

The scalar value.

Returns

NDArray

A 0-dimensional NDArray containing the scalar value.

Type Parameters

T

The type of the value, must be compliant to numpy's supported dtypes.

Remarks

NumPy: np.array(42) creates a 0-dimensional array with shape (). https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,,,,,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,,,,,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,,,,,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,,,,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,,,,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,,,,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,,,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,,,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,,,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,,] data, bool copy = true) where T : unmanaged

Parameters

data T[,,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,], NPTypeCode)

Creates an NDArray from given data with specified dtype.

public static NDArray array<T>(T[,] data, NPTypeCode dtype) where T : unmanaged

Parameters

data T[,]

The array to create NDArray from.

dtype NPTypeCode

The desired data type code for the array. If different from T, the data will be cast.

Returns

NDArray

An NDArray with the data cast to the specified dtype.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[,] data, bool copy = true) where T : unmanaged

Parameters

data T[,]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[,], Type)

Creates an NDArray from given data with specified dtype.

public static NDArray array<T>(T[,] data, Type dtype) where T : unmanaged

Parameters

data T[,]

The array to create NDArray from.

dtype Type

The desired data type for the array. If different from T, the data will be cast.

Returns

NDArray

An NDArray with the data cast to the specified dtype.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(params T[])

Creates a Vector NDArray from given data.

public static NDArray array<T>(params T[] data) where T : unmanaged

Parameters

data T[]

The array to create NDArray from.

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html
Always performs a copy.

array<T>(T[], NPTypeCode)

Creates a Vector NDArray from given data with specified dtype.

public static NDArray array<T>(T[] data, NPTypeCode dtype) where T : unmanaged

Parameters

data T[]

The array to create NDArray from.

dtype NPTypeCode

The desired data type code for the array. If different from T, the data will be cast.

Returns

NDArray

An NDArray with the data cast to the specified dtype.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[], bool)

Creates an NDArray from given data.

public static NDArray array<T>(T[] data, bool copy) where T : unmanaged

Parameters

data T[]

The array to create NDArray from.

copy bool

If true then the array will be copied to a newly allocated memory.
If false then the array will be pinned by calling Alloc(object).

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[], Type)

Creates a Vector NDArray from given data with specified dtype.

public static NDArray array<T>(T[] data, Type dtype) where T : unmanaged

Parameters

data T[]

The array to create NDArray from.

dtype Type

The desired data type for the array. If different from T, the data will be cast.

Returns

NDArray

An NDArray with the data cast to the specified dtype.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html

array<T>(T[][])

Creates an NDArray from given data.

[SuppressMessage("ReSharper", "SuggestVarOrType_SimpleTypes")]
[SuppressMessage("ReSharper", "SuggestVarOrType_Elsewhere")]
public static NDArray array<T>(T[][] data) where T : unmanaged

Parameters

data T[][]

The array to create NDArray from. Shape is taken from the first item of each array/nested array.

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html
Always performs a copy.

array<T>(T[][][])

Creates an NDArray from given data.

[SuppressMessage("ReSharper", "SuggestVarOrType_SimpleTypes")]
[SuppressMessage("ReSharper", "SuggestVarOrType_Elsewhere")]
public static NDArray array<T>(T[][][] data) where T : unmanaged

Parameters

data T[][][]

The array to create NDArray from. Shape is taken from the first item of each array/nested array.

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html
Always performs a copy.

array<T>(T[][][][])

Creates an NDArray from given data.

[SuppressMessage("ReSharper", "SuggestVarOrType_SimpleTypes")]
[SuppressMessage("ReSharper", "SuggestVarOrType_Elsewhere")]
public static NDArray array<T>(T[][][][] data) where T : unmanaged

Parameters

data T[][][][]

The array to create NDArray from. Shape is taken from the first item of each array/nested array.

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html
Always performs a copy.

array<T>(T[][][][][])

Creates an NDArray from given data.

[SuppressMessage("ReSharper", "SuggestVarOrType_SimpleTypes")]
[SuppressMessage("ReSharper", "SuggestVarOrType_Elsewhere")]
public static NDArray array<T>(T[][][][][] data) where T : unmanaged

Parameters

data T[][][][][]

The array to create NDArray from. Shape is taken from the first item of each array/nested array.

Returns

NDArray

An NDArray with the data and shape of the given array.

Type Parameters

T

The type of given array, must be compliant to numpy's supported dtypes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.array.html
Always performs a copy.

asanyarray(in object, Type)

Convert the input to an ndarray, but pass ndarray subclasses through.

public static NDArray asanyarray(in object a, Type dtype = null)

Parameters

a object

Input data, in any form that can be converted to an array. This includes scalars, lists, lists of tuples, tuples, tuples of tuples, tuples of lists, and ndarrays.

dtype Type

By default, the data-type is inferred from the input data.

Returns

NDArray

Array interpretation of a. If a is an ndarray or a subclass of ndarray, it is returned as-is and no copy is performed.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.asanyarray.html

asanyarray(in object, Type, char)

Convert the input to an ndarray with a specified memory layout.

public static NDArray asanyarray(in object a, Type dtype, char order)

Parameters

a object

Input data.

dtype Type

By default, the data-type is inferred from the input data.

order char

'C', 'F', 'A' or 'K' (default — resolved against a).

Returns

NDArray

Array interpretation of a in the requested layout.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.asanyarray.html

asarray(NDArray, DType, char, bool?, NDArray, string)

Convert the input to an ndarray. Convenience overload taking a DType instance.

public static NDArray asarray(NDArray a, DType dtype, char order = 'K', bool? copy = null, NDArray like = null, string device = null)

Parameters

a NDArray

dtype DType

order char

copy bool?

like NDArray

device string

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.asarray.html

asarray(NDArray, NPTypeCode, char, bool?, NDArray, string)

Convert the input to an ndarray. Convenience overload taking NPTypeCode.

public static NDArray asarray(NDArray a, NPTypeCode dtype, char order = 'K', bool? copy = null, NDArray like = null, string device = null)

Parameters

a NDArray

dtype NPTypeCode

order char

copy bool?

like NDArray

device string

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.asarray.html

asarray(NDArray, string, char, bool?, NDArray, string)

Convert the input to an ndarray. Convenience overload taking a NumPy-style dtype string (e.g. "float32", "<i4", "complex128").

public static NDArray asarray(NDArray a, string dtype, char order = 'K', bool? copy = null, NDArray like = null, string device = null)

Parameters

a NDArray

Input ndarray.

dtype string

NumPy-style dtype string (parsed via dtype(string)).

order char

'C', 'F', 'A', or 'K' (default).

copy bool?

Tri-state copy: null = if-needed, true = always, false = never (raises).

like NDArray

Reference for array-function dispatch — accepted for parity, no effect.

device string

Only "cpu" or null.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.asarray.html

asarray(NDArray, Type, char, bool?, NDArray, string)

Convert the input to an ndarray, matching NumPy 2.x semantics. If a already satisfies the requested dtype/layout, it is returned as-is — no copy.

public static NDArray asarray(NDArray a, Type dtype = null, char order = 'K', bool? copy = null, NDArray like = null, string device = null)

Parameters

a NDArray

Input ndarray.

dtype Type

Requested dtype. null keeps the input dtype.

order char

'C' (row-major), 'F' (column-major), 'A' (any contiguous), 'K' (keep — default). 'A'/'K' never force a copy on layout grounds.

copy bool?

Tri-state: null = copy only if needed (default), true = always copy, false = never copy (raises if a copy would be required).

like NDArray

Reference array for array-function dispatch — accepted for NumPy parity but has no observable effect in NumSharp.

device string

Target device. Only "cpu" and null are accepted.

Returns

NDArray

NDArray with the requested dtype and memory layout. Returns a when no copy is needed.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.asarray.html

asarray(string)

public static NDArray asarray(string data)

Parameters

data string

Returns

NDArray

asarray(string[], int)

public static NDArray asarray(string[] data, int ndim = 1)

Parameters

data string[]

ndim int

Returns

NDArray

asarray<T>(T)

public static NDArray asarray<T>(T data) where T : struct

Parameters

data T

Returns

NDArray

Type Parameters

T

asarray<T>(T[], int)

public static NDArray asarray<T>(T[] data, int ndim = 1) where T : struct

Parameters

data T[]

ndim int

Returns

NDArray

Type Parameters

T

ascontiguousarray(NDArray, Type)

Return a contiguous array (ndim >= 1) in memory (C order).

public static NDArray ascontiguousarray(NDArray a, Type dtype = null)

Parameters

a NDArray

Input array.

dtype Type

By default, the data-type is inferred from the input.

Returns

NDArray

Contiguous array of same shape and content as a, with type dtype if specified.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ascontiguousarray.html

asfortranarray(NDArray, Type)

Return an array (ndim >= 1) laid out in Fortran order in memory.

public static NDArray asfortranarray(NDArray a, Type dtype = null)

Parameters

a NDArray

Input array.

dtype Type

By default, the data-type is inferred from the input.

Returns

NDArray

The input a in Fortran, or column-major, order.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.asfortranarray.html

asscalar(NDArray)

Convert an array of size 1 to its scalar equivalent.

[Obsolete("np.asscalar is deprecated (removed in NumPy 2.0). Use NDArray.item() instead.")]
public static object asscalar(NDArray nd)

Parameters

nd NDArray

Input NDArray of size 1.

Returns

object

Remarks

DEPRECATED: np.asscalar was removed in NumPy 2.0.

asscalar(Array)

Convert an array of size 1 to its scalar equivalent.

[Obsolete("np.asscalar is deprecated (removed in NumPy 2.0). Use NDArray.item() instead.")]
public static object asscalar(Array arr)

Parameters

arr Array

Input array of size 1.

Returns

object

Remarks

DEPRECATED: np.asscalar was removed in NumPy 2.0.

asscalar<T>(ArraySlice<T>)

Convert an array of size 1 to its scalar equivalent.

[Obsolete("np.asscalar is deprecated (removed in NumPy 2.0). Use NDArray.item() instead.")]
public static T asscalar<T>(ArraySlice<T> arr) where T : unmanaged

Parameters

arr ArraySlice<T>

Input array of size 1.

Returns

T

Type Parameters

T

Remarks

DEPRECATED: np.asscalar was removed in NumPy 2.0.

asscalar<T>(IArraySlice)

Convert an array of size 1 to its scalar equivalent.

[Obsolete("np.asscalar is deprecated (removed in NumPy 2.0). Use NDArray.item() instead.")]
public static T asscalar<T>(IArraySlice arr) where T : unmanaged

Parameters

arr IArraySlice

Input array of size 1.

Returns

T

Type Parameters

T

Remarks

DEPRECATED: np.asscalar was removed in NumPy 2.0.

asscalar<T>(NDArray)

Convert an array of size 1 to its scalar equivalent.

[Obsolete("np.asscalar is deprecated (removed in NumPy 2.0). Use NDArray.item() instead.")]
public static T asscalar<T>(NDArray nd) where T : unmanaged

Parameters

nd NDArray

Input NDArray of size 1.

Returns

T

Type Parameters

T

Remarks

DEPRECATED: np.asscalar was removed in NumPy 2.0. Use NDArray.item() instead: arr.item() or arr.item<T>() https://numpy.org/doc/stable/reference/generated/numpy.ndarray.item.html

asscalar<T>(Array)

Convert an array of size 1 to its scalar equivalent.

[Obsolete("np.asscalar is deprecated (removed in NumPy 2.0). Use NDArray.item() instead.")]
public static T asscalar<T>(Array arr)

Parameters

arr Array

Input array of size 1.

Returns

T

Type Parameters

T

Remarks

DEPRECATED: np.asscalar was removed in NumPy 2.0.

atleast_1d(NDArray)

Convert inputs to arrays with at least one dimension. Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.

public static NDArray atleast_1d(NDArray arr)

Parameters

arr NDArray

Returns

NDArray

An array, or list of arrays, each with a.ndim >= 1. Copies are made only if necessary.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_1d.html

atleast_1d(params NDArray[])

Convert inputs to arrays with at least one dimension. Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.

public static NDArray[] atleast_1d(params NDArray[] arys)

Parameters

arys NDArray[]

One or more input arrays.

Returns

NDArray[]

An array, or list of arrays, each with a.ndim >= 1. Copies are made only if necessary.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_1d.html

atleast_1d(object)

Convert inputs to arrays with at least one dimension. Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.

public static NDArray atleast_1d(object arys)

Parameters

arys object

One or more input arrays.

Returns

NDArray

An array, or list of arrays, each with a.ndim >= 1. Copies are made only if necessary.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_1d.html

atleast_1d(params object[])

Convert inputs to arrays with at least one dimension. Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.

public static NDArray[] atleast_1d(params object[] arys)

Parameters

arys object[]

One or more input arrays.

Returns

NDArray[]

An array, or list of arrays, each with a.ndim >= 1. Copies are made only if necessary.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_1d.html

atleast_2d(NDArray)

View inputs as arrays with at least two dimensions.

public static NDArray atleast_2d(NDArray arr)

Parameters

arr NDArray

One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have two or more dimensions are preserved.

Returns

NDArray

An array, or list of arrays, each with a.ndim >= 2. Copies are avoided where possible, and views with two or more dimensions are returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_2d.html

atleast_2d(params NDArray[])

View inputs as arrays with at least two dimensions.

public static NDArray[] atleast_2d(params NDArray[] arys)

Parameters

arys NDArray[]

One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have two or more dimensions are preserved.

Returns

NDArray[]

An array, or list of arrays, each with a.ndim >= 2. Copies are avoided where possible, and views with two or more dimensions are returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_2d.html

atleast_2d(object)

View inputs as arrays with at least two dimensions.

public static NDArray atleast_2d(object arys)

Parameters

arys object

One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have two or more dimensions are preserved.

Returns

NDArray

An array, or list of arrays, each with a.ndim >= 2. Copies are avoided where possible, and views with two or more dimensions are returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_2d.html

atleast_2d(params object[])

View inputs as arrays with at least two dimensions.

public static NDArray[] atleast_2d(params object[] arys)

Parameters

arys object[]

One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have two or more dimensions are preserved.

Returns

NDArray[]

An array, or list of arrays, each with a.ndim >= 2. Copies are avoided where possible, and views with two or more dimensions are returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_2d.html

atleast_3d(NDArray)

View inputs as arrays with at least three dimensions.

public static NDArray atleast_3d(NDArray arr)

Parameters

arr NDArray

Returns

NDArray

An array, or list of arrays, each with a.ndim >= 3. Copies are avoided where possible, and views with three or more dimensions are returned. For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1), and a 2-D array of shape (M, N) becomes a view of shape (M, N, 1).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_3d.html

atleast_3d(params NDArray[])

View inputs as arrays with at least three dimensions.

public static NDArray[] atleast_3d(params NDArray[] arys)

Parameters

arys NDArray[]

One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have three or more dimensions are preserved.

Returns

NDArray[]

An array, or list of arrays, each with a.ndim >= 3. Copies are avoided where possible, and views with three or more dimensions are returned. For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1), and a 2-D array of shape (M, N) becomes a view of shape (M, N, 1).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_3d.html

atleast_3d(object)

View inputs as arrays with at least three dimensions.

public static NDArray atleast_3d(object arys)

Parameters

arys object

One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have three or more dimensions are preserved.

Returns

NDArray

An array, or list of arrays, each with a.ndim >= 3. Copies are avoided where possible, and views with three or more dimensions are returned. For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1), and a 2-D array of shape (M, N) becomes a view of shape (M, N, 1).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_3d.html

atleast_3d(params object[])

View inputs as arrays with at least three dimensions.

public static NDArray[] atleast_3d(params object[] arys)

Parameters

arys object[]

One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have three or more dimensions are preserved.

Returns

NDArray[]

An array, or list of arrays, each with a.ndim >= 3. Copies are avoided where possible, and views with three or more dimensions are returned. For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1), and a 2-D array of shape (M, N) becomes a view of shape (M, N, 1).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.atleast_3d.html

average(NDArray, int[], NDArray, bool)

Compute the weighted average along a tuple of axes. Equivalent to np.average(a, axis, weights, keepdims) in NumPy with a tuple axis.

public static NDArray average(NDArray a, int[] axis, NDArray weights = null, bool keepdims = false)

Parameters

a NDArray

axis int[]

weights NDArray

keepdims bool

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.average.html

average(NDArray, int?, NDArray, bool)

Compute the weighted average along the specified axis. Equivalent to sum(a * weights) / sum(weights). When weights is null this reduces to mean(NDArray) over the same axes.

public static NDArray average(NDArray a, int? axis = null, NDArray weights = null, bool keepdims = false)

Parameters

a NDArray

axis int?

weights NDArray

keepdims bool

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.average.html

average_returned(NDArray, int[], NDArray, bool)

Tuple-axis overload of average_returned(NDArray, int?, NDArray, bool).

public static (NDArray avg, NDArray sumOfWeights) average_returned(NDArray a, int[] axis, NDArray weights = null, bool keepdims = false)

Parameters

a NDArray

axis int[]

weights NDArray

keepdims bool

Returns

(NDArray Lhs, NDArray Rhs)

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.average.html

average_returned(NDArray, int?, NDArray, bool)

Compute the weighted average and return a tuple (avg, sum_of_weights). Equivalent to numpy.average(..., returned=True). When weights is null, sum_of_weights is the number of elements per output cell (broadcast to the average's shape).

public static (NDArray avg, NDArray sumOfWeights) average_returned(NDArray a, int? axis = null, NDArray weights = null, bool keepdims = false)

Parameters

a NDArray

axis int?

weights NDArray

keepdims bool

Returns

(NDArray Lhs, NDArray Rhs)

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.average.html

bitwise_and(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Compute the bit-wise AND of two arrays element-wise. Only integer and boolean types are handled (NumPy: float/complex inputs raise the no-loop TypeError).

public static NDArray bitwise_and(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

First input array.

x2 NDArray

Second input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Returns

NDArray

Result. This is a scalar if both x1 and x2 are scalars.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.bitwise_and.html

bitwise_not(NDArray, NDArray, NDArray, NPTypeCode?)

Compute bit-wise inversion, or bit-wise NOT, element-wise. Alias for invert.

public static NDArray bitwise_not(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Only integer and boolean types are handled.

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

Result. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.invert.html

bitwise_not(NDArray, NPTypeCode)

Compute bit-wise inversion, or bit-wise NOT, element-wise. Alias for invert.

public static NDArray bitwise_not(NDArray x, NPTypeCode outType)

Parameters

x NDArray

outType NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.invert.html

bitwise_not(NDArray, Type)

Compute bit-wise inversion, or bit-wise NOT, element-wise. Alias for invert.

public static NDArray bitwise_not(NDArray x, Type outType)

Parameters

x NDArray

Only integer and boolean types are handled.

outType Type

The dtype the returned ndarray should be of.

Returns

NDArray

Result. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.invert.html

bitwise_or(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Compute the bit-wise OR of two arrays element-wise. Only integer and boolean types are handled (NumPy: float/complex inputs raise the no-loop TypeError).

public static NDArray bitwise_or(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

First input array.

x2 NDArray

Second input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Returns

NDArray

Result. This is a scalar if both x1 and x2 are scalars.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.bitwise_or.html

bitwise_xor(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Compute the bit-wise XOR of two arrays element-wise. Only integer and boolean types are handled (NumPy: float/complex inputs raise the no-loop TypeError).

public static NDArray bitwise_xor(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

First input array.

x2 NDArray

Second input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Returns

NDArray

Result. This is a scalar if both x1 and x2 are scalars.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.bitwise_xor.html

broadcast(NDArray, NDArray)

Two-operand overload — the most common case. Retained as an explicit overload so np.broadcast(a, b) stays binary-compatible and skips the params-array allocation.

public static np.Broadcast broadcast(NDArray nd1, NDArray nd2)

Parameters

nd1 NDArray

nd2 NDArray

Returns

np.Broadcast

broadcast(params NDArray[])

Produce an object that mimics broadcasting.

public static np.Broadcast broadcast(params NDArray[] arrays)

Parameters

arrays NDArray[]

The arrays to broadcast against one another. NumPy caps this at 64 operands (NPY_MAXARGS); NumSharp imposes no cap, matching its unlimited-operand NDIter.

Returns

np.Broadcast

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast.html

broadcast_arrays(NDArray, NDArray)

Broadcast two arrays against each other.

public static (NDArray Lhs, NDArray Rhs) broadcast_arrays(NDArray lhs, NDArray rhs)

Parameters

lhs NDArray

An array to broadcast.

rhs NDArray

An array to broadcast.

Returns

(NDArray Lhs, NDArray Rhs)

These arrays are views on the original arrays. They are typically not contiguous. Furthermore, more than one element of a broadcasted array may refer to a single memory location. If you need to write to the arrays, make copies first.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_arrays.html

broadcast_arrays(params NDArray[])

Broadcast any number of arrays against each other.

public static NDArray[] broadcast_arrays(params NDArray[] ndArrays)

Parameters

ndArrays NDArray[]

The arrays to broadcast.

Returns

NDArray[]

These arrays are views on the original arrays. They are typically not contiguous. Furthermore, more than one element of a broadcasted array may refer to a single memory location. If you need to write to the arrays, make copies first.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_arrays.html

broadcast_to(UnmanagedStorage, UnmanagedStorage)

Broadcast an array to a new shape.

public static NDArray broadcast_to(UnmanagedStorage from, UnmanagedStorage against)

Parameters

from UnmanagedStorage

The UnmanagedStorage to broadcast.

against UnmanagedStorage

The shape to broadcast against.

Returns

NDArray

These arrays are views on the original arrays. They are typically not contiguous. Furthermore, more than one element of a broadcasted array may refer to a single memory location. If you need to write to the arrays, make copies first.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html

broadcast_to(UnmanagedStorage, NDArray)

Broadcast an array to a new shape.

public static NDArray broadcast_to(UnmanagedStorage from, NDArray against)

Parameters

from UnmanagedStorage

The UnmanagedStorage to broadcast.

against NDArray

The shape to broadcast against.

Returns

NDArray

These arrays are views on the original arrays. They are typically not contiguous. Furthermore, more than one element of a broadcasted array may refer to a single memory location. If you need to write to the arrays, make copies first.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html

broadcast_to(UnmanagedStorage, Shape)

Broadcast an array to a new shape.

public static NDArray broadcast_to(UnmanagedStorage from, Shape against)

Parameters

from UnmanagedStorage

The NDArray to broadcast.

against Shape

The shape to broadcast against.

Returns

NDArray

These arrays are views on the original arrays. They are typically not contiguous. Furthermore, more than one element of a broadcasted array may refer to a single memory location. If you need to write to the arrays, make copies first.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html

broadcast_to(NDArray, UnmanagedStorage)

Broadcast an array to a new shape.

public static NDArray broadcast_to(NDArray from, UnmanagedStorage against)

Parameters

from NDArray

The NDArray to broadcast.

against UnmanagedStorage

The shape to broadcast against.

Returns

NDArray

These arrays are views on the original arrays. They are typically not contiguous. Furthermore, more than one element of a broadcasted array may refer to a single memory location. If you need to write to the arrays, make copies first.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html

broadcast_to(NDArray, NDArray)

Broadcast an array to a new shape.

public static NDArray broadcast_to(NDArray from, NDArray against)

Parameters

from NDArray

The NDArray to broadcast.

against NDArray

The shape to broadcast against.

Returns

NDArray

These arrays are views on the original arrays. They are typically not contiguous. Furthermore, more than one element of a broadcasted array may refer to a single memory location. If you need to write to the arrays, make copies first.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html

broadcast_to(NDArray, Shape)

Broadcast an array to a new shape.

public static NDArray broadcast_to(NDArray from, Shape against)

Parameters

from NDArray

The NDArray to broadcast.

against Shape

The shape to broadcast against.

Returns

NDArray

These arrays are views on the original arrays. They are typically not contiguous. Furthermore, more than one element of a broadcasted array may refer to a single memory location. If you need to write to the arrays, make copies first.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html

broadcast_to(Shape, UnmanagedStorage)

Broadcast an shape against an other new shape.

public static Shape broadcast_to(Shape from, UnmanagedStorage against)

Parameters

from Shape

The shape that is to be broadcasted

against UnmanagedStorage

The shape that'll be used to broadcast from shape

Returns

Shape

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html

broadcast_to(Shape, NDArray)

Broadcast an shape against an other new shape.

public static Shape broadcast_to(Shape from, NDArray against)

Parameters

from Shape

The shape that is to be broadcasted

against NDArray

The shape that'll be used to broadcast from shape

Returns

Shape

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html

broadcast_to(Shape, Shape)

Broadcast an shape against an other new shape.

public static Shape broadcast_to(Shape from, Shape against)

Parameters

from Shape

The shape that is to be broadcasted

against Shape

The shape that'll be used to broadcast from shape

Returns

Shape

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.broadcast_to.html

can_cast(NDArray, NPTypeCode, string)

Returns True if cast from array dtype can occur according to the casting rule.

public static bool can_cast(NDArray from, NPTypeCode to, string casting = "safe")

Parameters

from NDArray

Array to cast from.

to NPTypeCode

Data type to cast to.

casting string

Controls what kind of data casting may occur.

Returns

bool

True if the array can be cast to the target type.

can_cast(NPTypeCode, NPTypeCode, string)

Returns True if cast between data types can occur according to the casting rule.

public static bool can_cast(NPTypeCode from, NPTypeCode to, string casting = "safe")

Parameters

from NPTypeCode

Data type to cast from.

to NPTypeCode

Data type to cast to.

casting string

Controls what kind of data casting may occur:

• "no" means the data types should not be cast at all.
• "equiv" means only byte-order changes are allowed.
• "safe" means only casts which can preserve values are allowed.
• "same_kind" means only safe casts or casts within a kind (int to int, float to float) are allowed.
• "unsafe" means any data conversions may be done.

Returns

bool

True if cast can occur according to the casting rule.

Examples

np.can_cast(NPTypeCode.Int32, NPTypeCode.Int64)           // True
np.can_cast(NPTypeCode.Int64, NPTypeCode.Int32)           // False
np.can_cast(NPTypeCode.Int32, NPTypeCode.Single, "same_kind")  // False (different kind)
np.can_cast(NPTypeCode.Int32, NPTypeCode.Int16, "unsafe") // True

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.can_cast.html

can_cast(bool, NPTypeCode, string)

Returns True if the bool value can be cast to the data type according to the casting rule.

public static bool can_cast(bool value, NPTypeCode to, string casting = "safe")

Parameters

value bool

to NPTypeCode

casting string

Returns

bool

can_cast(byte, NPTypeCode, string)

Returns True if the byte value can be cast to the data type according to the casting rule.

public static bool can_cast(byte value, NPTypeCode to, string casting = "safe")

Parameters

value byte

to NPTypeCode

casting string

Returns

bool

can_cast(decimal, NPTypeCode, string)

Returns True if the decimal value can be cast to the data type according to the casting rule.

public static bool can_cast(decimal value, NPTypeCode to, string casting = "safe")

Parameters

value decimal

to NPTypeCode

casting string

Returns

bool

can_cast(double, NPTypeCode, string)

Returns True if the double value can be cast to the data type according to the casting rule.

public static bool can_cast(double value, NPTypeCode to, string casting = "safe")

Parameters

value double

to NPTypeCode

casting string

Returns

bool

can_cast(short, NPTypeCode, string)

Returns True if the short value can be cast to the data type according to the casting rule.

public static bool can_cast(short value, NPTypeCode to, string casting = "safe")

Parameters

value short

to NPTypeCode

casting string

Returns

bool

can_cast(int, NPTypeCode, string)

Returns True if the int value can be cast to the data type according to the casting rule.

public static bool can_cast(int value, NPTypeCode to, string casting = "safe")

Parameters

value int

Int value to check.

to NPTypeCode

Data type to cast to.

casting string

Controls what kind of data casting may occur.

Returns

bool

True if the value can be cast to the target type.

can_cast(long, NPTypeCode, string)

Returns True if the long value can be cast to the data type according to the casting rule.

public static bool can_cast(long value, NPTypeCode to, string casting = "safe")

Parameters

value long

to NPTypeCode

casting string

Returns

bool

can_cast(object, NPTypeCode, string)

Returns True if the scalar value can be cast to the data type according to the casting rule.

public static bool can_cast(object value, NPTypeCode to, string casting = "safe")

Parameters

value object

Scalar value to check.

to NPTypeCode

Data type to cast to.

casting string

Controls what kind of data casting may occur.

Returns

bool

True if the value can be cast to the target type.

Examples

np.can_cast(100, NPTypeCode.Byte)    // True (100 fits in byte)
np.can_cast(1000, NPTypeCode.Byte)   // False (1000 > 255)

Remarks

Scalar values can often be cast to smaller types if the value fits.

can_cast(float, NPTypeCode, string)

Returns True if the float value can be cast to the data type according to the casting rule.

public static bool can_cast(float value, NPTypeCode to, string casting = "safe")

Parameters

value float

to NPTypeCode

casting string

Returns

bool

can_cast(Type, Type, string)

Returns True if cast between data types can occur according to the casting rule.

public static bool can_cast(Type from, Type to, string casting = "safe")

Parameters

from Type

CLR type to cast from.

to Type

CLR type to cast to.

casting string

Controls what kind of data casting may occur.

Returns

bool

True if cast can occur according to the casting rule.

can_cast(ushort, NPTypeCode, string)

Returns True if the ushort value can be cast to the data type according to the casting rule.

public static bool can_cast(ushort value, NPTypeCode to, string casting = "safe")

Parameters

value ushort

to NPTypeCode

casting string

Returns

bool

can_cast(uint, NPTypeCode, string)

Returns True if the uint value can be cast to the data type according to the casting rule.

public static bool can_cast(uint value, NPTypeCode to, string casting = "safe")

Parameters

value uint

to NPTypeCode

casting string

Returns

bool

can_cast(ulong, NPTypeCode, string)

Returns True if the ulong value can be cast to the data type according to the casting rule.

public static bool can_cast(ulong value, NPTypeCode to, string casting = "safe")

Parameters

value ulong

to NPTypeCode

casting string

Returns

bool

can_cast<TFrom, TTo>(string)

Returns True if cast between data types can occur according to the casting rule.

public static bool can_cast<TFrom, TTo>(string casting = "safe") where TFrom : struct where TTo : struct

Parameters

casting string

Controls what kind of data casting may occur.

Returns

bool

True if cast can occur according to the casting rule.

Type Parameters

TFrom

Source type.

TTo

Target type.

Examples

np.can_cast<int, long>()           // True
np.can_cast<long, int>()           // False
np.can_cast<int, float>("safe")    // True (int to float is safe)

cbrt(NDArray, NDArray, NDArray, NPTypeCode?)

Return the cube-root of an array, element-wise.

public static NDArray cbrt(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

The values whose cube-roots are required.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of.

Returns

NDArray

An array of the same shape as x, containing the cube root of each element. If x contains negative values, the result contains the (negative) real cube root. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cbrt.html

cbrt(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray cbrt(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cbrt.html

cbrt(NDArray, Type)

Return the cube-root of an array, element-wise.

public static NDArray cbrt(NDArray x, Type dtype)

Parameters

x NDArray

The values whose cube-roots are required.

dtype Type

The dtype the returned ndarray should be of.

Returns

NDArray

An array of the same shape as x, containing the cube root of each element. If x contains negative values, the result contains the (negative) real cube root. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cbrt.html

ceil(NDArray, NDArray, NDArray, NPTypeCode?)

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 \lceil x \rceil.

public static NDArray ceil(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input data.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The ceiling of each element in x, with float dtype. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ceil.html

ceil(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray ceil(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ceil.html

ceil(NDArray, Type)

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 \lceil x \rceil.

public static NDArray ceil(NDArray x, Type dtype)

Parameters

x NDArray

Input data.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The ceiling of each element in x, with float dtype. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ceil.html

clip(NDArray, NDArray, NDArray, NDArray, NPTypeCode?, NDArray, NDArray)

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.
Matches NumPy 2.x signature: clip(a, a_min=None, a_max=None, out=None, *, min=None, max=None). Either or both bounds may be null. The min and max keyword aliases (added in NumPy 2.0) are accepted; mixing a_min with min (or a_max with max) throws.

public static NDArray clip(NDArray a, NDArray a_min = null, NDArray a_max = null, NDArray @out = null, NPTypeCode? dtype = null, NDArray min = null, NDArray max = null)

Parameters

a NDArray

Array containing elements to clip.

a_min NDArray

Minimum value. If null, clipping is not performed on lower interval edge.

a_max NDArray

Maximum value. If null, clipping is not performed on upper interval edge.

out NDArray

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.

dtype NPTypeCode?

The dtype the returned ndarray should be of.

min NDArray

NumPy 2.x keyword alias for a_min. Cannot be combined with a_min.

max NDArray

NumPy 2.x keyword alias for a_max. Cannot be combined with a_max.

Returns

NDArray

An array with the elements of a, but where values < min are replaced with min, and those > max with max.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.clip.html

clip(NDArray, NDArray, NDArray, Type)

Clip (limit) the values in an array, returning a result of the requested CLR Type.

public static NDArray clip(NDArray a, NDArray a_min, NDArray a_max, Type dtype)

Parameters

a NDArray

Array containing elements to clip.

a_min NDArray

Minimum value. If null, clipping is not performed on lower interval edge.

a_max NDArray

Maximum value. If null, clipping is not performed on upper interval edge.

dtype Type

The dtype the returned ndarray should be of.

Returns

NDArray

An array with the elements of a, but where values < a_min are replaced with a_min, and those > a_max with a_max.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.clip.html

common_type(params NDArray[])

Return a scalar type which is common to the input arrays.

public static Type common_type(params NDArray[] arrays)

Parameters

arrays NDArray[]

Input arrays.

Returns

Type

The common scalar type as CLR Type.

Examples

np.common_type(np.array(new int[] {1, 2}))           // typeof(double)
np.common_type(a_float32, a_float64)                 // typeof(double)

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.common_type.html

The return type will always be a floating-point type (minimum float64 for integers). This differs from result_type which may return an integer type.

common_type_code(params NDArray[])

Return a scalar type code which is common to the input arrays.

public static NPTypeCode common_type_code(params NDArray[] arrays)

Parameters

arrays NDArray[]

Input arrays.

Returns

NPTypeCode

The common scalar type as NPTypeCode.

Remarks

The return type will always be a floating-point type (minimum Double for integers).

common_type_code(params NPTypeCode[])

Return a scalar type code which is common to the input type codes.

public static NPTypeCode common_type_code(params NPTypeCode[] types)

Parameters

types NPTypeCode[]

Input type codes.

Returns

NPTypeCode

The common scalar type as NPTypeCode.

Remarks

NumPy common_type rules:

• Any Complex input -> Complex (complex128).
• Any Decimal input (NumSharp extension) -> Decimal.
• Any integer/bool/char input -> Double (any int presence forces float64).
• Otherwise (all float16/float32/float64): return max-precision float.

compress(NDArray, NDArray, int?, NDArray)

Return selected slices of a along the given axis at positions where the 1-D condition is truthy.

public static NDArray compress(NDArray condition, NDArray a, int? axis = null, NDArray @out = null)

Parameters

condition NDArray

1-D array of booleans (or any dtype interpreted as truthy). Must be 1-D — a 2-D or 0-D condition raises ArgumentException, mirroring NumPy's ValueError("condition must be a 1-d array"). If len(condition) < a.shape[axis], only the first len(condition) positions along axis are considered; if longer, any True beyond a.shape[axis] raises IndexOutOfRangeException.

a NDArray

Source array.

axis int?

Axis along which to slice. null (default) flattens a first.

out NDArray

Optional destination. When supplied, shape must match the natural output and out.dtype must be safely castable to a.dtype; values are written via copyto(NDArray, NDArray, string, NDArray) with unsafe casting and the method returns out itself (matches NumPy's out= dispatch via PyArray_TakeFrom).

Returns

NDArray

A copy of a without the slices along axis for which condition is false. Dtype matches a (or out's dtype when supplied).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.compress.html

Two execution paths:

• Fast path: bool condition, contig source, no out= or out= matches src.dtype, condition.size <= a.shape[axis]. Runs the fused mask-driven gather kernel (popcount → alloc → SIMD bit-scan + cpblk-per-outer-slab), skipping the flatnonzero indices NDArray.
• Generic path: mirrors NumPy's PyArray_Compress chain — flatnonzero(cond) → take(a, indices, axis, out, "raise"). Handles non-bool conditions, out= with safe dtype cast, and OOB-True via take's RAISE mode.

When condition is 1-D extract(NDArray, NDArray) with axis = null is equivalent.

concatenate(NDArray[], int?, NDArray, NPTypeCode?, string)

Join a sequence of arrays along an existing axis.

public static NDArray concatenate(NDArray[] arrays, int? axis = 0, NDArray @out = null, NPTypeCode? dtype = null, string casting = "same_kind")

Parameters

arrays NDArray[]

The arrays must have the same shape, except in the dimension corresponding to axis (the first, by default).

axis int?

The axis along which the arrays will be joined. If null, arrays are flattened before use. Default is 0. Negative axes are normalized against the input ndim.

out NDArray

If provided, the destination to place the result. The shape must be correct, matching what would have been returned with no out argument. Cannot be used together with dtype.

dtype NPTypeCode?

If provided, the result array will have this dtype. Cannot be used together with out.

casting string

Controls what kind of data casting may occur. One of "no", "equiv", "safe", "same_kind" (default), or "unsafe".

Returns

NDArray

The concatenated array.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html

concatenate((NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray), int)

public static NDArray concatenate((NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray) arrays, int axis = 0)

Parameters

arrays (NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray)

axis int

Returns

NDArray

concatenate((NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray), int)

public static NDArray concatenate((NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray) arrays, int axis = 0)

Parameters

arrays (NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray)

axis int

Returns

NDArray

concatenate((NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray), int)

public static NDArray concatenate((NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray) arrays, int axis = 0)

Parameters

arrays (NDArray, NDArray, NDArray, NDArray, NDArray, NDArray, NDArray)

axis int

Returns

NDArray

concatenate((NDArray, NDArray, NDArray, NDArray, NDArray, NDArray), int)

public static NDArray concatenate((NDArray, NDArray, NDArray, NDArray, NDArray, NDArray) arrays, int axis = 0)

Parameters

arrays (NDArray, NDArray, NDArray, NDArray, NDArray, NDArray)

axis int

Returns

NDArray

concatenate((NDArray, NDArray, NDArray, NDArray, NDArray), int)

public static NDArray concatenate((NDArray, NDArray, NDArray, NDArray, NDArray) arrays, int axis = 0)

Parameters

arrays (NDArray, NDArray, NDArray, NDArray, NDArray)

axis int

Returns

NDArray

concatenate((NDArray, NDArray, NDArray, NDArray), int)

public static NDArray concatenate((NDArray, NDArray, NDArray, NDArray) arrays, int axis = 0)

Parameters

arrays (NDArray, NDArray, NDArray, NDArray)

axis int

Returns

NDArray

concatenate((NDArray, NDArray, NDArray), int)

public static NDArray concatenate((NDArray, NDArray, NDArray) arrays, int axis = 0)

Parameters

arrays (NDArray, NDArray, NDArray)

axis int

Returns

NDArray

concatenate((NDArray, NDArray), int)

public static NDArray concatenate((NDArray, NDArray) arrays, int axis = 0)

Parameters

arrays (NDArray Lhs, NDArray Rhs)

axis int

Returns

NDArray

convolve(NDArray, NDArray, string)

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.

public static NDArray convolve(NDArray a, NDArray v, string mode = "full")

Parameters

a NDArray

v NDArray

mode string

Returns

NDArray

copy(NDArray, char)

Return an array copy of the given object.

public static NDArray copy(NDArray a, char order = 'K')

Parameters

a NDArray

Input data.

order char

Controls the memory layout of the copy. 'C' - row-major, 'F' - column-major, 'A' - 'F' if source is F-contiguous else 'C', 'K' - match source layout as closely as possible.

Returns

NDArray

Array interpretation of a.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.copy.html

copyto(NDArray, NDArray, string, NDArray)

Copies values from one array to another, broadcasting as necessary.

public static void copyto(NDArray dst, NDArray src, string casting = "same_kind", NDArray where = null)

Parameters

dst NDArray

The array into which values are copied.

src NDArray

The array from which values are copied.

casting string

Controls what kind of data casting may occur when copying. Default "same_kind". Allowed values: "no", "equiv", "safe", "same_kind", "unsafe".

where NDArray

Optional boolean mask broadcast to dst's shape. Elements of src are only written to dst where the mask is true. null (default) is equivalent to where=True — every element is copied.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.copyto.html

Exceptions

ArgumentException

If dst is read-only, or casting is not a recognised casting name, or where is not a boolean array.

InvalidCastException

If casting from src's dtype to dst's dtype is not allowed under the chosen rule (NumPy raises TypeError).

cos(NDArray, NDArray, NDArray, NPTypeCode?)

Cosine element-wise. Mirrors NumPy's ufunc signature: cos(x, /, out=None, *, where=True, dtype=None).

public static NDArray cos(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array in radians.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the computation runs at this precision; integer/bool requests raise NumPy's "No loop matching" error.

Returns

NDArray

The cosine of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cos.html

cos(NDArray, NPTypeCode)

Cosine element-wise, computed in dtype. Positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray cos(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array in radians.

dtype NPTypeCode

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cos.html

cos(NDArray, Type)

Cosine element-wise.

public static NDArray cos(NDArray x, Type dtype)

Parameters

x NDArray

Input array in radians.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The sine of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cos.html

cosh(NDArray, NDArray, NDArray, NPTypeCode?)

Hyperbolic cosine, element-wise.
Equivalent to 1/2 * (np.exp(x) + np.exp(-x)) and np.cos(1j* x).

public static NDArray cosh(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

Output array of same shape as x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cosh.html

cosh(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray cosh(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cosh.html

cosh(NDArray, Type)

Hyperbolic cosine, element-wise.
Equivalent to 1/2 * (np.exp(x) + np.exp(-x)) and np.cos(1j* x).

public static NDArray cosh(NDArray x, Type dtype)

Parameters

x NDArray

Input array.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

Output array of same shape as x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cosh.html

count_nonzero(NDArray)

Counts the number of non-zero values in the array.

public static long count_nonzero(NDArray a)

Parameters

a NDArray

The array for which to count non-zeros.

Returns

long

Number of non-zero values in the array.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.count_nonzero.html

count_nonzero(NDArray, int, bool)

Counts the number of non-zero values in the array along the given axis.

public static NDArray count_nonzero(NDArray a, int axis, bool keepdims = false)

Parameters

a NDArray

The array for which to count non-zeros.

axis int

Axis along which to count non-zeros.

keepdims bool

If True, the axes which are reduced are left in the result as dimensions with size one.

Returns

NDArray

Number of non-zero values along the specified axis.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.count_nonzero.html

cumprod(NDArray, int?, NPTypeCode?)

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

public static NDArray cumprod(NDArray arr, int? axis = null, NPTypeCode? typeCode = null)

Parameters

arr NDArray

Input array.

axis int?

Axis along which the cumulative product is computed. The default (None) is to compute the cumprod over the flattened array.

typeCode NPTypeCode?

Type of the returned array and 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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cumprod.html

cumsum(NDArray, int?, NPTypeCode?)

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

public static NDArray cumsum(NDArray arr, int? axis = null, NPTypeCode? typeCode = null)

Parameters

arr NDArray

Input array.

axis int?

Axis along which the cumulative sum is computed. The default (None) is to compute the cumsum over the flattened array.

typeCode NPTypeCode?

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.cumsum.html

deg2rad(NDArray, NDArray, NDArray, NPTypeCode?)

Convert angles from degrees to radians.

public static NDArray deg2rad(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Angles in degrees.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of.

Returns

NDArray

The corresponding angle in radians. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.deg2rad.html

deg2rad(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray deg2rad(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.deg2rad.html

deg2rad(NDArray, Type)

Convert angles from degrees to radians.

public static NDArray deg2rad(NDArray x, Type dtype)

Parameters

x NDArray

Angles in degrees.

dtype Type

The dtype the returned ndarray should be of.

Returns

NDArray

The corresponding angle in radians. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.deg2rad.html

degrees(NDArray, NDArray, NDArray, NPTypeCode?)

Convert angles from radians to degrees. Alias for rad2deg.

public static NDArray degrees(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Angle in radians.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of.

Returns

NDArray

The corresponding angle in degrees. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.degrees.html

degrees(NDArray, NPTypeCode)

Alias for rad2deg — positional-dtype convenience overload.

public static NDArray degrees(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

dtype NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.degrees.html

degrees(NDArray, Type)

Convert angles from radians to degrees. Alias for rad2deg.

public static NDArray degrees(NDArray x, Type dtype)

Parameters

x NDArray

Angle in radians.

dtype Type

The dtype the returned ndarray should be of.

Returns

NDArray

The corresponding angle in degrees. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.degrees.html

delete(NDArray, NDArray, int?)

NDArray-typed obj dispatch — selects the integer-array path or the boolean-mask path based on obj.GetTypeCode. 0-D and 1-element integer arrays collapse to the scalar-index fast path (matching NumPy's obj.size == 1 and obj.dtype.kind in "ui": obj = obj.item()).

public static NDArray delete(NDArray arr, NDArray obj, int? axis = null)

Parameters

arr NDArray

obj NDArray

axis int?

Returns

NDArray

delete(NDArray, Slice, int?)

Slice-index overload. obj is interpreted via Python slice.indices(N) against the axis length.

public static NDArray delete(NDArray arr, Slice obj, int? axis = null)

Parameters

arr NDArray

obj Slice

axis int?

Returns

NDArray

delete(NDArray, bool[], int?)

Bool-array overload — values are interpreted as a keep-mask inversion. Length must match the targeted axis size (NumPy raises ValueError otherwise).

public static NDArray delete(NDArray arr, bool[] obj, int? axis = null)

Parameters

arr NDArray

obj bool[]

axis int?

Returns

NDArray

delete(NDArray, int, int?)

Return a new array with the element at obj along axis removed.

public static NDArray delete(NDArray arr, int obj, int? axis = null)

Parameters

arr NDArray

Input array.

obj int

Integer index of the position to remove. Accepts negative indices (counted from the end). Raises IndexOutOfRangeException when out of bounds for the selected axis.

axis int?

Axis along which to delete. null (default) flattens arr first and returns a 1-D result.

Returns

NDArray

A C-contiguous copy of arr with one sub-array removed along axis.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.delete.html

delete(NDArray, int[], int?)

Array-of-indices overload. Negative indices are normalized; duplicates are silently collapsed (each axis position is removed at most once).

public static NDArray delete(NDArray arr, int[] obj, int? axis = null)

Parameters

arr NDArray

obj int[]

axis int?

Returns

NDArray

delete(NDArray, long, int?)

Long-index overload of delete(NDArray, int, int?).

public static NDArray delete(NDArray arr, long obj, int? axis = null)

Parameters

arr NDArray

obj long

axis int?

Returns

NDArray

delete(NDArray, long[], int?)

Long-array-of-indices overload.

public static NDArray delete(NDArray arr, long[] obj, int? axis = null)

Parameters

arr NDArray

obj long[]

axis int?

Returns

NDArray

diagonal(NDArray, int, int, int)

Return specified diagonals of a. For a 2-D array, returns the diagonal as a 1-D array. For an N-D array, the last two axes (default axis1=0, axis2=1) define the 2-D sub-arrays from which diagonals are taken; the diagonal is appended as the last axis of the returned array.

public static NDArray diagonal(NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1)

Parameters

a NDArray

Source array. Must have at least 2 dimensions.

offset int

Offset of the diagonal from the main diagonal. Positive values refer to diagonals above the main, negative below. Default 0.

axis1 int

First axis of the 2-D sub-array. Default 0.

axis2 int

Second axis of the 2-D sub-array. Default 1.

Returns

NDArray

A read-only view sharing storage with a. Shape: a.shape with axis1 and axis2 removed and the diagonal appended as the last axis.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.diagonal.html

Mirrors NumPy's PyArray_Diagonal (item_selection.c). The view trick: combining the two strides into one stride[axis1] + stride[axis2] walks the diagonal in one step. Read-only by NumPy contract (the writeable-by-default change pencilled in for NumPy 1.10 hasn't shipped in 2.x).

diff(NDArray, int, int, object, object)

Calculate the n-th discrete difference along the given axis. The first difference is out[i] = a[i+1] - a[i]; higher differences are computed recursively.

public static NDArray diff(NDArray a, int n = 1, int axis = -1, object prepend = null, object append = null)

Parameters

a NDArray

Input array (must be at least one dimensional).

n int

The number of times values are differenced. If zero, the input is returned as-is. Must be non-negative.

axis int

The axis along which the difference is taken; default is the last axis. Negative axes count from the end.

prepend object

Value(s) to prepend to a along axis prior to differencing. Scalars expand to length 1 along the axis. null means "not supplied" (NumPy's np._NoValue).

append object

Value(s) to append to a along axis prior to differencing. Scalars expand to length 1 along the axis. null means "not supplied".

Returns

NDArray

The n-th differences. The shape matches the (optionally prepend/append-extended) input except along axis where the size shrinks by n. The dtype is preserved (boolean input yields boolean output via not_equal).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.diff.html

divide(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

public static NDArray divide(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

x2 NDArray

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.divide.html

dot(NDArray, NDArray)

Dot product of two arrays. See remarks.

public static NDArray dot(NDArray a, NDArray b)

Parameters

a NDArray

Lhs, First argument.

b NDArray

Rhs, Second argument.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.dot.html
Specifically,
- If both a and b are 1-D arrays, it is inner product of vectors (without complex conjugation).
- If both a and b are 2-D arrays, it is matrix multiplication, but using matmul or a @ b is preferred.
- If either a or b is 0-D(scalar), it is equivalent to multiply and using numpy.multiply(a, b) or a* b is preferred.
- If a is an N-D array and b is a 1-D array, it is a sum product over the last axis of a and b.
- If a is an N-D array and b is an M-D array(where M>=2), it is a sum product over the last axis of a and the second-to-last axis of b:
dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

dsplit(NDArray, int)

Split array into multiple sub-arrays along the 3rd axis (depth).

public static NDArray[] dsplit(NDArray ary, int indices_or_sections)

Parameters

ary NDArray

Array to be divided into sub-arrays.

indices_or_sections int

If an integer, N, the array will be divided into N equal arrays along axis 2. If such a split is not possible, an error is raised.

Returns

NDArray[]

A list of sub-arrays as views into ary.

Remarks

Equivalent to split with axis=2. Array must have ndim >= 3. https://numpy.org/doc/stable/reference/generated/numpy.dsplit.html

dsplit(NDArray, int[])

Split array into multiple sub-arrays along the 3rd axis (depth).

public static NDArray[] dsplit(NDArray ary, int[] indices)

Parameters

ary NDArray

Array to be divided into sub-arrays.

indices int[]

A 1-D array of sorted integers indicating where along axis 2 the array is split. For example, [2, 3] would result in ary[:,:,:2], ary[:,:,2:3], ary[:,:,3:].

Returns

NDArray[]

A list of sub-arrays as views into ary.

Remarks

Equivalent to split with axis=2. Array must have ndim >= 3. https://numpy.org/doc/stable/reference/generated/numpy.dsplit.html

dstack(params NDArray[])

Stack arrays in sequence depth wise (along third axis). This is equivalent to concatenation along the third axis after 2-D arrays of shape(M, N) have been reshaped to(M, N,1) and 1-D arrays of shape(N,) have been reshaped to(1, N,1). Rebuilds arrays divided by dsplit. This function makes most sense for arrays with up to 3 dimensions.For instance, for pixel-data with a height(first axis), width(second axis), and r/g/b channels(third axis). The functions concatenate, stack and block provide more general stacking and concatenation operations.

public static NDArray dstack(params NDArray[] tup)

Parameters

tup NDArray[]

The arrays must have the same shape along all but the third axis. 1-D or 2-D arrays must have the same shape.

Returns

NDArray

The array formed by stacking the given arrays, will be at least 3-D.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.dstack.html

dtype(string)

Parse a string into a DType. 1:1 NumPy 2.x parity (with adaptations documented in NumSharp.np._dtype_string_map).

public static DType dtype(string dtype)

Parameters

dtype string

Any NumPy-style dtype string (e.g. "int8", "f4", "<i2", "complex128").

Returns

DType

Matching DType.

Remarks

https://numpy.org/doc/stable/reference/arrays.dtypes.html

Exceptions

NotSupportedException

Thrown for valid-NumPy types NumSharp doesn't implement (S, U, M, m, O, V, a, c=S1), or for syntactically invalid strings (e.g. "f16", "b4", "xyz").

ediff1d(NDArray, object, object)

The differences between consecutive elements of an array. The input is flattened first; the result is always 1-D.

public static NDArray ediff1d(NDArray ary, object to_end = null, object to_begin = null)

Parameters

ary NDArray

Input array (flattened before differencing).

to_end object

Number(s) to append to the end of the returned differences. null means none. Cast to ary's dtype under the same_kind casting rule.

to_begin object

Number(s) to prepend to the beginning of the returned differences. null means none. Cast to ary's dtype under the same_kind casting rule.

Returns

NDArray

1-D array of consecutive differences (input dtype), optionally bracketed by to_begin and to_end.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ediff1d.html

empty(Shape)

Return a new array of given shape and type, without initializing entries.

public static NDArray empty(Shape shape)

Parameters

shape Shape

Shape of the empty array, e.g., (2, 3) or 2.

Returns

NDArray

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty.html

empty(Shape, NPTypeCode)

Return a new array of given shape and type, without initializing entries.

public static NDArray empty(Shape shape, NPTypeCode typeCode)

Parameters

shape Shape

Shape of the empty array, e.g., (2, 3) or 2.

typeCode NPTypeCode

Desired output data-type for the array, e.g, numpy.int8. Default is numpy.float64.

Returns

NDArray

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty.html

empty(Shape, char, Type)

Return a new array of given shape and type with a specified memory layout.

public static NDArray empty(Shape shape, char order, Type dtype = null)

Parameters

shape Shape

Shape of the empty array, e.g., (2, 3) or 2.

order char

Memory layout: 'C' (row-major), 'F' (column-major), 'A' (any), 'K' (keep). With no source array, 'A' and 'K' default to 'C'.

dtype Type

Desired output data-type. Default is numpy.float64.

Returns

NDArray

Array of uninitialized data with the requested memory layout.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty.html

empty(Shape, Type)

Return a new array of given shape and type, without initializing entries.

public static NDArray empty(Shape shape, Type dtype)

Parameters

shape Shape

Shape of the empty array, e.g., (2, 3) or 2.

dtype Type

Desired output data-type for the array, e.g, numpy.int8. Default is numpy.float64.

Returns

NDArray

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty.html

empty(int)

Return a new array of given shape and type, without initializing entries.

public static NDArray empty(int shape)

Parameters

shape int

Returns

NDArray

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty.html

empty(int[])

Return a new array of given shape and type, without initializing entries.

public static NDArray empty(int[] shape)

Parameters

shape int[]

Shape of the empty array, e.g., (2, 3) or 2.

Returns

NDArray

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty.html

empty(long[])

Return a new array of given shape and type, without initializing entries.

public static NDArray empty(long[] shape)

Parameters

shape long[]

Shape of the empty array, e.g., (2, 3) or 2.

Returns

NDArray

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty.html

empty_like(NDArray, NPTypeCode, Shape)

Return a new array with the same shape and type as a given array.

public static NDArray empty_like(NDArray prototype, NPTypeCode typeCode, Shape shape = default)

Parameters

prototype NDArray

The shape and data-type of prototype define these same attributes of the returned array.

typeCode NPTypeCode

Overrides the data type of the result.

shape Shape

Overrides the shape of the result.

Returns

NDArray

Array of uninitialized (arbitrary) data with the same shape and type as prototype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty_like.html

empty_like(NDArray, NPTypeCode, Shape, char)

Return a new array with the same shape and type as a given array.

public static NDArray empty_like(NDArray prototype, NPTypeCode typeCode, Shape shape, char order)

Parameters

prototype NDArray

The shape and data-type of prototype define these same attributes of the returned array.

typeCode NPTypeCode

Overrides the data type of the result.

shape Shape

Overrides the shape of the result.

order char

Memory layout: 'C', 'F', 'A' or 'K' (default, preserves prototype layout).

Returns

NDArray

Array of uninitialized (arbitrary) data with the same shape and type as prototype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty_like.html

empty_like(NDArray, Type, Shape)

Return a new array with the same shape and type as a given array.

public static NDArray empty_like(NDArray prototype, Type dtype = null, Shape shape = default)

Parameters

prototype NDArray

The shape and data-type of prototype define these same attributes of the returned array.

dtype Type

Overrides the data type of the result.

shape Shape

Overrides the shape of the result.

Returns

NDArray

Array of uninitialized (arbitrary) data with the same shape and type as prototype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty_like.html

empty_like(NDArray, Type, Shape, char)

Return a new array with the same shape and type as a given array.

public static NDArray empty_like(NDArray prototype, Type dtype, Shape shape, char order)

Parameters

prototype NDArray

The shape and data-type of prototype define these same attributes of the returned array.

dtype Type

Overrides the data type of the result.

shape Shape

Overrides the shape of the result.

order char

Memory layout: 'C', 'F', 'A' or 'K' (default, preserves prototype layout).

Returns

NDArray

Array of uninitialized (arbitrary) data with the same shape and type as prototype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty_like.html

empty<T>(int[])

Return a new array of given shape and type, without initializing entries.

public static NDArray empty<T>(int[] shape)

Parameters

shape int[]

Shape of the empty array, e.g., (2, 3) or 2.

Returns

NDArray

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.

Type Parameters

T

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty.html

empty<T>(long[])

Return a new array of given shape and type, without initializing entries.

public static NDArray empty<T>(long[] shape)

Parameters

shape long[]

Shape of the empty array, e.g., (2, 3) or 2.

Returns

NDArray

Array of uninitialized (arbitrary) data of the given shape, dtype, and order. Object arrays will be initialized to None.

Type Parameters

T

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.empty.html

equal(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Return (x1 == x2) element-wise. Mirrors NumPy's ufunc signature: equal(x1, x2, /, out=None, *, where=True, dtype=None). A plain call returns a bool-dtype array (the instance is an NDArray<TDType> of bool — cast or use the == operator for the typed wrapper).

public static NDArray equal(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

Input array.

x2 NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written; masked-off out slots keep prior contents.

dtype NPTypeCode?

Validate-only (NumPy parity): comparisons have bool loops only — any non-bool request raises the no-loop TypeError.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.equal.html

equal(NDArray, object)

Return (x1 == x2) element-wise with scalar.

public static NDArray<bool> equal(NDArray x1, object x2)

Parameters

x1 NDArray

Input array.

x2 object

Scalar or array-like value.

Returns

NDArray<bool>

Output array of bools.

equal(object, NDArray)

Return (x1 == x2) element-wise with scalar on left.

public static NDArray<bool> equal(object x1, NDArray x2)

Parameters

x1 object

Scalar or array-like value.

x2 NDArray

Input array.

Returns

NDArray<bool>

Output array of bools.

evaluate(NDExpr, NDArray)

Evaluate an expression tree over NDArrays in ONE fused pass — no intermediate arrays, one read of each operand, one write of the result (NumSharp extension; the NumPy-ecosystem equivalent is numexpr.evaluate).

public static NDArray evaluate(NDExpr expr, NDArray @out = null)

Parameters

expr NDExpr

Expression with embedded array leaves. NDArrays convert implicitly, so one cast lights up the whole operator set:

NDArray r = np.evaluate((NDExpr)a * b + 2);            // a*b+2 fused
NDArray d = np.evaluate((NDExpr.Arr(a) - b) / (NDExpr.Arr(a) + b));
NDArray s = np.evaluate(NDExpr.Sum((NDExpr)a * b));   // one-pass sum(a*b)

A repeated NDArray reference becomes ONE iterator operand.

out NDArray

Optional pre-allocated result (ufunc out= rules: joins the broadcast but is never stretched; same_kind cast from the resolved dtype; may alias an input — overlap-safe).

Returns

NDArray

The evaluated array at the tree's NumPy result_type — dtypes match the equivalent unfused NumPy expression node-for-node (NEP50, including weak python-scalar literals). Root reductions (Sum(NDExpr) / Prod / Min / Max / Mean) return a 0-d scalar array.

evaluate(NDExpr, NDArray[], NDArray)

Evaluate an expression built over positional Input(int) leaves against an explicit operand list: np.evaluate(NDExpr.Input(0) * NDExpr.Input(1), new[] { a, b }).

public static NDArray evaluate(NDExpr expr, NDArray[] operands, NDArray @out = null)

Parameters

expr NDExpr

operands NDArray[]

out NDArray

Returns

NDArray

exp(NDArray)

Base-e exponential, element-wise.

public static NDArray exp(NDArray a)

Parameters

a NDArray

Input value.

Returns

NDArray

The natural logarithm of x, element-wise. This is a scalar NDArray.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.exp.html

exp(NDArray, NDArray, NDArray, NPTypeCode?)

Calculate the exponential of all elements in the input array. Mirrors NumPy's ufunc signature: exp(x, /, out=None, *, where=True, dtype=None).

public static NDArray exp(NDArray a, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Input value.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the computation runs at this precision; integer/bool requests raise NumPy's "No loop matching" error.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.exp.html

exp(NDArray, NPTypeCode)

Base-e exponential, element-wise.

public static NDArray exp(NDArray a, NPTypeCode typeCode)

Parameters

a NDArray

Input value.

typeCode NPTypeCode

The dtype of the returned NDArray

Returns

NDArray

The natural logarithm of x, element-wise. This is a scalar NDArray.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.exp.html

exp(NDArray, Type)

Base-e exponential, element-wise.

public static NDArray exp(NDArray a, Type dtype)

Parameters

a NDArray

Input value.

dtype Type

The dtype of the returned NDArray

Returns

NDArray

The natural logarithm of x, element-wise. This is a scalar NDArray.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.exp.html

exp2(NDArray)

Calculate 2**p for all p in the input array.

public static NDArray exp2(NDArray a)

Parameters

a NDArray

Input value.

Returns

NDArray

Element-wise 2 to the power x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.exp2.html

exp2(NDArray, NDArray, NDArray, NPTypeCode?)

Mirrors NumPy's ufunc signature: exp2(x, /, out=None, *, where=True, dtype=None).

public static NDArray exp2(NDArray a, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): selects the loop; the input must be same_kind-castable to it.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.exp2.html

exp2(NDArray, NPTypeCode)

Calculate 2**p for all p in the input array.

public static NDArray exp2(NDArray a, NPTypeCode typeCode)

Parameters

a NDArray

Input value.

typeCode NPTypeCode

Returns

NDArray

Element-wise 2 to the power x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.exp2.html

exp2(NDArray, Type)

Calculate 2**p for all p in the input array.

public static NDArray exp2(NDArray a, Type dtype)

Parameters

a NDArray

Input value.

dtype Type

Returns

NDArray

Element-wise 2 to the power x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.exp2.html

expand_dims(NDArray, IEnumerable<int>)

Sequence overload — accepts any IEnumerable<T>, materializes to an array, and delegates to the tuple-axis path.

public static NDArray expand_dims(NDArray a, IEnumerable<int> axis)

Parameters

a NDArray

axis IEnumerable<int>

Returns

NDArray

expand_dims(NDArray, int)

public static NDArray expand_dims(NDArray a, int axis)

Parameters

a NDArray

axis int

Returns

NDArray

expand_dims(NDArray, int[])

Expand the shape of an array. Insert new axes that will appear at the axis positions in the expanded output.

public static NDArray expand_dims(NDArray a, int[] axis)

Parameters

a NDArray

axis int[]

Returns

NDArray

Remarks

Matches NumPy 2.x: each axis in the tuple is normalized against the FINAL output ndim (a.ndim + axis.Length). Duplicate normalized positions raise ArgumentException ("repeated axis"); out-of-range axes throw the same. Empty axis returns the input unchanged.

expm1(NDArray)

Calculate exp(x) - 1 for all elements in the array.

public static NDArray expm1(NDArray a)

Parameters

a NDArray

Input value.

Returns

NDArray

Element-wise exponential minus one: out = exp(x) - 1. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.expm1.html

expm1(NDArray, NDArray, NDArray, NPTypeCode?)

Mirrors NumPy's ufunc signature: expm1(x, /, out=None, *, where=True, dtype=None).

public static NDArray expm1(NDArray a, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): selects the loop; the input must be same_kind-castable to it.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.expm1.html

expm1(NDArray, NPTypeCode)

Calculate exp(x) - 1 for all elements in the array.

public static NDArray expm1(NDArray a, NPTypeCode typeCode)

Parameters

a NDArray

Input value.

typeCode NPTypeCode

Returns

NDArray

Element-wise exponential minus one: out = exp(x) - 1. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.expm1.html

expm1(NDArray, Type)

Calculate exp(x) - 1 for all elements in the array.

public static NDArray expm1(NDArray a, Type dtype)

Parameters

a NDArray

Input value.

dtype Type

Returns

NDArray

Element-wise exponential minus one: out = exp(x) - 1. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.expm1.html

extract(NDArray, NDArray)

Return the elements of arr that satisfy some condition. Equivalent to np.take(np.ravel(arr), np.flatnonzero(np.ravel(condition))) — i.e. arr.ravel()[condition.ravel()] when condition is boolean.

public static NDArray extract(NDArray condition, NDArray arr)

Parameters

condition NDArray

Array whose nonzero / True entries indicate the elements of arr to extract. May be any dtype (treated as truthy via NumPy's "nonzero" semantics). May be any shape — it is ravel'd before alignment with arr.

arr NDArray

Input array. May be any shape; it is ravel'd.

Returns

NDArray

Rank-1 NDArray of values from arr where the corresponding ravel'd condition entry is truthy. Dtype matches arr.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.extract.html

Two execution paths:

• Fast path: bool condition, contig arr + condition, condition.size <= arr.size. Runs a fused IL kernel (popcount → alloc → SIMD bit-scan + cpblk) avoiding the indices NDArray allocation that the generic path needs.
• Generic path: mirrors NumPy's literal chain take(ravel(arr), flatnonzero(ravel(condition))). Handles non-bool conditions (any dtype interpreted as nonzero), broadcast / strided / negative-stride sources, and the OOB-True case (raises via take's RAISE mode).

Note that place(NDArray, NDArray, NDArray) is the inverse operation.

eye(int, int?, int, Type, char)

Return a 2-D array with ones on the diagonal and zeros elsewhere.

public static NDArray eye(int N, int? M = null, int k = 0, Type dtype = null, char order = 'C')

Parameters

N int

Number of rows in the output.

M int?

Number of columns in the output. If None, defaults to N.

k int

Index of the diagonal: 0 (the default) refers to the main diagonal, a positive value refers to an upper diagonal, and a negative value to a lower diagonal.

dtype Type

Data-type of the returned array.

order char

Memory layout: 'C' (row-major, default) or 'F' (column-major).

Returns

NDArray

An array where all elements are equal to zero, except for the k-th diagonal, whose values are equal to one.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.eye.html

find_common_type(NPTypeCode[], NPTypeCode[])

Determine common type following standard coercion rules.

public static NPTypeCode find_common_type(NPTypeCode[] array_types, NPTypeCode[] scalar_types)

Parameters

array_types NPTypeCode[]

A list of dtypes or dtype convertible objects representing arrays. Can be null.

scalar_types NPTypeCode[]

A list of dtypes or dtype convertible objects representing scalars.Can be null.

Returns

NPTypeCode

The common data type, which is the maximum of array_types ignoring scalar_types, unless the maximum of scalar_types is of a different kind (dtype.kind). If the kind is not understood, then None is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.result_type.html

find_common_type(NPTypeCode[], Type[])

Determine common type following standard coercion rules.

public static NPTypeCode find_common_type(NPTypeCode[] array_types, Type[] scalar_types)

Parameters

array_types NPTypeCode[]

A list of dtypes or dtype convertible objects representing arrays. Can be null.

scalar_types Type[]

A list of dtypes or dtype convertible objects representing scalars.Can be null.

Returns

NPTypeCode

The common data type, which is the maximum of array_types ignoring scalar_types, unless the maximum of scalar_types is of a different kind (dtype.kind). If the kind is not understood, then None is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.result_type.html

find_common_type(params string[])

Resolves to which type should the output be.

public static NPTypeCode find_common_type(params string[] involvedTypes)

Parameters

involvedTypes string[]

Returns

NPTypeCode

find_common_type(string[], string[])

Determine common type following standard coercion rules.

public static NPTypeCode find_common_type(string[] array_types, string[] scalar_types)

Parameters

array_types string[]

A list of dtypes or dtype convertible objects representing arrays. Can be null.

scalar_types string[]

A list of dtypes or dtype convertible objects representing scalars.Can be null.

Returns

NPTypeCode

The common data type, which is the maximum of array_types ignoring scalar_types, unless the maximum of scalar_types is of a different kind (dtype.kind). If the kind is not understood, then None is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.result_type.html

find_common_type(Type[])

Determine common type following standard coercion rules.

public static NPTypeCode find_common_type(Type[] array_types)

Parameters

array_types Type[]

A list of dtypes or dtype convertible objects representing arrays. Can be null.

Returns

NPTypeCode

The common data type, which is the maximum of array_types ignoring scalar_types, unless the maximum of scalar_types is of a different kind (dtype.kind). If the kind is not understood, then None is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.result_type.html

find_common_type(Type[], NPTypeCode[])

Determine common type following standard coercion rules.

public static NPTypeCode find_common_type(Type[] array_types, NPTypeCode[] scalar_types)

Parameters

array_types Type[]

A list of dtypes or dtype convertible objects representing arrays. Can be null.

scalar_types NPTypeCode[]

A list of dtypes or dtype convertible objects representing scalars.Can be null.

Returns

NPTypeCode

The common data type, which is the maximum of array_types ignoring scalar_types, unless the maximum of scalar_types is of a different kind (dtype.kind). If the kind is not understood, then None is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.result_type.html

find_common_type(Type[], Type[])

Determine common type following standard coercion rules.

public static NPTypeCode find_common_type(Type[] array_types, Type[] scalar_types)

Parameters

array_types Type[]

A list of dtypes or dtype convertible objects representing arrays. Can be null.

scalar_types Type[]

A list of dtypes or dtype convertible objects representing scalars.Can be null.

Returns

NPTypeCode

The common data type, which is the maximum of array_types ignoring scalar_types, unless the maximum of scalar_types is of a different kind (dtype.kind). If the kind is not understood, then None is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.result_type.html

finfo(NDArray)

Machine limits for floating point types.

public static finfo finfo(NDArray arr)

Parameters

arr NDArray

An NDArray with floating point dtype.

Returns

finfo

An finfo object describing the array's floating point type limits.

Examples

var a = np.array(new double[] {1.0, 2.0, 3.0});
var info = np.finfo(a);
Console.WriteLine(info.bits);  // 64

Exceptions

ArgumentNullException

Thrown if arr is null.

finfo(NPTypeCode)

Machine limits for floating point types.

public static finfo finfo(NPTypeCode typeCode)

Parameters

typeCode NPTypeCode

A floating point type code.

Returns

finfo

An finfo object describing the floating point type limits.

Examples

var info = np.finfo(NPTypeCode.Double);
Console.WriteLine(info.bits);       // 64
Console.WriteLine(info.eps);        // ~2.22e-16
Console.WriteLine(info.precision);  // 15

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.finfo.html

finfo(string)

Machine limits for floating point types.

public static finfo finfo(string dtypeName)

Parameters

dtypeName string

A dtype string (e.g., "float32", "float64", "double").

Returns

finfo

An finfo object describing the floating point type limits.

Examples

var info = np.finfo("float64");
Console.WriteLine(info.bits);  // 64

Exceptions

ArgumentException

Thrown if dtypeName is not a valid floating point dtype.

finfo(Type)

Machine limits for floating point types.

public static finfo finfo(Type type)

Parameters

type Type

A CLR floating point type.

Returns

finfo

An finfo object describing the floating point type limits.

finfo<T>()

Machine limits for floating point types.

public static finfo finfo<T>() where T : struct

Returns

finfo

An finfo object describing the floating point type limits.

Type Parameters

T

A floating point type (float, double, decimal).

Examples

var info = np.finfo<double>();
Console.WriteLine(info.bits);  // 64

flatnonzero(NDArray)

Return indices that are non-zero in the flattened version of a. This is equivalent to np.nonzero(np.ravel(a))[0].

public static NDArray<long> flatnonzero(NDArray a)

Parameters

a NDArray

Input data.

Returns

NDArray<long>

1-D NDArray<TDType> of long (NumPy intp) containing the indices of elements of a.ravel() that are non-zero. For 0-d input, returns [0] when the value is truthy and an empty array otherwise. For empty input, returns an empty 1-D array.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.flatnonzero.html

Faster than the literal composition nonzero(ravel(a))[0]: the engine runs the SIMD popcount + bit-scan straight into the 1-D result buffer without materializing the per-axis coordinate arrays produced by nonzero(NDArray). For multi-dim inputs the cost is the same as a 1-D input of equal element count (the layout is collapsed by materializing to C-contig when needed).

floor(NDArray, NDArray, NDArray, NPTypeCode?)

public static NDArray floor(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

floor(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray floor(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.floor.html

floor(NDArray, Type)

public static NDArray floor(NDArray x, Type dtype)

Parameters

x NDArray

dtype Type

Returns

NDArray

floor_divide(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Return the largest integer smaller or equal to the division of the inputs. It is equivalent to the Python // operator. Mirrors NumPy's ufunc signature: floor_divide(x1, x2, /, out=None, *, where=True, dtype=None).

public static NDArray floor_divide(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

Dividend array.

x2 NDArray

Divisor array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the computation runs in this dtype; inputs must be same_kind-castable to it.

Returns

NDArray

y = floor(x1/x2). This is a scalar if both x1 and x2 are scalars.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.floor_divide.html

floor_divide(NDArray, NDArray, NPTypeCode)

Return the largest integer smaller or equal to the division of the inputs. It is equivalent to the Python // operator.

public static NDArray floor_divide(NDArray x1, NDArray x2, NPTypeCode typeCode)

Parameters

x1 NDArray

Dividend array.

x2 NDArray

Divisor array.

typeCode NPTypeCode

The dtype of the returned NDArray.

Returns

NDArray

y = floor(x1/x2). This is a scalar if both x1 and x2 are scalars.

floor_divide(NDArray, NDArray, Type)

Return the largest integer smaller or equal to the division of the inputs. It is equivalent to the Python // operator.

public static NDArray floor_divide(NDArray x1, NDArray x2, Type dtype)

Parameters

x1 NDArray

Dividend array.

x2 NDArray

Divisor array.

dtype Type

The dtype of the returned NDArray.

Returns

NDArray

y = floor(x1/x2). This is a scalar if both x1 and x2 are scalars.

floor_divide(NDArray, object)

Return the largest integer smaller or equal to the division of the inputs. Scalar or array-like divisor version.

public static NDArray floor_divide(NDArray x1, object x2)

Parameters

x1 NDArray

Dividend array.

x2 object

Scalar or array-like divisor.

Returns

NDArray

y = floor(x1/x2).

floor_divide(NDArray, object, NPTypeCode)

Return the largest integer smaller or equal to the division of the inputs. Scalar or array-like divisor version.

public static NDArray floor_divide(NDArray x1, object x2, NPTypeCode typeCode)

Parameters

x1 NDArray

Dividend array.

x2 object

Scalar or array-like divisor.

typeCode NPTypeCode

The dtype of the returned NDArray.

Returns

NDArray

y = floor(x1/x2).

floor_divide(NDArray, object, Type)

Return the largest integer smaller or equal to the division of the inputs. Scalar or array-like divisor version.

public static NDArray floor_divide(NDArray x1, object x2, Type dtype)

Parameters

x1 NDArray

Dividend array.

x2 object

Scalar or array-like divisor.

dtype Type

The dtype of the returned NDArray.

Returns

NDArray

y = floor(x1/x2).

fmax(NDArray, NDArray, NDArray)

Element-wise maximum of array elements, ignoring NaNs, writing into @out.

public static NDArray fmax(NDArray x1, NDArray x2, NDArray @out)

Parameters

x1 NDArray

x2 NDArray

out NDArray

Returns

NDArray

fmax(NDArray, NDArray, NPTypeCode?)

Element-wise maximum of array elements, ignoring NaNs. 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 net effect is that NaNs are ignored when possible.

public static NDArray fmax(NDArray x1, NDArray x2, NPTypeCode? dtype = null)

Parameters

x1 NDArray

The arrays holding the elements to be compared. If x1.shape != x2.shape, they must be broadcastable to a common shape (which becomes the shape of the output).

x2 NDArray

The arrays holding the elements to be compared. If x1.shape != x2.shape, they must be broadcastable to a common shape (which becomes the shape of the output).

dtype NPTypeCode?

Loop dtype (NumPy ufunc dtype=): the comparison runs at this precision.

Returns

NDArray

The maximum of x1 and x2, element-wise, ignoring NaNs.

fmax(NDArray, NDArray, Type)

Element-wise maximum of array elements, ignoring NaNs. See fmax(NDArray, NDArray, NPTypeCode?).

public static NDArray fmax(NDArray x1, NDArray x2, Type dtype)

Parameters

x1 NDArray

x2 NDArray

dtype Type

Returns

NDArray

fmin(NDArray, NDArray, NDArray)

Element-wise minimum of array elements, ignoring NaNs, writing into @out.

public static NDArray fmin(NDArray x1, NDArray x2, NDArray @out)

Parameters

x1 NDArray

x2 NDArray

out NDArray

Returns

NDArray

fmin(NDArray, NDArray, NPTypeCode?)

Element-wise minimum of array elements, ignoring NaNs. 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 net effect is that NaNs are ignored when possible.

public static NDArray fmin(NDArray x1, NDArray x2, NPTypeCode? dtype = null)

Parameters

x1 NDArray

The arrays holding the elements to be compared. If x1.shape != x2.shape, they must be broadcastable to a common shape (which becomes the shape of the output).

x2 NDArray

The arrays holding the elements to be compared. If x1.shape != x2.shape, they must be broadcastable to a common shape (which becomes the shape of the output).

dtype NPTypeCode?

Loop dtype (NumPy ufunc dtype=): the comparison runs at this precision.

Returns

NDArray

The minimum of x1 and x2, element-wise, ignoring NaNs.

fmin(NDArray, NDArray, Type)

Element-wise minimum of array elements, ignoring NaNs. See fmin(NDArray, NDArray, NPTypeCode?).

public static NDArray fmin(NDArray x1, NDArray x2, Type dtype)

Parameters

x1 NDArray

x2 NDArray

dtype Type

Returns

NDArray

format_float_positional(double, int?, bool, bool, char, bool, int?, int?, int?)

Format a floating-point scalar as a decimal string in positional notation (NumPy's np.format_float_positional).

public static string format_float_positional(double x, int? precision = null, bool unique = true, bool fractional = true, char trim = 'k', bool sign = false, int? pad_left = null, int? pad_right = null, int? min_digits = null)

Parameters

x double

precision int?

unique bool

fractional bool

trim char

sign bool

pad_left int?

pad_right int?

min_digits int?

Returns

string

format_float_scientific(double, int?, bool, char, bool, int?, int?, int?)

Format a floating-point scalar as a decimal string in scientific notation (NumPy's np.format_float_scientific).

public static string format_float_scientific(double x, int? precision = null, bool unique = true, char trim = 'k', bool sign = false, int? pad_left = null, int? exp_digits = null, int? min_digits = null)

Parameters

x double

precision int?

unique bool

trim char

sign bool

pad_left int?

exp_digits int?

min_digits int?

Returns

string

frombuffer(ArraySegment<byte>, NPTypeCode, long)

Interpret an ArraySegment as a 1-dimensional array.

public static NDArray frombuffer(ArraySegment<byte> segment, NPTypeCode dtype, long count = -1)

Parameters

segment ArraySegment<byte>

dtype NPTypeCode

count long

Returns

NDArray

frombuffer(ArraySegment<byte>, Type, long)

Interpret an ArraySegment as a 1-dimensional array. Uses the segment's Offset and Count automatically.

public static NDArray frombuffer(ArraySegment<byte> segment, Type dtype = null, long count = -1)

Parameters

segment ArraySegment<byte>

The array segment to interpret.

dtype Type

Data-type of the returned array. Default is float64.

count long

Number of items to read. -1 means all data in the segment.

Returns

NDArray

1-dimensional NDArray viewing the segment's data.

frombuffer(byte[], NPTypeCode, long, long)

Interpret a buffer as a 1-dimensional array.

public static NDArray frombuffer(byte[] buffer, NPTypeCode dtype, long count = -1, long offset = 0)

Parameters

buffer byte[]

An object that exposes the buffer interface.

dtype NPTypeCode

Data-type of the returned array. Default is float64.

count long

Number of items to read. -1 means all data in the buffer.

offset long

Start reading the buffer from this offset (in bytes). Default is 0.

Returns

NDArray

1-dimensional NDArray with data interpreted from the buffer.

frombuffer(byte[], string, long, long)

Interpret a buffer as a 1-dimensional array.

public static NDArray frombuffer(byte[] buffer, string dtype, long count = -1, long offset = 0)

Parameters

buffer byte[]

An object that exposes the buffer interface.

dtype string

Data-type string (e.g., ">u4" for big-endian uint32).

count long

Number of items to read. -1 means all data in the buffer.

offset long

Start reading the buffer from this offset (in bytes). Default is 0.

Returns

NDArray

1-dimensional NDArray with data interpreted from the buffer.

Remarks

Note: Big-endian dtype strings (">u4", ">i4", etc.) require a COPY to perform byte swapping. Little-endian and native endian create views without copying.

frombuffer(byte[], Type, long, long)

Interpret a buffer as a 1-dimensional array.

public static NDArray frombuffer(byte[] buffer, Type dtype = null, long count = -1, long offset = 0)

Parameters

buffer byte[]

An object that exposes the buffer interface.

dtype Type

Data-type of the returned array. Default is float64.

count long

Number of items to read. -1 means all data in the buffer.

offset long

Start reading the buffer from this offset (in bytes). Default is 0.

Returns

NDArray

1-dimensional NDArray with data interpreted from the buffer.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.frombuffer.html

Like NumPy, this creates a VIEW of the buffer (pins the array, shares memory). Modifications to the NDArray will affect the original buffer. The buffer must stay alive while the NDArray is in use.

frombuffer(nint, long, NPTypeCode, long, long, Action)

Interpret unmanaged memory at a pointer as a 1-dimensional array.

public static NDArray frombuffer(nint address, long byteLength, NPTypeCode dtype, long count = -1, long offset = 0, Action dispose = null)

Parameters

address nint

byteLength long

dtype NPTypeCode

count long

offset long

dispose Action

Returns

NDArray

frombuffer(nint, long, Type, long, long, Action)

Interpret unmanaged memory at a pointer as a 1-dimensional array.

public static NDArray frombuffer(nint address, long byteLength, Type dtype = null, long count = -1, long offset = 0, Action dispose = null)

Parameters

address nint

Pointer to the start of the buffer.

byteLength long

Total length of the buffer in bytes.

dtype Type

Data-type of the returned array. Default is float64.

count long

Number of items to read. -1 means all data.

offset long

Byte offset into the buffer. Default is 0.

dispose Action

Optional cleanup action called when NDArray is disposed. Use to transfer ownership: dispose: () => Marshal.FreeHGlobal(ptr) If null, caller is responsible for memory lifetime (view semantics).

Returns

NDArray

1-dimensional NDArray viewing/owning the memory.

Examples

// View only (caller manages lifetime): var arr = np.frombuffer(ptr, length, typeof(float));

// Take ownership (NumSharp frees on dispose): var ptr = Marshal.AllocHGlobal(1024); var arr = np.frombuffer(ptr, 1024, typeof(float), dispose: () => Marshal.FreeHGlobal(ptr));

frombuffer(Memory<byte>, NPTypeCode, long, long)

Interpret a Memory<byte> as a 1-dimensional array.

public static NDArray frombuffer(Memory<byte> memory, NPTypeCode dtype, long count = -1, long offset = 0)

Parameters

memory Memory<byte>

dtype NPTypeCode

count long

offset long

Returns

NDArray

frombuffer(Memory<byte>, Type, long, long)

Interpret a Memory<byte> as a 1-dimensional array. Creates a view if backed by an array, otherwise copies.

public static NDArray frombuffer(Memory<byte> memory, Type dtype = null, long count = -1, long offset = 0)

Parameters

memory Memory<byte>

The memory to interpret.

dtype Type

Data-type of the returned array. Default is float64.

count long

Number of items to read. -1 means all data.

offset long

Byte offset within the memory. Default is 0.

Returns

NDArray

1-dimensional NDArray.

frombuffer(ReadOnlySpan<byte>, NPTypeCode, long, long)

Interpret a ReadOnlySpan as a 1-dimensional array. Note: ReadOnlySpan cannot be pinned, so this always creates a copy.

public static NDArray frombuffer(ReadOnlySpan<byte> buffer, NPTypeCode dtype, long count = -1, long offset = 0)

Parameters

buffer ReadOnlySpan<byte>

dtype NPTypeCode

count long

offset long

Returns

NDArray

frombuffer(ReadOnlySpan<byte>, Type, long, long)

Interpret a ReadOnlySpan as a 1-dimensional array. Note: ReadOnlySpan cannot be pinned, so this always creates a copy.

public static NDArray frombuffer(ReadOnlySpan<byte> buffer, Type dtype = null, long count = -1, long offset = 0)

Parameters

buffer ReadOnlySpan<byte>

dtype Type

count long

offset long

Returns

NDArray

frombuffer(void*, long, NPTypeCode, long, long, Action)

Interpret unmanaged memory at a pointer as a 1-dimensional array.

public static NDArray frombuffer(void* address, long byteLength, NPTypeCode dtype, long count = -1, long offset = 0, Action dispose = null)

Parameters

address void*

byteLength long

dtype NPTypeCode

count long

offset long

dispose Action

Returns

NDArray

frombuffer(void*, long, Type, long, long, Action)

Interpret unmanaged memory at a pointer as a 1-dimensional array.

public static NDArray frombuffer(void* address, long byteLength, Type dtype = null, long count = -1, long offset = 0, Action dispose = null)

Parameters

address void*

Pointer to the start of the buffer.

byteLength long

Total length of the buffer in bytes.

dtype Type

Data-type of the returned array. Default is float64.

count long

Number of items to read. -1 means all data.

offset long

Byte offset into the buffer. Default is 0.

dispose Action

Optional cleanup action called when NDArray is disposed.

Returns

NDArray

1-dimensional NDArray viewing/owning the memory.

frombuffer<TSource>(TSource[], NPTypeCode, long, long)

Reinterpret a typed array as a different dtype.

public static NDArray frombuffer<TSource>(TSource[] array, NPTypeCode dtype, long count = -1, long offset = 0) where TSource : unmanaged

Parameters

array TSource[]

dtype NPTypeCode

count long

offset long

Returns

NDArray

Type Parameters

TSource

frombuffer<TSource>(TSource[], Type, long, long)

Reinterpret a typed array as a different dtype. Like NumPy's view() but via frombuffer semantics.

public static NDArray frombuffer<TSource>(TSource[] array, Type dtype = null, long count = -1, long offset = 0) where TSource : unmanaged

Parameters

array TSource[]

The source array to reinterpret.

dtype Type

Target data-type. Default preserves source type.

count long

Number of items of target dtype. -1 for all.

offset long

Byte offset. Default is 0.

Returns

NDArray

1-dimensional NDArray viewing the array as the target dtype.

Type Parameters

TSource

Source element type.

Examples

var ints = new int[] { 1, 2, 3, 4 }; var asBytes = np.frombuffer(ints, typeof(byte)); // 16 bytes var asFloats = np.frombuffer(ints, typeof(float)); // 4 floats (same bits)

fromfile(string, NPTypeCode)

Construct an array from data in a text or binary file. A highly efficient way of reading binary data with a known data-type, as well as parsing simply formatted text files. Data written using the tofile method can be read using this function.

public static NDArray fromfile(string file, NPTypeCode dtype)

Parameters

file string

filename.

dtype NPTypeCode

Data type of the returned array. For binary files, it is used to determine the size and byte-order of the items in the file.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.fromfile.html

fromfile(string, Type)

Construct an array from data in a text or binary file. A highly efficient way of reading binary data with a known data-type, as well as parsing simply formatted text files. Data written using the tofile method can be read using this function.

public static NDArray fromfile(string file, Type dtype)

Parameters

file string

filename.

dtype Type

Data type of the returned array. For binary files, it is used to determine the size and byte-order of the items in the file.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.fromfile.html

full(Shape, object, NPTypeCode)

Return a new array of given shape and type, filled with fill_value.

public static NDArray full(Shape shape, object fill_value, NPTypeCode typeCode)

Parameters

shape Shape

Shape of the array, e.g., (2, 3) or 2.

fill_value object

Fill value (scalar).

typeCode NPTypeCode

The desired data-type for the array.

Returns

NDArray

Array of fill_value with the given shape, dtype, and order.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.full.html

full(Shape, object, Type)

Return a new array of given shape and type, filled with fill_value.

public static NDArray full(Shape shape, object fill_value, Type dtype = null)

Parameters

shape Shape

Shape of the array, e.g., (2, 3) or 2.

fill_value object

Fill value (scalar).

dtype Type

The desired data-type for the array. Default infers from fill_value.

Returns

NDArray

Array of fill_value with the given shape, dtype, and order.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.full.html

full(int[], object)

Return a new array of given shape and type, filled with fill_value.

public static NDArray full(int[] shape, object fill_value)

Parameters

shape int[]

Shape of the array, e.g., (2, 3) or 2.

fill_value object

Fill value (scalar).

Returns

NDArray

Array of fill_value with the given shape, dtype, and order.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.full.html

full(long[], object)

Return a new array of given shape and type, filled with fill_value.

public static NDArray full(long[] shape, object fill_value)

Parameters

shape long[]

Shape of the array, e.g., (2, 3) or 2.

fill_value object

Fill value (scalar).

Returns

NDArray

Array of fill_value with the given shape, dtype, and order.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.full.html

full_like(NDArray, object, Type)

Return a full array with the same shape and type as a given array.

public static NDArray full_like(NDArray a, object fill_value, Type dtype = null)

Parameters

a NDArray

The shape and data-type of a define these same attributes of the returned array.

fill_value object

Fill value.

dtype Type

Overrides the data type of the result.

Returns

NDArray

Array of fill_value with the same shape and type as a.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.full_like.html

full_like(NDArray, object, Type, char)

Return a full array with the same shape and type as a given array.

public static NDArray full_like(NDArray a, object fill_value, Type dtype, char order)

Parameters

a NDArray

The shape and data-type of a define these same attributes of the returned array.

fill_value object

Fill value.

dtype Type

Overrides the data type of the result.

order char

Memory layout: 'C', 'F', 'A' or 'K' (default, preserves source layout).

Returns

NDArray

Array of fill_value with the same shape and type as a.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.full_like.html

full<T>(int[], object)

Return a new array of given shape and type, filled with fill_value.

public static NDArray full<T>(int[] shape, object fill_value) where T : unmanaged

Parameters

shape int[]

Shape of the array, e.g., (2, 3) or 2.

fill_value object

Fill value (scalar).

Returns

NDArray

Array of fill_value with the given shape, dtype, and order.

Type Parameters

T

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.full.html

full<T>(long[], object)

Return a new array of given shape and type, filled with fill_value.

public static NDArray full<T>(long[] shape, object fill_value) where T : unmanaged

Parameters

shape long[]

Shape of the array, e.g., (2, 3) or 2.

fill_value object

Fill value (scalar).

Returns

NDArray

Array of fill_value with the given shape, dtype, and order.

Type Parameters

T

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.full.html

get_printoptions()

Return the current print options as a dictionary (NumPy's np.get_printoptions).

public static IReadOnlyDictionary<string, object> get_printoptions()

Returns

IReadOnlyDictionary<string, object>

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.get_printoptions.html

greater(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Return (x1 > x2) element-wise. Mirrors NumPy's ufunc signature: greater(x1, x2, /, out=None, *, where=True, dtype=None). A plain call returns a bool-dtype array (the instance is an NDArray<TDType> of bool — cast or use the > operator for the typed wrapper).

public static NDArray greater(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

Input array.

x2 NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written; masked-off out slots keep prior contents.

dtype NPTypeCode?

Validate-only (NumPy parity): comparisons have bool loops only — any non-bool request raises the no-loop TypeError.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.greater.html

greater(NDArray, object)

Return (x1 > x2) element-wise with scalar.

public static NDArray<bool> greater(NDArray x1, object x2)

Parameters

x1 NDArray

Input array.

x2 object

Scalar or array-like value.

Returns

NDArray<bool>

Output array of bools.

greater(object, NDArray)

Return (x1 > x2) element-wise with scalar on left.

public static NDArray<bool> greater(object x1, NDArray x2)

Parameters

x1 object

Scalar or array-like value.

x2 NDArray

Input array.

Returns

NDArray<bool>

Output array of bools.

greater_equal(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Return (x1 >= x2) element-wise. Mirrors NumPy's ufunc signature: greater_equal(x1, x2, /, out=None, *, where=True, dtype=None). A plain call returns a bool-dtype array (the instance is an NDArray<TDType> of bool — cast or use the >= operator for the typed wrapper).

public static NDArray greater_equal(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

Input array.

x2 NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written; masked-off out slots keep prior contents.

dtype NPTypeCode?

Validate-only (NumPy parity): comparisons have bool loops only — any non-bool request raises the no-loop TypeError.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.greater_equal.html

greater_equal(NDArray, object)

Return (x1 >= x2) element-wise with scalar.

public static NDArray<bool> greater_equal(NDArray x1, object x2)

Parameters

x1 NDArray

Input array.

x2 object

Scalar or array-like value.

Returns

NDArray<bool>

Output array of bools.

greater_equal(object, NDArray)

Return (x1 >= x2) element-wise with scalar on left.

public static NDArray<bool> greater_equal(object x1, NDArray x2)

Parameters

x1 object

Scalar or array-like value.

x2 NDArray

Input array.

Returns

NDArray<bool>

Output array of bools.

hsplit(NDArray, int)

Split an array into multiple sub-arrays horizontally (column-wise).

public static NDArray[] hsplit(NDArray ary, int indices_or_sections)

Parameters

ary NDArray

Array to be divided into sub-arrays.

indices_or_sections int

If an integer, N, the array will be divided into N equal arrays along the axis. If such a split is not possible, an error is raised.

Returns

NDArray[]

A list of sub-arrays as views into ary.

Remarks

For 1-D arrays, splits along axis 0. For 2-D+ arrays, splits along axis 1 (columns). https://numpy.org/doc/stable/reference/generated/numpy.hsplit.html

hsplit(NDArray, int[])

Split an array into multiple sub-arrays horizontally (column-wise).

public static NDArray[] hsplit(NDArray ary, int[] indices)

Parameters

ary NDArray

Array to be divided into sub-arrays.

indices int[]

A 1-D array of sorted integers indicating where along the axis the array is split. For example, [2, 3] would result in ary[:2], ary[2:3], ary[3:].

Returns

NDArray[]

A list of sub-arrays as views into ary.

Remarks

For 1-D arrays, splits along axis 0. For 2-D+ arrays, splits along axis 1 (columns). https://numpy.org/doc/stable/reference/generated/numpy.hsplit.html

hstack(params NDArray[])

Stack arrays in sequence horizontally (column wise). This is equivalent to concatenation along the second axis, except for 1-D arrays where it concatenates along the first axis.Rebuilds arrays divided by hsplit. This function makes most sense for arrays with up to 3 dimensions.For instance, for pixel-data with a height(first axis), width(second axis), and r/g/b channels(third axis). The functions concatenate, stack and block provide more general stacking and concatenation operations.

public static NDArray hstack(params NDArray[] tup)

Parameters

tup NDArray[]

The arrays must have the same shape along all but the second axis, except 1-D arrays which can be any length.

Returns

NDArray

The array formed by stacking the given arrays.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.hstack.html

identity(int, Type)

Return the identity array. The identity array is a square array with ones on the main diagonal.

public static NDArray identity(int n, Type dtype = null)

Parameters

n int

Number of rows (and columns) in n x n output.

dtype Type

Data-type of the output. Defaults to double.

Returns

NDArray

n x n array with its main diagonal set to one, and all other elements 0.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.identity.html

iinfo(NDArray)

Machine limits for integer types.

public static iinfo iinfo(NDArray arr)

Parameters

arr NDArray

An NDArray with integer dtype.

Returns

iinfo

An iinfo object describing the array's integer type limits.

Examples

var a = np.array(new int[] {1, 2, 3});
var info = np.iinfo(a);
Console.WriteLine(info.bits);  // 32

Exceptions

ArgumentNullException

Thrown if arr is null.

iinfo(NPTypeCode)

Machine limits for integer types.

public static iinfo iinfo(NPTypeCode typeCode)

Parameters

typeCode NPTypeCode

An integer type code.

Returns

iinfo

An iinfo object describing the integer type limits.

Examples

var info = np.iinfo(NPTypeCode.Int32);
Console.WriteLine(info.bits);  // 32
Console.WriteLine(info.min);   // -2147483648
Console.WriteLine(info.max);   // 2147483647

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.iinfo.html

iinfo(string)

Machine limits for integer types.

public static iinfo iinfo(string dtypeName)

Parameters

dtypeName string

A dtype string (e.g., "int32", "uint8", "bool").

Returns

iinfo

An iinfo object describing the integer type limits.

Examples

var info = np.iinfo("int32");
Console.WriteLine(info.bits);  // 32

Exceptions

ArgumentException

Thrown if dtypeName is not a valid integer dtype.

iinfo(Type)

Machine limits for integer types.

public static iinfo iinfo(Type type)

Parameters

type Type

A CLR integer type.

Returns

iinfo

An iinfo object describing the integer type limits.

iinfo<T>()

Machine limits for integer types.

public static iinfo iinfo<T>() where T : struct

Returns

iinfo

An iinfo object describing the integer type limits.

Type Parameters

T

An integer type (bool, byte, short, ushort, int, uint, long, ulong, char).

Examples

var info = np.iinfo<int>();
Console.WriteLine(info.bits);  // 32

indices(int[], NPTypeCode)

Return an array representing the indices of a grid. Dense form — for the sparse form, see indices_sparse(int[], NPTypeCode).

public static NDArray indices(int[] dimensions, NPTypeCode dtype = NPTypeCode.Int64)

Parameters

dimensions int[]

Shape of the grid.

dtype NPTypeCode

Element type of the result. Default is long.

Returns

NDArray

Single dense array of shape (len(dimensions), *dimensions). The d-th sub-array contains the d-th coordinate of each output position.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.indices.html

NumPy's sparse=True mode is exposed as the separate method indices_sparse(int[], NPTypeCode) — C# can't change return type based on a parameter the way Python's dynamic typing does, so splitting the API is clearer than throwing from a shared signature.

indices_sparse(int[], NPTypeCode)

Sparse counterpart to indices(int[], NPTypeCode) — returns a tuple of broadcast-shaped arrays where each axis-d array has shape (1, …, 1, dimensions[d], 1, …, 1). Equivalent to NumPy's np.indices(dimensions, sparse=True).

public static NDArray[] indices_sparse(int[] dimensions, NPTypeCode dtype = NPTypeCode.Int64)

Parameters

dimensions int[]

dtype NPTypeCode

Returns

NDArray[]

insert(NDArray, NDArray, NDArray, int?)

NDArray-typed obj. Dispatches:

• 0-D / 1-element integer ⇒ scalar single-index path.
• 1-D bool ⇒ flatnonzero(NDArray) ⇒ multi-index path.
• 1-D integer ⇒ multi-index path.
• > 1-D ⇒ ArgumentException matching NumPy's "index array argument obj to insert must be one dimensional or scalar".

public static NDArray insert(NDArray arr, NDArray obj, NDArray values, int? axis = null)

Parameters

arr NDArray

obj NDArray

values NDArray

axis int?

Returns

NDArray

insert(NDArray, NDArray, object, int?)

NDArray-obj overload accepting a scalar value.

public static NDArray insert(NDArray arr, NDArray obj, object value, int? axis = null)

Parameters

arr NDArray

obj NDArray

value object

axis int?

Returns

NDArray

insert(NDArray, Slice, NDArray, int?)

Slice-obj overload. obj is expanded via Python slice.indices(N) into an indices array, then the multi-index branch runs.

public static NDArray insert(NDArray arr, Slice obj, NDArray values, int? axis = null)

Parameters

arr NDArray

obj Slice

values NDArray

axis int?

Returns

NDArray

insert(NDArray, Slice, object, int?)

Slice-obj overload accepting a scalar value.

public static NDArray insert(NDArray arr, Slice obj, object value, int? axis = null)

Parameters

arr NDArray

obj Slice

value object

axis int?

Returns

NDArray

insert(NDArray, int, NDArray, int?)

Insert values along axis before the position obj. Scalar-obj path.

public static NDArray insert(NDArray arr, int obj, NDArray values, int? axis = null)

Parameters

arr NDArray

obj int

values NDArray

axis int?

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.insert.html

insert(NDArray, int, object, int?)

int-overload accepting a scalar value.

public static NDArray insert(NDArray arr, int obj, object value, int? axis = null)

Parameters

arr NDArray

obj int

value object

axis int?

Returns

NDArray

insert(NDArray, int[], NDArray, int?)

int[]-obj overload. Always routes through the multi-index branch (NumPy parity: np.insert(arr, [1], v) != np.insert(arr, 1, v) when v has multiple axes, even though both have one insertion point).

public static NDArray insert(NDArray arr, int[] obj, NDArray values, int? axis = null)

Parameters

arr NDArray

obj int[]

values NDArray

axis int?

Returns

NDArray

insert(NDArray, int[], object, int?)

int[]-obj overload accepting a scalar value.

public static NDArray insert(NDArray arr, int[] obj, object value, int? axis = null)

Parameters

arr NDArray

obj int[]

value object

axis int?

Returns

NDArray

insert(NDArray, long, NDArray, int?)

Long-index overload of insert(NDArray, int, NDArray, int?).

public static NDArray insert(NDArray arr, long obj, NDArray values, int? axis = null)

Parameters

arr NDArray

obj long

values NDArray

axis int?

Returns

NDArray

insert(NDArray, long, object, int?)

Scalar-obj overload accepting a scalar value (NumPy: np.insert(a, 1, 99)). Broadcasts the value to the required shape using arr.dtype.

public static NDArray insert(NDArray arr, long obj, object value, int? axis = null)

Parameters

arr NDArray

obj long

value object

axis int?

Returns

NDArray

insert(NDArray, long[], NDArray, int?)

long[]-obj overload.

public static NDArray insert(NDArray arr, long[] obj, NDArray values, int? axis = null)

Parameters

arr NDArray

obj long[]

values NDArray

axis int?

Returns

NDArray

insert(NDArray, long[], object, int?)

long[]-obj overload accepting a scalar value.

public static NDArray insert(NDArray arr, long[] obj, object value, int? axis = null)

Parameters

arr NDArray

obj long[]

value object

axis int?

Returns

NDArray

invert(NDArray, NDArray, NDArray, NPTypeCode?)

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.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.

public static NDArray invert(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Only integer and boolean types are handled.

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

Result. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.invert.html

invert(NDArray, NPTypeCode)

Compute bit-wise inversion in outType — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray invert(NDArray x, NPTypeCode outType)

Parameters

x NDArray

outType NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.invert.html

invert(NDArray, Type)

Compute bit-wise inversion, or bit-wise NOT, element-wise.

public static NDArray invert(NDArray x, Type outType)

Parameters

x NDArray

Only integer and boolean types are handled.

outType Type

The dtype the returned ndarray should be of.

Returns

NDArray

Result. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.invert.html

isclose(NDArray, NDArray, double, double, bool)

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. Warning: The default atol is not appropriate for comparing numbers that are much smaller than one(see Notes).

See also allclose(NDArray, NDArray, double, double, bool)

Notes: For finite values, isclose uses the following equation to test whether two floating point values are equivalent.

absolute(`a` - `b`) less than or equal to (`atol` + `rtol` * absolute(`b`))

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.

public static NDArray<bool> isclose(NDArray a, NDArray b, double rtol = 1E-05, double atol = 1E-08, bool equal_nan = false)

Parameters

a NDArray

Input array to compare with b

b NDArray

Input array to compare with a.

rtol double

The relative tolerance parameter(see Notes)

atol double

The absolute tolerance parameter(see Notes)

equal_nan bool

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

NDArray<bool>

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.

iscomplex(NDArray)

Returns a bool array, where True if input element is complex.

public static NDArray iscomplex(NDArray a)

Parameters

a NDArray

Input array.

Returns

NDArray

Boolean array of same shape, True where element has non-zero imaginary part.

Examples

var a = np.array(new int[] {1, 2, 3});
np.iscomplex(a)  // [False, False, False]

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.iscomplex.html

For non-complex arrays, all elements are considered not complex. For complex arrays, elements with non-zero imaginary part are complex.

iscomplexobj(NDArray)

Return True if x is a complex type or an array of complex numbers.

public static bool iscomplexobj(NDArray a)

Parameters

a NDArray

Input array or scalar.

Returns

bool

True if the array's dtype is complex.

Examples

var a = np.array(new int[] {1, 2, 3});
np.iscomplexobj(a)  // False (dtype is int, not complex)

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.iscomplexobj.html

The type of the input is checked, not the value.

isdtype(NDArray, string)

Returns True if the array's dtype is of a specified category.

public static bool isdtype(NDArray arr, string kind)

Parameters

arr NDArray

The NDArray to check.

kind string

The dtype category.

Returns

bool

True if array's dtype belongs to the specified category.

Exceptions

ArgumentNullException

Thrown if arr is null.

isdtype(NDArray, string[])

Returns True if the array's dtype is of any of the specified categories.

public static bool isdtype(NDArray arr, string[] kinds)

Parameters

arr NDArray

The NDArray to check.

kinds string[]

Array of dtype categories to check.

Returns

bool

True if array's dtype belongs to any of the specified categories.

Exceptions

ArgumentNullException

Thrown if arr is null.

isdtype(NPTypeCode, string)

Returns True if dtype is of a specified category.

public static bool isdtype(NPTypeCode dtype, string kind)

Parameters

dtype NPTypeCode

The dtype to check.

kind string

The dtype category. Can be:

• "bool" - boolean
• "integral" - integer types (signed and unsigned)
• "real floating" - floating point types
• "complex floating" - complex types
• "numeric" - any numeric type

Returns

bool

True if dtype belongs to the specified category.

Examples

np.isdtype(NPTypeCode.Int32, "integral")      // True
np.isdtype(NPTypeCode.Double, "real floating") // True
np.isdtype(NPTypeCode.Int32, "numeric")       // True

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.isdtype.html This is a NumPy 2.0+ function.

Uses NPTypeHierarchy for consistent type categorization across all typing functions.

isdtype(NPTypeCode, string[])

Returns True if dtype is of any of the specified categories.

public static bool isdtype(NPTypeCode dtype, string[] kinds)

Parameters

dtype NPTypeCode

The dtype to check.

kinds string[]

Array of dtype categories to check.

Returns

bool

True if dtype belongs to any of the specified categories.

isdtype(Type, string)

Returns True if the CLR type is of a specified category.

public static bool isdtype(Type type, string kind)

Parameters

type Type

The CLR type to check.

kind string

The dtype category.

Returns

bool

True if type belongs to the specified category.

isdtype(Type, string[])

Returns True if the CLR type is of any of the specified categories.

public static bool isdtype(Type type, string[] kinds)

Parameters

type Type

The CLR type to check.

kinds string[]

Array of dtype categories to check.

Returns

bool

True if type belongs to any of the specified categories.

isfinite(NDArray, NDArray, NDArray, NPTypeCode?)

Test element-wise for finiteness (not infinity and not Not a Number). Mirrors NumPy's ufunc signature: isfinite(x, /, out=None, *, where=True, dtype=None). A plain call returns a bool-dtype array (the instance is an NDArray<TDType> of bool).

public static NDArray isfinite(NDArray a, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written; masked-off out slots keep prior contents.

dtype NPTypeCode?

Validate-only (NumPy parity): the predicate has bool loops only — any non-bool request raises the no-loop TypeError.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.isfinite.html

isinf(NDArray, NDArray, NDArray, NPTypeCode?)

Test element-wise for positive or negative infinity. Mirrors NumPy's ufunc signature: isinf(x, /, out=None, *, where=True, dtype=None). A plain call returns a bool-dtype array (the instance is an NDArray<TDType> of bool).

public static NDArray isinf(NDArray a, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written; masked-off out slots keep prior contents.

dtype NPTypeCode?

Validate-only (NumPy parity): the predicate has bool loops only — any non-bool request raises the no-loop TypeError.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.isinf.html

• Float/Double: True if value is +Inf or -Inf
• Integer types: Always False (integers cannot be Inf)
• NaN: Returns False (NaN is not infinity)

isnan(NDArray, NDArray, NDArray, NPTypeCode?)

Test element-wise for Not a Number. Mirrors NumPy's ufunc signature: isnan(x, /, out=None, *, where=True, dtype=None). A plain call returns a bool-dtype array (the instance is an NDArray<TDType> of bool).

public static NDArray isnan(NDArray a, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written; masked-off out slots keep prior contents.

dtype NPTypeCode?

Validate-only (NumPy parity): the predicate has bool loops only — any non-bool request raises the no-loop TypeError.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.isnan.html

isreal(NDArray)

Returns a bool array, where True if input element is real.

public static NDArray isreal(NDArray a)

Parameters

a NDArray

Input array.

Returns

NDArray

Boolean array of same shape, True where element has no imaginary part.

Examples

var a = np.array(new int[] {1, 2, 3});
np.isreal(a)  // [True, True, True]

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.isreal.html

For non-complex arrays, all elements are considered real. For complex arrays, elements with zero imaginary part are real.

isrealobj(NDArray)

Return True if x is a not complex type or an array of complex numbers.

public static bool isrealobj(NDArray a)

Parameters

a NDArray

Input array or scalar.

Returns

bool

True if the array's dtype is not complex.

Examples

var a = np.array(new int[] {1, 2, 3});
np.isrealobj(a)  // True (dtype is int, not complex)

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.isrealobj.html

The type of the input is checked, not the value. Even an array of complex numbers with zero imaginary parts will return False.

isscalar(object)

Returns true incase of a number, bool or string. If null, returns false.

public static bool isscalar(object obj)

Parameters

obj object

Returns

bool

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.isscalar.html

issctype(object)

Determines whether the given object represents a scalar dtype.

public static bool issctype(object rep)

Parameters

rep object

The object to check.

Returns

bool

True if rep represents a scalar dtype.

Examples

np.issctype(typeof(int))       // True
np.issctype(NPTypeCode.Int32)  // True
np.issctype(typeof(NDArray))   // False

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.issctype.html

issubdtype(NDArray, string)

Returns True if first argument is a typecode lower/equal in type hierarchy.

public static bool issubdtype(NDArray arr, string arg2)

Parameters

arr NDArray

NDArray - array whose dtype to check.

arg2 string

string - string representing a typecode category.

Returns

bool

True if array's dtype is a subtype of arg2 category.

Exceptions

ArgumentNullException

Thrown if arr is null.

issubdtype(NPTypeCode, NPTypeCode)

Returns True if first argument is a typecode lower/equal in type hierarchy.

public static bool issubdtype(NPTypeCode arg1, NPTypeCode arg2)

Parameters

arg1 NPTypeCode

dtype - dtype representing a typecode.

arg2 NPTypeCode

dtype - dtype representing a typecode.

Returns

bool

True if arg1 is equal to or a subtype of arg2.

Remarks

When comparing two concrete types, returns true only if they are the same type. For hierarchy checks, use the (NPTypeCode, string) overload.

issubdtype(NPTypeCode, string)

Returns True if first argument is a typecode lower/equal in type hierarchy.

public static bool issubdtype(NPTypeCode arg1, string arg2)

Parameters

arg1 NPTypeCode

dtype or string - dtype or string representing a typecode.

arg2 string

dtype or string - dtype or string representing a typecode.

Returns

bool

True if arg1 is a subtype of arg2.

Examples

np.issubdtype(NPTypeCode.Int32, "integer")     // True
np.issubdtype(NPTypeCode.Double, "floating")   // True
np.issubdtype(NPTypeCode.Boolean, "integer")   // False (NumPy 2.x)

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.issubdtype.html

Implementation mirrors NumPy's issubdtype which uses issubclass() on the type hierarchy defined in numpy/_core/src/multiarray/multiarraymodule.c.

Type hierarchy in NumPy:

• generic → number → integer/inexact
• integer → signedinteger/unsignedinteger
• inexact → floating/complexfloating

Note: In NumPy 2.x, bool is NOT a subtype of integer (it's directly under generic).

issubdtype(Type, string)

Returns True if first argument is a typecode lower/equal in type hierarchy.

public static bool issubdtype(Type arg1, string arg2)

Parameters

arg1 Type

Type - CLR type representing a typecode.

arg2 string

string - string representing a typecode category.

Returns

bool

True if arg1 is a subtype of arg2 category.

issubdtype(Type, Type)

Returns True if first argument is a typecode lower/equal in type hierarchy.

public static bool issubdtype(Type arg1, Type arg2)

Parameters

arg1 Type

Type - first CLR type.

arg2 Type

Type - second CLR type to compare against.

Returns

bool

True if arg1 is equal to or a subtype of arg2.

issubsctype(NPTypeCode, NPTypeCode)

Determine if a class is a subclass of a second class.

public static bool issubsctype(NPTypeCode arg1, NPTypeCode arg2)

Parameters

arg1 NPTypeCode

The dtype to check.

arg2 NPTypeCode

The dtype to compare against.

Returns

bool

True if arg1 is a subtype of arg2.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.issubsctype.html

left_shift(NDArray, NDArray)

Shift the bits of an integer to the left.

public static NDArray left_shift(NDArray x1, NDArray x2)

Parameters

x1 NDArray

Input array (integer types only).

x2 NDArray

Number of bits to shift (integer types only).

Returns

NDArray

Array with bits shifted left.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.left_shift.html

Bits are shifted to the left by appending x2 0s at the right of x1. Since the internal representation of numbers is in binary format, this operation is equivalent to multiplying x1 by 2**x2.

Example: np.left_shift(5, 2) = 20 # 0b101 -> 0b10100

left_shift(NDArray, object)

Shift the bits of an integer to the left by a scalar or array-like amount.

public static NDArray left_shift(NDArray x1, object x2)

Parameters

x1 NDArray

Input array (integer types only).

x2 object

Number of bits to shift (scalar or array-like).

Returns

NDArray

Array with bits shifted left.

less(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Return (x1 < x2) element-wise. Mirrors NumPy's ufunc signature: less(x1, x2, /, out=None, *, where=True, dtype=None). A plain call returns a bool-dtype array (the instance is an NDArray<TDType> of bool — cast or use the < operator for the typed wrapper).

public static NDArray less(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

Input array.

x2 NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written; masked-off out slots keep prior contents.

dtype NPTypeCode?

Validate-only (NumPy parity): comparisons have bool loops only — any non-bool request raises the no-loop TypeError.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.less.html

less(NDArray, object)

Return (x1 < x2) element-wise with scalar.

public static NDArray<bool> less(NDArray x1, object x2)

Parameters

x1 NDArray

Input array.

x2 object

Scalar or array-like value.

Returns

NDArray<bool>

Output array of bools.

less(object, NDArray)

Return (x1 < x2) element-wise with scalar on left.

public static NDArray<bool> less(object x1, NDArray x2)

Parameters

x1 object

Scalar or array-like value.

x2 NDArray

Input array.

Returns

NDArray<bool>

Output array of bools.

less_equal(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Return (x1 <= x2) element-wise. Mirrors NumPy's ufunc signature: less_equal(x1, x2, /, out=None, *, where=True, dtype=None). A plain call returns a bool-dtype array (the instance is an NDArray<TDType> of bool — cast or use the <= operator for the typed wrapper).

public static NDArray less_equal(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

Input array.

x2 NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written; masked-off out slots keep prior contents.

dtype NPTypeCode?

Validate-only (NumPy parity): comparisons have bool loops only — any non-bool request raises the no-loop TypeError.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.less_equal.html

less_equal(NDArray, object)

Return (x1 <= x2) element-wise with scalar.

public static NDArray<bool> less_equal(NDArray x1, object x2)

Parameters

x1 NDArray

Input array.

x2 object

Scalar or array-like value.

Returns

NDArray<bool>

Output array of bools.

less_equal(object, NDArray)

Return (x1 <= x2) element-wise with scalar on left.

public static NDArray<bool> less_equal(object x1, NDArray x2)

Parameters

x1 object

Scalar or array-like value.

x2 NDArray

Input array.

Returns

NDArray<bool>

Output array of bools.

linspace(double, double, int, bool, NPTypeCode)

public static NDArray linspace(double start, double stop, int num, bool endpoint = true, NPTypeCode typeCode = NPTypeCode.Double)

Parameters

start double

stop double

num int

endpoint bool

typeCode NPTypeCode

Returns

NDArray

linspace(double, double, int, bool, Type)

public static NDArray linspace(double start, double stop, int num, bool endpoint, Type dtype)

Parameters

start double

stop double

num int

endpoint bool

dtype Type

Returns

NDArray

linspace(double, double, long, bool, NPTypeCode)

public static NDArray linspace(double start, double stop, long num, bool endpoint = true, NPTypeCode typeCode = NPTypeCode.Double)

Parameters

start double

stop double

num long

endpoint bool

typeCode NPTypeCode

Returns

NDArray

linspace(double, double, long, bool, Type)

public static NDArray linspace(double start, double stop, long num, bool endpoint, Type dtype)

Parameters

start double

stop double

num long

endpoint bool

dtype Type

Returns

NDArray

linspace(float, float, int, bool, NPTypeCode)

public static NDArray linspace(float start, float stop, int num, bool endpoint = true, NPTypeCode typeCode = NPTypeCode.Double)

Parameters

start float

stop float

num int

endpoint bool

typeCode NPTypeCode

Returns

NDArray

linspace(float, float, int, bool, Type)

public static NDArray linspace(float start, float stop, int num, bool endpoint, Type dtype)

Parameters

start float

stop float

num int

endpoint bool

dtype Type

Returns

NDArray

linspace(float, float, long, bool, NPTypeCode)

public static NDArray linspace(float start, float stop, long num, bool endpoint = true, NPTypeCode typeCode = NPTypeCode.Double)

Parameters

start float

stop float

num long

endpoint bool

typeCode NPTypeCode

Returns

NDArray

linspace(float, float, long, bool, Type)

public static NDArray linspace(float start, float stop, long num, bool endpoint, Type dtype)

Parameters

start float

stop float

num long

endpoint bool

dtype Type

Returns

NDArray

load(Stream)

public static NDArray load(Stream stream)

Parameters

stream Stream

Returns

NDArray

load(string)

public static NDArray load(string path)

Parameters

path string

Returns

NDArray

log(NDArray)

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.

public static NDArray log(NDArray x)

Parameters

x NDArray

Input value.

Returns

NDArray

The natural logarithm of x, element-wise. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log.html

log(NDArray, NDArray, NDArray, NPTypeCode?)

Natural logarithm, element-wise. Mirrors NumPy's ufunc signature: log(x, /, out=None, *, where=True, dtype=None).

public static NDArray log(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input value.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the computation runs at this precision; integer/bool requests raise NumPy's "No loop matching" error.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log.html

log(NDArray, NPTypeCode)

Natural logarithm, element-wise, computed in dtype. Positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray log(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input value.

dtype NPTypeCode

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The natural logarithm of x, element-wise. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log.html

log(NDArray, Type)

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.

public static NDArray log(NDArray x, Type dtype)

Parameters

x NDArray

Input value.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The natural logarithm of x, element-wise. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log.html

log10(NDArray)

Return the base 10 logarithm of the input array, element-wise.

public static NDArray log10(NDArray x)

Parameters

x NDArray

Input value.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log10.html

log10(NDArray, NDArray, NDArray, NPTypeCode?)

Return the base 10 logarithm of the input array, element-wise.

public static NDArray log10(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input value.

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log10.html

log10(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray log10(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

dtype NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log10.html

log10(NDArray, Type)

Return the base 10 logarithm of the input array, element-wise.

public static NDArray log10(NDArray x, Type dtype)

Parameters

x NDArray

Input value.

dtype Type

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log10.html

log1p(NDArray)

Return the natural logarithm of one plus the input array, element-wise.
Calculates log(1 + x).

public static NDArray log1p(NDArray x)

Parameters

x NDArray

Input value.

Returns

NDArray

Natural logarithm of 1 + x, element-wise. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log1p.html

log1p(NDArray, NDArray, NDArray, NPTypeCode?)

Return the natural logarithm of one plus the input array, element-wise.
Calculates log(1 + x).

public static NDArray log1p(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input value.

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

Natural logarithm of 1 + x, element-wise. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log1p.html

log1p(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray log1p(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

dtype NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log1p.html

log1p(NDArray, Type)

Return the natural logarithm of one plus the input array, element-wise.
Calculates log(1 + x).

public static NDArray log1p(NDArray x, Type dtype)

Parameters

x NDArray

Input value.

dtype Type

Returns

NDArray

Natural logarithm of 1 + x, element-wise. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log1p.html

log2(NDArray)

Base-2 logarithm of x.

public static NDArray log2(NDArray x)

Parameters

x NDArray

Input value.

Returns

NDArray

Base-2 logarithm of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log2.html

log2(NDArray, NDArray, NDArray, NPTypeCode?)

Base-2 logarithm of x.

public static NDArray log2(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input value.

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

Base-2 logarithm of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log2.html

log2(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray log2(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

dtype NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log2.html

log2(NDArray, Type)

Base-2 logarithm of x.

public static NDArray log2(NDArray x, Type dtype)

Parameters

x NDArray

Input value.

dtype Type

Returns

NDArray

Base-2 logarithm of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.log2.html

logical_and(NDArray, NDArray)

Compute the truth value of x1 AND x2 element-wise.

public static NDArray<bool> logical_and(NDArray x1, NDArray x2)

Parameters

x1 NDArray

Input array.

x2 NDArray

Input array.

Returns

NDArray<bool>

Boolean result of the logical AND operation applied to the elements of x1 and x2; the shape is determined by broadcasting.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.logical_and.html

logical_not(NDArray)

Compute the truth value of NOT x element-wise.

public static NDArray<bool> logical_not(NDArray x)

Parameters

x NDArray

Logical NOT is applied to the elements of x.

Returns

NDArray<bool>

Boolean result with the same shape as x.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.logical_not.html

logical_or(NDArray, NDArray)

Compute the truth value of x1 OR x2 element-wise.

public static NDArray<bool> logical_or(NDArray x1, NDArray x2)

Parameters

x1 NDArray

Input array.

x2 NDArray

Input array.

Returns

NDArray<bool>

Boolean result of the logical OR operation applied to the elements of x1 and x2; the shape is determined by broadcasting.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.logical_or.html

logical_xor(NDArray, NDArray)

Compute the truth value of x1 XOR x2 element-wise.

public static NDArray<bool> logical_xor(NDArray x1, NDArray x2)

Parameters

x1 NDArray

Input array.

x2 NDArray

Input array.

Returns

NDArray<bool>

Boolean result of the logical XOR operation applied to the elements of x1 and x2; the shape is determined by broadcasting.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.logical_xor.html

matmul(NDArray, NDArray)

Matrix product of two arrays.

public static NDArray matmul(NDArray x1, NDArray x2)

Parameters

x1 NDArray

Lhs Input array, scalars not allowed.

x2 NDArray

Rhs Input array, scalars not allowed.

Returns

NDArray

The matrix product of the inputs. This is a scalar only when both x1, x2 are 1-d vectors.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.matmul.html

max(NDArray, int?, bool, Type)

Return the maximum of an array or maximum along an axis.

public static NDArray max(NDArray a, int? axis = null, bool keepdims = false, Type dtype = null)

Parameters

a NDArray

axis int?

Axis or axes along which to operate.

keepdims bool

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.

dtype Type

the type expected as a return, null will remain the same dtype.

Returns

NDArray

Maximum of a. If axis is None, the result is a scalar value. If axis is given, the result is an array of dimension a.ndim - 1.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.amax.html

maximum(NDArray, NDArray, NDArray)

Element-wise maximum of array elements (NaN-propagating), writing into @out.

public static NDArray maximum(NDArray x1, NDArray x2, NDArray @out)

Parameters

x1 NDArray

x2 NDArray

out NDArray

Returns

NDArray

maximum(NDArray, NDArray, NPTypeCode?)

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.

public static NDArray maximum(NDArray x1, NDArray x2, NPTypeCode? dtype = null)

Parameters

x1 NDArray

The arrays holding the elements to be compared. If x1.shape != x2.shape, they must be broadcastable to a common shape (which becomes the shape of the output).

x2 NDArray

The arrays holding the elements to be compared. If x1.shape != x2.shape, they must be broadcastable to a common shape (which becomes the shape of the output).

dtype NPTypeCode?

Loop dtype (NumPy ufunc dtype=): the comparison runs at this precision.

Returns

NDArray

The maximum of x1 and x2, element-wise. This is a scalar if both x1 and x2 are scalars.

maximum(NDArray, NDArray, Type)

Element-wise maximum of array elements (NaN-propagating). See maximum(NDArray, NDArray, NPTypeCode?).

public static NDArray maximum(NDArray x1, NDArray x2, Type dtype)

Parameters

x1 NDArray

x2 NDArray

dtype Type

Returns

NDArray

maximum_sctype(NPTypeCode)

Return the scalar type of highest precision of the same kind as the input.

public static NPTypeCode maximum_sctype(NPTypeCode t)

Parameters

t NPTypeCode

The input scalar type.

Returns

NPTypeCode

The highest precision type of the same kind.

Examples

np.maximum_sctype(NPTypeCode.Int32)   // Int64
np.maximum_sctype(NPTypeCode.Single)  // Double (or Decimal)

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.maximum_sctype.html

Uses NPTypeHierarchy for consistent type categorization across all typing functions.

mean(NDArray)

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.

public static NDArray mean(NDArray a)

Parameters

a NDArray

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

Returns

NDArray

returns a new array containing the mean values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.mean.html

mean(NDArray, bool)

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.

public static NDArray mean(NDArray a, bool keepdims)

Parameters

a NDArray

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

keepdims bool

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.

Returns

NDArray

returns a new array containing the mean values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.mean.html

mean(NDArray, int)

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.

public static NDArray mean(NDArray a, int axis)

Parameters

a NDArray

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

axis int

Axis or axes along which the means are computed. The default is to compute the mean of the flattened array.

Returns

NDArray

returns a new array containing the mean values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.mean.html

mean(NDArray, int, NPTypeCode, bool)

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.

public static NDArray mean(NDArray a, int axis, NPTypeCode type, bool keepdims = false)

Parameters

a NDArray

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

axis int

Axis or axes along which the means are computed. The default is to compute the mean of the flattened array.

type NPTypeCode

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.

keepdims bool

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.

Returns

NDArray

returns a new array containing the mean values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.mean.html

mean(NDArray, int, bool)

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.

public static NDArray mean(NDArray a, int axis, bool keepdims)

Parameters

a NDArray

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

axis int

Axis or axes along which the means are computed. The default is to compute the mean of the flattened array.

keepdims bool

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.

Returns

NDArray

returns a new array containing the mean values, otherwise a reference to the output array is returned.

mean(NDArray, int, Type, bool)

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.

public static NDArray mean(NDArray a, int axis, Type dtype, bool keepdims = false)

Parameters

a NDArray

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

axis int

Axis or axes along which the means are computed. The default is to compute the mean of the flattened array.

dtype Type

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.

keepdims bool

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.

Returns

NDArray

returns a new array containing the mean values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.mean.html

median(NDArray, int[], NDArray, bool, bool)

public static NDArray median(NDArray a, int[] axis, NDArray @out = null, bool overwrite_input = false, bool keepdims = false)

Parameters

a NDArray

axis int[]

out NDArray

overwrite_input bool

keepdims bool

Returns

NDArray

median(NDArray, int?, NDArray, bool, bool)

Compute the median along the specified axis. For an even-sized slice the median is the mean of the two central values; for an odd-sized slice it is the single central value. Equivalent to np.quantile(a, 0.5) for our purposes, which matches NumPy's contract.

public static NDArray median(NDArray a, int? axis = null, NDArray @out = null, bool overwrite_input = false, bool keepdims = false)

Parameters

a NDArray

axis int?

out NDArray

overwrite_input bool

keepdims bool

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.median.html

meshgrid(NDArray, NDArray, Kwargs)

Return coordinate matrices from coordinate vectors. Make N-D coordinate arrays for vectorized evaluations of N-D scalar/vector fields over N-D grids, given one-dimensional coordinate arrays x1, x2,..., xn. .. versionchanged:: 1.9 1-D and 0-D cases are allowed.

public static (NDArray, NDArray) meshgrid(NDArray x1, NDArray x2, Kwargs kwargs = null)

Parameters

x1 NDArray

1-D arrays representing the coordinates of a grid

x2 NDArray

1-D arrays representing the coordinates of a grid

kwargs Kwargs

Returns

(NDArray Lhs, NDArray Rhs)

mgrid(NDArray, NDArray)

nd_grid instance which returns a dense multi-dimensional “meshgrid”. An instance of numpy.lib.index_tricks.nd_grid which returns an dense (or fleshed out) mesh-grid when indexed, so that each returned argument has the same shape. The dimensions and number of the output arrays are equal to the number of indexing dimensions.If the step length is not a complex number, then the stop is not inclusive.

public static (NDArray, NDArray) mgrid(NDArray lhs, NDArray rhs)

Parameters

lhs NDArray

rhs NDArray

Returns

(NDArray Lhs, NDArray Rhs)

mesh-grid ndarrays all of the same dimensions

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.mgrid.html

min(NDArray, int?, bool, Type)

Return the minimum of an array or minimum along an axis.

public static NDArray min(NDArray a, int? axis = null, bool keepdims = false, Type dtype = null)

Parameters

a NDArray

Input data.

axis int?

Axis or axes along which to operate.

keepdims bool

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.

dtype Type

the type expected as a return, null will remain the same dtype.

Returns

NDArray

Minimum of a. If axis is None, the result is a scalar value. If axis is given, the result is an array of dimension a.ndim - 1.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.amin.html

min_scalar_type(object)

For scalar value, returns the data type with the smallest size and smallest scalar kind which can hold its value.

public static NPTypeCode min_scalar_type(object value)

Parameters

value object

The scalar value to check.

Returns

NPTypeCode

The minimum dtype that can represent the value.

Examples

np.min_scalar_type(10)      // Byte (uint8)
np.min_scalar_type(-10)     // Int16 (no int8 in NumSharp)
np.min_scalar_type(1000)    // UInt16
np.min_scalar_type(1.0)     // Single (float32)
np.min_scalar_type(true)    // Boolean

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.min_scalar_type.html

For integers, finds the smallest integer type that can hold the value. For floats, finds the smallest float type that can represent the value exactly.

minimum(NDArray, NDArray, NDArray)

Element-wise minimum of array elements (NaN-propagating), writing into @out.

public static NDArray minimum(NDArray x1, NDArray x2, NDArray @out)

Parameters

x1 NDArray

x2 NDArray

out NDArray

Returns

NDArray

minimum(NDArray, NDArray, NPTypeCode?)

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.

public static NDArray minimum(NDArray x1, NDArray x2, NPTypeCode? dtype = null)

Parameters

x1 NDArray

The arrays holding the elements to be compared. If x1.shape != x2.shape, they must be broadcastable to a common shape (which becomes the shape of the output).

x2 NDArray

The arrays holding the elements to be compared. If x1.shape != x2.shape, they must be broadcastable to a common shape (which becomes the shape of the output).

dtype NPTypeCode?

Loop dtype (NumPy ufunc dtype=): the comparison runs at this precision.

Returns

NDArray

The minimum of x1 and x2, element-wise. This is a scalar if both x1 and x2 are scalars.

minimum(NDArray, NDArray, Type)

Element-wise minimum of array elements (NaN-propagating). See minimum(NDArray, NDArray, NPTypeCode?).

public static NDArray minimum(NDArray x1, NDArray x2, Type dtype)

Parameters

x1 NDArray

x2 NDArray

dtype Type

Returns

NDArray

mintypecode(char[], string, char)

Return the character for the minimum-size type to which given types can be safely cast. The returned type character must represent the smallest size dtype such that an array of the returned type can handle the data from an array of all types in typechars(or if typechars is an array, then its dtype.char).

public static char mintypecode(char[] typechars, string typeset = "GDFgdf", char @default = 'd')

Parameters

typechars char[]

typeset string

The set of characters that the returned character is chosen from. The default set is ‘GDFgdf’.

default char

The default character, this is returned if none of the characters in typechars matches a character in typeset.

Returns

char

The character representing the minimum-size type that was found.

mintypecode(string, string, char)

Return the character for the minimum-size type to which given types can be safely cast. The returned type character must represent the smallest size dtype such that an array of the returned type can handle the data from an array of all types in typechars(or if typechars is an array, then its dtype.char).

public static char mintypecode(string typechars, string typeset = "GDFgdf", char @default = 'd')

Parameters

typechars string

every character represents a type. see char

typeset string

The set of characters that the returned character is chosen from. The default set is ‘GDFgdf’.

default char

The default character, this is returned if none of the characters in typechars matches a character in typeset.

Returns

char

The character representing the minimum-size type that was found.

mod(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

public static NDArray mod(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

x2 NDArray

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.mod.html

mod(NDArray, float)

public static NDArray mod(NDArray x1, float x2)

Parameters

x1 NDArray

x2 float

Returns

NDArray

modf(NDArray, NPTypeCode?)

Return the fractional and integral parts of an array, element-wise. The fractional and integral parts are negative if the given number is negative.

public static (NDArray Fractional, NDArray Intergral) modf(NDArray x, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array.

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

(NDArray Lhs, NDArray Rhs)

Fractional part of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.modf.html

modf(NDArray, Type)

Return the fractional and integral parts of an array, element-wise. The fractional and integral parts are negative if the given number is negative.

public static (NDArray Fractional, NDArray Intergral) modf(NDArray x, Type dtype)

Parameters

x NDArray

Input array.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

(NDArray Lhs, NDArray Rhs)

Fractional part of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.modf.html

moveaxis(NDArray, int, int)

Move axes of an array to new positions. Other axes remain in their original order.

public static NDArray moveaxis(NDArray a, int source, int destination)

Parameters

a NDArray

The array whose axes should be reordered.

source int

Original positions of the axes to move. These must be unique (distinct).

destination int

Destination positions for each of the original axes. These must also be unique (distinct).

Returns

NDArray

Array with moved axes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.moveaxis.html

moveaxis(NDArray, int, int[])

Move axes of an array to new positions. Other axes remain in their original order.

public static NDArray moveaxis(NDArray a, int source, int[] destination)

Parameters

a NDArray

The array whose axes should be reordered.

source int

Original positions of the axes to move. These must be unique (distinct).

destination int[]

Destination positions for each of the original axes. These must also be unique (distinct).

Returns

NDArray

Array with moved axes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.moveaxis.html

moveaxis(NDArray, int[], int)

Move axes of an array to new positions. Other axes remain in their original order.

public static NDArray moveaxis(NDArray a, int[] source, int destination)

Parameters

a NDArray

The array whose axes should be reordered.

source int[]

Original positions of the axes to move. These must be unique (distinct).

destination int

Destination positions for each of the original axes. These must also be unique (distinct).

Returns

NDArray

Array with moved axes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.moveaxis.html

moveaxis(NDArray, int[], int[])

Move axes of an array to new positions. Other axes remain in their original order.

public static NDArray moveaxis(NDArray a, int[] source, int[] destination)

Parameters

a NDArray

The array whose axes should be reordered.

source int[]

Original positions of the axes to move. These must be unique (distinct).

destination int[]

Destination positions for each of the original axes. These must also be unique (distinct).

Returns

NDArray

Array with moved axes.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.moveaxis.html

multiply(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

public static NDArray multiply(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

x2 NDArray

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.multiply.html

multithreading(bool, int)

Enable or disable NumSharp's multithreaded kernels and cap the worker thread count.

public static void multithreading(bool enabled, int max_threads = 8)

Parameters

enabled bool

Whether kernels are allowed to use more than one thread.

max_threads int

Upper bound on worker threads (clamped to at least 1 and to the processor count). Defaults to 8.

Remarks

Multithreading is disabled by default, so the default behavior — and the exact summation order — is unchanged unless you opt in.

Currently this controls the fused 1-D dot product (dot(NDArray, NDArray) for vector·vector) on contiguous float / double inputs. Only large vectors are parallelized; small and medium ones stay single-threaded because thread fan-out would cost more than it saves. With multithreading on, the inner product is summed per-chunk and combined, so results may differ from the single-threaded path in the last few ULPs (the same floating-point reordering NumPy's threaded BLAS exhibits).

np.multithreading(true);          // enable, up to 8 threads
np.multithreading(true, 16);      // enable, up to 16 threads
np.multithreading(false);         // back to single-threaded

nanmax(NDArray, int?, bool)

Return maximum of an array or maximum along an axis, ignoring any NaNs.

public static NDArray nanmax(NDArray a, int? axis = null, bool keepdims = false)

Parameters

a NDArray

Array containing numbers whose maximum is desired. If a is not an array, a conversion is attempted.

axis int?

Axis or axes along which the maximum is computed. The default is to compute the maximum of the flattened array.

keepdims bool

If this is set to True, the axes which are reduced are left in the result as dimensions with size one.

Returns

NDArray

A new array containing the maximum. If all values are NaN, returns NaN.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nanmax.html Only applicable to float and double arrays. For integer arrays, this is equivalent to np.amax (no NaN values possible).

nanmean(NDArray, int?, bool)

Compute the arithmetic mean along the specified axis, ignoring NaNs. 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.

public static NDArray nanmean(NDArray a, int? axis = null, bool keepdims = false)

Parameters

a NDArray

Array containing numbers whose mean is desired. If a is not an array, a conversion is attempted.

axis int?

Axis or axes along which the means are computed. The default is to compute the mean of the flattened array.

keepdims bool

If this is set to True, the axes which are reduced are left in the result as dimensions with size one.

Returns

NDArray

A new array containing the mean values, with NaN values ignored. If all values along an axis are NaN, returns NaN for that slice.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nanmean.html

nanmedian(NDArray, int[], NDArray, bool, bool)

public static NDArray nanmedian(NDArray a, int[] axis, NDArray @out = null, bool overwrite_input = false, bool keepdims = false)

Parameters

a NDArray

axis int[]

out NDArray

overwrite_input bool

keepdims bool

Returns

NDArray

nanmedian(NDArray, int?, NDArray, bool, bool)

Compute the median along the specified axis, ignoring NaNs. Equivalent to np.nanquantile(a, 0.5). A slice that is entirely NaN (or empty) yields NaN, matching NumPy's "All-NaN slice" behaviour.

public static NDArray nanmedian(NDArray a, int? axis = null, NDArray @out = null, bool overwrite_input = false, bool keepdims = false)

Parameters

a NDArray

axis int?

out NDArray

overwrite_input bool

keepdims bool

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nanmedian.html

nanmin(NDArray, int?, bool)

Return minimum of an array or minimum along an axis, ignoring any NaNs.

public static NDArray nanmin(NDArray a, int? axis = null, bool keepdims = false)

Parameters

a NDArray

Array containing numbers whose minimum is desired. If a is not an array, a conversion is attempted.

axis int?

Axis or axes along which the minimum is computed. The default is to compute the minimum of the flattened array.

keepdims bool

If this is set to True, the axes which are reduced are left in the result as dimensions with size one.

Returns

NDArray

A new array containing the minimum. If all values are NaN, returns NaN.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nanmin.html Only applicable to float and double arrays. For integer arrays, this is equivalent to np.amin (no NaN values possible).

nanpercentile(NDArray, NDArray, int?, NDArray, bool, string, bool)

public static NDArray nanpercentile(NDArray a, NDArray q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q NDArray

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

nanpercentile(NDArray, double, int[], NDArray, bool, string, bool)

public static NDArray nanpercentile(NDArray a, double q, int[] axis, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double

axis int[]

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

nanpercentile(NDArray, double, int?, NDArray, bool, string, bool)

Compute the q-th percentile of the data along the specified axis, ignoring NaNs. q must be in [0, 100]. Equivalent to np.nanquantile(a, q/100). A slice that is entirely NaN (or empty) yields NaN.

public static NDArray nanpercentile(NDArray a, double q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nanpercentile.html

nanpercentile(NDArray, double[], int[], NDArray, bool, string, bool)

public static NDArray nanpercentile(NDArray a, double[] q, int[] axis, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double[]

axis int[]

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

nanpercentile(NDArray, double[], int?, NDArray, bool, string, bool)

public static NDArray nanpercentile(NDArray a, double[] q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double[]

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

nanprod(NDArray, int?, bool)

Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.

public static NDArray nanprod(NDArray a, int? axis = null, bool keepdims = false)

Parameters

a NDArray

Array containing numbers whose product is desired. If a is not an array, a conversion is attempted.

axis int?

Axis or axes along which the product is computed. The default is to compute the product of the flattened array.

keepdims bool

If this is set to True, the axes which are reduced are left in the result as dimensions with size one.

Returns

NDArray

A new array containing the product, with NaN values treated as one.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nanprod.html Only applicable to float and double arrays. For integer arrays, this is equivalent to np.prod (no NaN values possible).

nanquantile(NDArray, NDArray, int?, NDArray, bool, string, bool)

NDArray-q overload — accepts a 0-D or 1-D NDArray of quantile values. Higher-rank q is rejected (NumPy raises "q must be a scalar or 1d").

public static NDArray nanquantile(NDArray a, NDArray q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q NDArray

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

nanquantile(NDArray, double, int[], NDArray, bool, string, bool)

public static NDArray nanquantile(NDArray a, double q, int[] axis, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double

axis int[]

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

nanquantile(NDArray, double, int?, NDArray, bool, string, bool)

Compute the q-th quantile of the data along the specified axis, ignoring NaNs. q must be in the range [0, 1]. A slice that is entirely NaN (or empty) yields NaN, matching NumPy's "All-NaN slice" behaviour.

public static NDArray nanquantile(NDArray a, double q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nanquantile.html

nanquantile(NDArray, double[], int[], NDArray, bool, string, bool)

public static NDArray nanquantile(NDArray a, double[] q, int[] axis, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double[]

axis int[]

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

nanquantile(NDArray, double[], int?, NDArray, bool, string, bool)

public static NDArray nanquantile(NDArray a, double[] q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double[]

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

nanstd(NDArray, int?, bool, int)

Compute the standard deviation along the specified axis, while ignoring NaNs. Returns the standard deviation, a measure of the spread of a distribution, of the non-NaN array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray nanstd(NDArray a, int? axis = null, bool keepdims = false, int ddof = 0)

Parameters

a NDArray

Calculate the standard deviation of the non-NaN values.

axis int?

Axis or axes along which the standard deviation is computed. The default is to compute the standard deviation of the flattened array.

keepdims bool

If this is set to True, the axes which are reduced are left in the result as dimensions with size one.

ddof int

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of non-NaN elements. By default ddof is zero.

Returns

NDArray

A new array containing the standard deviation. If all values along an axis are NaN, returns NaN for that slice.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nanstd.html

nansum(NDArray, int?, bool)

Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.

public static NDArray nansum(NDArray a, int? axis = null, bool keepdims = false)

Parameters

a NDArray

Array containing numbers whose sum is desired. If a is not an array, a conversion is attempted.

axis int?

Axis or axes along which the sum is computed. The default is to compute the sum of the flattened array.

keepdims bool

If this is set to True, the axes which are reduced are left in the result as dimensions with size one.

Returns

NDArray

A new array containing the sum, with NaN values treated as zero.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nansum.html Only applicable to float and double arrays. For integer arrays, this is equivalent to np.sum (no NaN values possible).

nanvar(NDArray, int?, bool, int)

Compute the variance along the specified axis, while ignoring NaNs. Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray nanvar(NDArray a, int? axis = null, bool keepdims = false, int ddof = 0)

Parameters

a NDArray

Array containing numbers whose variance is desired.

axis int?

Axis or axes along which the variance is computed. The default is to compute the variance of the flattened array.

keepdims bool

If this is set to True, the axes which are reduced are left in the result as dimensions with size one.

ddof int

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of non-NaN elements. By default ddof is zero.

Returns

NDArray

A new array containing the variance. If all values along an axis are NaN, returns NaN for that slice.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nanvar.html

ndarray(Shape, Type, Array, char)

Create an array.

public static NDArray ndarray(Shape shape, Type dtype = null, Array buffer = null, char order = 'F')

Parameters

shape Shape

Shape of the array.

dtype Type

Data type. Default is float32.

buffer Array

Optional buffer to use for data. If null, allocates new memory filled with zeros.

order char

Memory order. Note: Only C-order is supported, F-order parameter is accepted but ignored.

Returns

NDArray

New NDArray with the specified shape and dtype.

Remarks

This function creates an NDArray directly without going through TensorEngine. Memory allocation is not backend-specific - all backends use the same unmanaged memory.

negative(NDArray, NDArray, NDArray, NPTypeCode?)

Numerical negative, element-wise. Mirrors NumPy's ufunc signature: negative(x, /, out=None, *, where=True, dtype=None).

public static NDArray negative(NDArray nd, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

nd NDArray

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): selects the loop, so negative(bool, dtype: float64) is legal while plain negative(bool) raises (NumPy parity).

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.negative.html

nonzero(NDArray)

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. To group the indices by element, rather than dimension, use argwhere, which returns a row for each non-zero element.

public static NDArray<long>[] nonzero(NDArray a)

Parameters

a NDArray

Input array.

Returns

NDArray<long>[]

Indices of elements that are non-zero.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.nonzero.html

not_equal(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

Return (x1 != x2) element-wise. Mirrors NumPy's ufunc signature: not_equal(x1, x2, /, out=None, *, where=True, dtype=None). A plain call returns a bool-dtype array (the instance is an NDArray<TDType> of bool — cast or use the != operator for the typed wrapper).

public static NDArray not_equal(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

Input array.

x2 NDArray

Input array.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written; masked-off out slots keep prior contents.

dtype NPTypeCode?

Validate-only (NumPy parity): comparisons have bool loops only — any non-bool request raises the no-loop TypeError.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.not_equal.html

not_equal(NDArray, object)

Return (x1 != x2) element-wise with scalar.

public static NDArray<bool> not_equal(NDArray x1, object x2)

Parameters

x1 NDArray

Input array.

x2 object

Scalar or array-like value.

Returns

NDArray<bool>

Output array of bools.

not_equal(object, NDArray)

Return (x1 != x2) element-wise with scalar on left.

public static NDArray<bool> not_equal(object x1, NDArray x2)

Parameters

x1 object

Scalar or array-like value.

x2 NDArray

Input array.

Returns

NDArray<bool>

Output array of bools.

ones(Shape)

Return a new array of given shape and type, filled with ones.

public static NDArray ones(Shape shape)

Parameters

shape Shape

Shape of the new array.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones.html

ones(Shape, NPTypeCode)

Return a new array of given shape and type, filled with ones.

public static NDArray ones(Shape shape, NPTypeCode typeCode)

Parameters

shape Shape

Shape of the new array.

typeCode NPTypeCode

The desired data-type for the array, e.g., uint8. Default is float64 / double.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones.html

ones(Shape, Type)

Return a new array of given shape and type, filled with ones.

public static NDArray ones(Shape shape, Type dtype)

Parameters

shape Shape

Shape of the new array.

dtype Type

The desired data-type for the array, e.g., uint8. Default is float64 / double.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones.html

ones(int)

Return a new array of given shape and type, filled with ones.

public static NDArray ones(int shape)

Parameters

shape int

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones.html

ones(int[])

Return a new array of given shape and type, filled with ones.

public static NDArray ones(int[] shape)

Parameters

shape int[]

Shape of the new array.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones.html

ones(int[], Type)

Return a new array of given shape and type, filled with ones.

public static NDArray ones(int[] shape, Type dtype)

Parameters

shape int[]

Shape of the new array.

dtype Type

The desired data-type for the array, e.g., uint8. Default is float64 / double.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones.html

ones(long[])

Return a new array of given shape and type, filled with ones.

public static NDArray ones(long[] shape)

Parameters

shape long[]

Shape of the new array.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones.html

ones_like(NDArray, Type)

Return an array of ones with the same shape and type as a given array.

public static NDArray ones_like(NDArray a, Type dtype = null)

Parameters

a NDArray

Array of ones with the same shape and type as a.

dtype Type

Overrides the data type of the result.

Returns

NDArray

Array of zeros with the same shape and type as nd.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones_like.html

ones_like(NDArray, Type, char)

Return an array of ones with the same shape and type as a given array.

public static NDArray ones_like(NDArray a, Type dtype, char order)

Parameters

a NDArray

Array of ones with the same shape and type as a.

dtype Type

Overrides the data type of the result.

order char

Memory layout: 'C', 'F', 'A' or 'K' (default, preserves source layout).

Returns

NDArray

Array of ones with the same shape and type as nd.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones_like.html

ones<T>(int[])

Return a new array of given shape and type, filled with ones.

public static NDArray ones<T>(int[] shape) where T : unmanaged

Parameters

shape int[]

Shape of the new array.

Returns

NDArray

Type Parameters

T

The desired data-type for the array, e.g., uint8. Default is float64 / double.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ones.html

outer(NDArray, NDArray)

Compute the outer product of two vectors. Given two vectors, a = [a0, a1, ..., aM] and b = [b0, b1, ..., bN], the outer product[R60] is:

public static NDArray outer(NDArray a, NDArray b)

Parameters

a NDArray

First input vector. Input is flattened if not already 1-dimensional.

b NDArray

Second input vector. Input is flattened if not already 1-dimensional.

Returns

NDArray

out[i, j] = a[i] * b[j]

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.outer.html

pad(NDArray, IDictionary<int, object>, PadFunc, object)

public static NDArray pad(NDArray array, IDictionary<int, object> pad_width, np.PadFunc mode, object kwargs = null)

Parameters

array NDArray

pad_width IDictionary<int, object>

mode np.PadFunc

kwargs object

Returns

NDArray

pad(NDArray, IDictionary<int, object>, string, object, object, object, string)

public static NDArray pad(NDArray array, IDictionary<int, object> pad_width, string mode = "constant", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = "even")

Parameters

array NDArray

pad_width IDictionary<int, object>

mode string

constant_values object

end_values object

stat_length object

reflect_type string

Returns

NDArray

pad(NDArray, int, PadFunc, object)

public static NDArray pad(NDArray array, int pad_width, np.PadFunc mode, object kwargs = null)

Parameters

array NDArray

pad_width int

mode np.PadFunc

kwargs object

Returns

NDArray

pad(NDArray, int, string, object, object, object, string)

Pad an array. Scalar pad_width applies (pad_width, pad_width) to every axis.

public static NDArray pad(NDArray array, int pad_width, string mode = "constant", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = "even")

Parameters

array NDArray

pad_width int

mode string

constant_values object

end_values object

stat_length object

reflect_type string

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.pad.html

pad(NDArray, int[,], PadFunc, object)

public static NDArray pad(NDArray array, int[,] pad_width, np.PadFunc mode, object kwargs = null)

Parameters

array NDArray

pad_width int[,]

mode np.PadFunc

kwargs object

Returns

NDArray

pad(NDArray, int[,], string, object, object, object, string)

public static NDArray pad(NDArray array, int[,] pad_width, string mode = "constant", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = "even")

Parameters

array NDArray

pad_width int[,]

mode string

constant_values object

end_values object

stat_length object

reflect_type string

Returns

NDArray

pad(NDArray, int[], PadFunc, object)

public static NDArray pad(NDArray array, int[] pad_width, np.PadFunc mode, object kwargs = null)

Parameters

array NDArray

pad_width int[]

mode np.PadFunc

kwargs object

Returns

NDArray

pad(NDArray, int[], string, object, object, object, string)

public static NDArray pad(NDArray array, int[] pad_width, string mode = "constant", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = "even")

Parameters

array NDArray

pad_width int[]

mode string

constant_values object

end_values object

stat_length object

reflect_type string

Returns

NDArray

pad(NDArray, (int before, int after), PadFunc, object)

public static NDArray pad(NDArray array, (int before, int after) pad_width, np.PadFunc mode, object kwargs = null)

Parameters

array NDArray

pad_width (int before, int after)

mode np.PadFunc

kwargs object

Returns

NDArray

pad(NDArray, (int before, int after), string, object, object, object, string)

public static NDArray pad(NDArray array, (int before, int after) pad_width, string mode = "constant", object constant_values = null, object end_values = null, object stat_length = null, string reflect_type = "even")

Parameters

array NDArray

pad_width (int before, int after)

mode string

constant_values object

end_values object

stat_length object

reflect_type string

Returns

NDArray

percentile(NDArray, NDArray, int?, NDArray, bool, string, bool)

public static NDArray percentile(NDArray a, NDArray q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q NDArray

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

percentile(NDArray, double, int[], NDArray, bool, string, bool)

public static NDArray percentile(NDArray a, double q, int[] axis, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double

axis int[]

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

percentile(NDArray, double, int?, NDArray, bool, string, bool)

Compute the q-th percentile of the data along the specified axis. q must be in [0, 100]. Equivalent to np.quantile(a, q/100).

public static NDArray percentile(NDArray a, double q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.percentile.html

percentile(NDArray, double[], int[], NDArray, bool, string, bool)

public static NDArray percentile(NDArray a, double[] q, int[] axis, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double[]

axis int[]

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

percentile(NDArray, double[], int?, NDArray, bool, string, bool)

public static NDArray percentile(NDArray a, double[] q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double[]

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

place(NDArray, NDArray, NDArray)

Change elements of arr based on a boolean mask. Where mask is true (walked in C-order), the next value from vals (cycling) is written into arr. In-place.

public static void place(NDArray arr, NDArray mask, NDArray vals)

Parameters

arr NDArray

Target array (modified in place).

mask NDArray

Boolean mask. Must have the same total size as arr — NumPy allows shape mismatch as long as element counts match.

vals NDArray

Values to write. Cast to arr's dtype and cycled to fill the True positions. Must be non-empty when at least one mask entry is True (NumPy parity).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.place.html

positive(NDArray, NDArray, NDArray, NPTypeCode?)

Numerical positive, element-wise (identity: returns +x, a copy). Mirrors NumPy's ufunc signature: positive(x, /, out=None, *, where=True, dtype=None).

public static NDArray positive(NDArray nd, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

nd NDArray

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): positive(i32, dtype: float64) widens; bool loop requests raise NumPy's did-not-contain-a-loop TypeError (positive has no bool loop, but positive(bool, dtype: float64) is legal).

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.positive.html

power(NDArray, NDArray)

First array elements raised to powers from second array, element-wise. Supports broadcasting between x1 and x2.

public static NDArray power(NDArray x1, NDArray x2)

Parameters

x1 NDArray

The bases.

x2 NDArray

The exponents (array).

Returns

NDArray

The bases in x1 raised to the exponents in x2.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.power.html

power(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

First array elements raised to powers from second array, element-wise. Mirrors NumPy's ufunc signature: power(x1, x2, /, out=None, *, where=True, dtype=None).

public static NDArray power(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

The bases.

x2 NDArray

The exponents (array).

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the computation runs in this dtype (power(2, -1, dtype: float64) = 0.5; inputs must be same_kind-castable to it).

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.power.html

power(NDArray, NDArray, NPTypeCode)

First array elements raised to powers from second array, element-wise. Supports broadcasting between x1 and x2.

public static NDArray power(NDArray x1, NDArray x2, NPTypeCode typeCode)

Parameters

x1 NDArray

The bases.

x2 NDArray

The exponents (array).

typeCode NPTypeCode

The dtype of the returned NDArray.

Returns

NDArray

The bases in x1 raised to the exponents in x2.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.power.html

power(NDArray, NDArray, Type)

First array elements raised to powers from second array, element-wise. Supports broadcasting between x1 and x2.

public static NDArray power(NDArray x1, NDArray x2, Type dtype)

Parameters

x1 NDArray

The bases.

x2 NDArray

The exponents (array).

dtype Type

The dtype of the returned NDArray.

Returns

NDArray

The bases in x1 raised to the exponents in x2.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.power.html

power(NDArray, object)

First array elements raised to powers from second array, element-wise.

public static NDArray power(NDArray x1, object x2)

Parameters

x1 NDArray

The bases.

x2 object

The exponents (scalar or array-like).

Returns

NDArray

The bases in x1 raised to the exponents in x2. This is a scalar NDArray if both x1 and x2 are scalars.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.power.html

power(NDArray, object, NPTypeCode)

First array elements raised to powers from second array, element-wise.

public static NDArray power(NDArray x1, object x2, NPTypeCode typeCode)

Parameters

x1 NDArray

The bases.

x2 object

The exponents (scalar or array-like).

typeCode NPTypeCode

The dtype of the returned NDArray

Returns

NDArray

The bases in x1 raised to the exponents in x2. This is a scalar NDArray if both x1 and x2 are scalars.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.power.html

power(NDArray, object, Type)

First array elements raised to powers from second array, element-wise.

public static NDArray power(NDArray x1, object x2, Type dtype)

Parameters

x1 NDArray

The bases.

x2 object

The exponents (scalar or array-like).

dtype Type

The dtype of the returned NDArray

Returns

NDArray

The bases in x1 raised to the exponents in x2. This is a scalar NDArray if both x1 and x2 are scalars.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.power.html

power(in NDArray, in NDArray)

First array elements raised to powers from second array, element-wise. Supports broadcasting between x1 and x2.

public static NDArray power(in NDArray x1, in NDArray x2)

Parameters

x1 NDArray

The bases.

x2 NDArray

The exponents (array).

Returns

NDArray

The bases in x1 raised to the exponents in x2.

Remarks

https://docs.scipy.org/doc/numpy/reference/generated/numpy.power.html

power(in NDArray, in NDArray, NPTypeCode)

First array elements raised to powers from second array, element-wise. Supports broadcasting between x1 and x2.

public static NDArray power(in NDArray x1, in NDArray x2, NPTypeCode typeCode)

Parameters

x1 NDArray

The bases.

x2 NDArray

The exponents (array).

typeCode NPTypeCode

The dtype of the returned NDArray.

Returns

NDArray

The bases in x1 raised to the exponents in x2.

Remarks

https://docs.scipy.org/doc/numpy/reference/generated/numpy.power.html

power(in NDArray, in NDArray, Type)

First array elements raised to powers from second array, element-wise. Supports broadcasting between x1 and x2.

public static NDArray power(in NDArray x1, in NDArray x2, Type dtype)

Parameters

x1 NDArray

The bases.

x2 NDArray

The exponents (array).

dtype Type

The dtype of the returned NDArray.

Returns

NDArray

The bases in x1 raised to the exponents in x2.

Remarks

https://docs.scipy.org/doc/numpy/reference/generated/numpy.power.html

printoptions(int?, int?, int?, int?, bool?, string, string, char?, string)

Context manager for setting print options (NumPy's np.printoptions). Restores the previous options when disposed.

public static IDisposable printoptions(int? precision = null, int? threshold = null, int? edgeitems = null, int? linewidth = null, bool? suppress = null, string nanstr = null, string infstr = null, char? sign = null, string floatmode = null)

Parameters

precision int?

threshold int?

edgeitems int?

linewidth int?

suppress bool?

nanstr string

infstr string

sign char?

floatmode string

Returns

IDisposable

Examples

using (np.printoptions(precision: 2, suppress: true)) { Console.WriteLine(arr); }

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.printoptions.html

prod(NDArray, int?, Type, bool)

Return the product of array elements over a given axis.

public static NDArray prod(NDArray a, int? axis = null, Type dtype = null, bool keepdims = false)

Parameters

a NDArray

Input data.

axis int?

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.

dtype Type

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.

keepdims bool

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.

Returns

NDArray

An array shaped as a but with the specified axis removed.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.prod.html

promote_types(NPTypeCode, NPTypeCode)

Returns the data type with the smallest size and smallest scalar kind to which both type1 and type2 can be safely cast.

public static NPTypeCode promote_types(NPTypeCode type1, NPTypeCode type2)

Parameters

type1 NPTypeCode

First data type.

type2 NPTypeCode

Second data type.

Returns

NPTypeCode

The promoted type.

Examples

np.promote_types(NPTypeCode.Int32, NPTypeCode.Single)  // Double
np.promote_types(NPTypeCode.Int16, NPTypeCode.UInt16)  // Int32
np.promote_types(NPTypeCode.Int8, NPTypeCode.Int8)     // Int8

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.promote_types.html

Unlike result_type, promote_types only considers types (not values), and always returns the smallest safe type.

promote_types(Type, Type)

Returns the data type with the smallest size and smallest scalar kind to which both type1 and type2 can be safely cast.

public static NPTypeCode promote_types(Type type1, Type type2)

Parameters

type1 Type

First CLR type.

type2 Type

Second CLR type.

Returns

NPTypeCode

The promoted type as NPTypeCode.

promote_types<T1, T2>()

Returns the data type with the smallest size and smallest scalar kind to which both T1 and T2 can be safely cast.

public static NPTypeCode promote_types<T1, T2>() where T1 : struct where T2 : struct

Returns

NPTypeCode

The promoted type as NPTypeCode.

Type Parameters

T1

First type.

T2

Second type.

Examples

np.promote_types<int, long>()      // Int64
np.promote_types<float, double>()  // Double

ptp(NDArray, int[], NDArray, bool)

public static NDArray ptp(NDArray a, int[] axis, NDArray @out = null, bool keepdims = false)

Parameters

a NDArray

axis int[]

out NDArray

keepdims bool

Returns

NDArray

ptp(NDArray, int?, NDArray, bool)

Range of values (maximum - minimum) along an axis. Equivalent to np.amax(a, axis) - np.amin(a, axis); dtype is preserved, so unsigned/signed integer overflow wraps the same way NumPy does (e.g. ptp(uint8[0,255]) == 255, ptp(int8[-128,127]) == -1).

public static NDArray ptp(NDArray a, int? axis = null, NDArray @out = null, bool keepdims = false)

Parameters

a NDArray

axis int?

out NDArray

keepdims bool

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ptp.html

put(NDArray, NDArray, NDArray, string)

Replace elements of a with given values, at the specified flat indices. In-place — modifies a. Equivalent to a.flat[indices] = values with cyclic broadcasting of values.

public static void put(NDArray a, NDArray indices, NDArray values, string mode = "raise")

Parameters

a NDArray

Target array (modified in place).

indices NDArray

Integer array of flat indices (cast to int64 internally). Indexing is into the C-order flattening of a.

values NDArray

Values to write. Cast to a's dtype. Cycles modulo its size — shorter than indices is fine.

mode string

Boundary mode: "raise" (default), "wrap", or "clip".

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.put.html

put(NDArray, long, object, string)

Scalar-index, scalar-value convenience overload.

public static void put(NDArray a, long index, object value, string mode = "raise")

Parameters

a NDArray

index long

value object

mode string

quantile(NDArray, NDArray, int?, NDArray, bool, string, bool)

NDArray-q overload — accepts a 0-D or 1-D NDArray of quantile values. Higher-rank q is rejected (NumPy raises "q must be a scalar or 1d").

public static NDArray quantile(NDArray a, NDArray q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q NDArray

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

quantile(NDArray, double, int[], NDArray, bool, string, bool)

Compute the q-th quantile, reducing along multiple axes.

public static NDArray quantile(NDArray a, double q, int[] axis, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double

axis int[]

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

quantile(NDArray, double, int?, NDArray, bool, string, bool)

Compute the q-th quantile of the data along the specified axis. q must be in the range [0, 1].

public static NDArray quantile(NDArray a, double q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.quantile.html

quantile(NDArray, double[], int[], NDArray, bool, string, bool)

public static NDArray quantile(NDArray a, double[] q, int[] axis, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double[]

axis int[]

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

quantile(NDArray, double[], int?, NDArray, bool, string, bool)

Compute the q-th quantiles of the data along the specified axis. Each value in q must be in [0, 1]. Result's first axis is q.

public static NDArray quantile(NDArray a, double[] q, int? axis = null, NDArray @out = null, bool overwrite_input = false, string method = "linear", bool keepdims = false)

Parameters

a NDArray

q double[]

axis int?

out NDArray

overwrite_input bool

method string

keepdims bool

Returns

NDArray

rad2deg(NDArray, NDArray, NDArray, NPTypeCode?)

Convert angles from radians to degrees.

public static NDArray rad2deg(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Angle in radians.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of.

Returns

NDArray

The corresponding angle in degrees. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.rad2deg.html

rad2deg(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray rad2deg(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.rad2deg.html

rad2deg(NDArray, Type)

Convert angles from radians to degrees.

public static NDArray rad2deg(NDArray x, Type dtype)

Parameters

x NDArray

Angle in radians.

dtype Type

The dtype the returned ndarray should be of.

Returns

NDArray

The corresponding angle in degrees. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.rad2deg.html

radians(NDArray, NDArray, NDArray, NPTypeCode?)

Convert angles from degrees to radians. Alias for deg2rad.

public static NDArray radians(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Angles in degrees.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of.

Returns

NDArray

The corresponding angle in radians. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.radians.html

radians(NDArray, NPTypeCode)

Alias for deg2rad — positional-dtype convenience overload.

public static NDArray radians(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

dtype NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.radians.html

radians(NDArray, Type)

Convert angles from degrees to radians. Alias for deg2rad.

public static NDArray radians(NDArray x, Type dtype)

Parameters

x NDArray

Angles in degrees.

dtype Type

The dtype the returned ndarray should be of.

Returns

NDArray

The corresponding angle in radians. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.radians.html

ravel(NDArray)

Return a contiguous flattened array. A 1-D array, containing the elements of the input, is returned

public static NDArray ravel(NDArray a)

Parameters

a NDArray

Input array. The elements in a are read in the order specified by order, and packed as a 1-D array.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ravel.html

ravel(NDArray, char)

Return a contiguous flattened array. A 1-D array, containing the elements of the input, is returned

public static NDArray ravel(NDArray a, char order)

Parameters

a NDArray

Input array.

order char

The order in which to read the elements. 'C' - row-major, 'F' - column-major, 'A' - 'F' if a is F-contiguous (and not C-contiguous) else 'C', 'K' - memory order.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ravel.html

ravel_multi_index(NDArray[], int[], string, char)

Converts a tuple of coordinate arrays into an array of flat indices, applying boundary modes per axis. Inverse of unravel_index(NDArray, int[], char).

public static NDArray<long> ravel_multi_index(NDArray[] multi_index, int[] dims, string mode = "raise", char order = 'C')

Parameters

multi_index NDArray[]

Tuple of integer arrays, one per dimension. All arrays must share the same shape, which becomes the shape of the result.

dims int[]

Shape of the array the indices are unravelling into.

mode string

Boundary mode: "raise" (default — throw on OOB), "wrap" (modulo with sign correction), or "clip" (saturate). Applied to every axis.

order char

'C' (row-major, default) or 'F' (column-major). Selects the stride ordering used to fold coordinates into a flat index.

Returns

NDArray<long>

1-D (or shape-preserving) NDArray<TDType> of long.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ravel_multi_index.html

ravel_multi_index(NDArray[], int[], string[], char)

Per-axis mode overload. modes length must match dims length.

public static NDArray<long> ravel_multi_index(NDArray[] multi_index, int[] dims, string[] modes, char order = 'C')

Parameters

multi_index NDArray[]

dims int[]

modes string[]

order char

Returns

NDArray<long>

ravel_multi_index(long[], int[], string, char)

Scalar convenience overload — folds a single coordinate tuple into a flat index. Equivalent to wrapping each coord in a 0-d NDArray but returns a long directly.

public static long ravel_multi_index(long[] coords, int[] dims, string mode = "raise", char order = 'C')

Parameters

coords long[]

dims int[]

mode string

order char

Returns

long

reciprocal(NDArray, NDArray, NDArray, NPTypeCode?)

Return the reciprocal of the argument, element-wise. Calculates 1/x.

public static NDArray reciprocal(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of.

Returns

NDArray

Return array containing 1/x for each element in x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.reciprocal.html

reciprocal(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray reciprocal(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.reciprocal.html

reciprocal(NDArray, Type)

Return the reciprocal of the argument, element-wise. Calculates 1/x.

public static NDArray reciprocal(NDArray x, Type dtype)

Parameters

x NDArray

Input array.

dtype Type

The dtype the returned ndarray should be of.

Returns

NDArray

Return array containing 1/x for each element in x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.reciprocal.html

repeat(NDArray, NDArray, int?)

Repeat elements of an array with per-element repeat counts. Mirrors NumPy np.repeat(a, repeats, axis): scalar / size-1 repeats broadcasts to every element along the (flattened or selected) axis; otherwise the length must match.

public static NDArray repeat(NDArray a, NDArray repeats, int? axis = null)

Parameters

a NDArray

Input array.

repeats NDArray

Repeat counts. Either a 0-d/size-1 array (broadcast) or a 1-D array of length equal to a.size (axis=None) or a.shape[axis].

axis int?

Axis along which to repeat. null flattens the input.

Returns

NDArray

A new array with elements repeated according to repeats.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.repeat.html

repeat(NDArray, int, int?)

Repeat each element of an array after themselves.

public static NDArray repeat(NDArray a, int repeats, int? axis = null)

Parameters

a NDArray

Input array.

repeats int

The number of repetitions for each element.

axis int?

Axis along which to repeat values. null (NumPy None) flattens the input and returns a flat array.

Returns

NDArray

Output array which has the same shape as a, except along axis.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.repeat.html

repeat(NDArray, long, int?)

Repeat each element of an array after themselves.

public static NDArray repeat(NDArray a, long repeats, int? axis = null)

Parameters

a NDArray

Input array.

repeats long

The number of repetitions for each element.

axis int?

Axis along which to repeat values. null (NumPy None) flattens the input.

Returns

NDArray

Output array.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.repeat.html

repeat<T>(T, int)

Repeat a scalar value.

public static NDArray repeat<T>(T a, int repeats) where T : unmanaged

Parameters

a T

Input scalar.

repeats int

The number of repetitions.

Returns

NDArray

A 1-D array with the scalar repeated.

Type Parameters

T

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.repeat.html

repeat<T>(T, long)

Repeat a scalar value.

public static NDArray repeat<T>(T a, long repeats) where T : unmanaged

Parameters

a T

Input scalar.

repeats long

The number of repetitions.

Returns

NDArray

A 1-D array with the scalar repeated.

Type Parameters

T

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.repeat.html

reshape(NDArray, Shape)

Gives a new shape to an array without changing its data.

public static NDArray reshape(NDArray nd, Shape shape)

Parameters

nd NDArray

Array to be reshaped.

shape Shape

The new shape should be compatible with the original shape.

Returns

NDArray

original nd reshaped without copying.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.reshape.html

reshape(NDArray, ref Shape)

Gives a new shape to an array without changing its data.

public static NDArray reshape(NDArray nd, ref Shape shape)

Parameters

nd NDArray

Array to be reshaped.

shape Shape

The new shape should be compatible with the original shape.

Returns

NDArray

original nd reshaped without copying.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.reshape.html

reshape(NDArray, int[])

Gives a new shape to an array without changing its data.

public static NDArray reshape(NDArray nd, int[] shape)

Parameters

nd NDArray

Array to be reshaped.

shape int[]

The new shape should be compatible with the original shape.

Returns

NDArray

original nd reshaped without copying.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.reshape.html

reshape(NDArray, long[])

Gives a new shape to an array without changing its data.

public static NDArray reshape(NDArray nd, long[] shape)

Parameters

nd NDArray

Array to be reshaped.

shape long[]

The new shape should be compatible with the original shape.

Returns

NDArray

original nd reshaped without copying.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.reshape.html

result_type(NDArray, NDArray)

Returns the type that results from applying the NumPy type promotion rules to the two arrays. Convenience overload to avoid params array allocation.

public static NPTypeCode result_type(NDArray arr1, NDArray arr2)

Parameters

arr1 NDArray

First array.

arr2 NDArray

Second array.

Returns

NPTypeCode

The result type from combining the array dtypes.

result_type(params NDArray[])

Returns the type that results from applying the NumPy type promotion rules to the arguments.

public static NPTypeCode result_type(params NDArray[] arrays)

Parameters

arrays NDArray[]

One or more NDArray objects.

Returns

NPTypeCode

The result type from combining the array dtypes.

result_type(NPTypeCode, NPTypeCode)

Returns the type that results from applying the NumPy type promotion rules to the two type codes. Convenience overload to avoid params array allocation.

public static NPTypeCode result_type(NPTypeCode type1, NPTypeCode type2)

Parameters

type1 NPTypeCode

First type code.

type2 NPTypeCode

Second type code.

Returns

NPTypeCode

The result type from combining the inputs.

result_type(params NPTypeCode[])

Returns the type that results from applying the NumPy type promotion rules to the arguments.

public static NPTypeCode result_type(params NPTypeCode[] types)

Parameters

types NPTypeCode[]

One or more NPTypeCode values.

Returns

NPTypeCode

The result type from combining the inputs.

result_type(params object[])

Returns the type that results from applying the NumPy type promotion rules to the arguments.

public static NPTypeCode result_type(params object[] arrays_and_dtypes)

Parameters

arrays_and_dtypes object[]

Arrays and/or dtype arguments. Can be any mix of NDArray, NPTypeCode, or Type.

Returns

NPTypeCode

The result type from combining the inputs.

Examples

np.result_type(NPTypeCode.Int32, NPTypeCode.Int64)    // Int64
np.result_type(NPTypeCode.Int32, NPTypeCode.Single)   // Double
np.result_type(a, b)  // where a, b are NDArrays

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.result_type.html

Type promotion is the operation of determining the result type of an operation involving operands of different types.

result_type(Type, Type)

Returns the type that results from applying the NumPy type promotion rules to the two CLR types. Convenience overload to avoid params array allocation.

public static NPTypeCode result_type(Type type1, Type type2)

Parameters

type1 Type

First CLR type.

type2 Type

Second CLR type.

Returns

NPTypeCode

The result type from combining the inputs.

right_shift(NDArray, NDArray)

Shift the bits of an integer to the right.

public static NDArray right_shift(NDArray x1, NDArray x2)

Parameters

x1 NDArray

Input array (integer types only).

x2 NDArray

Number of bits to shift (integer types only).

Returns

NDArray

Array with bits shifted right.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.right_shift.html

Bits are shifted to the right by removing x2 bits from the right of x1. For unsigned integers, this is logical shift (zeros filled from left). For signed integers, this is arithmetic shift (sign bit extended). This operation is equivalent to floor division by 2**x2.

Example: np.right_shift(20, 2) = 5 # 0b10100 -> 0b101

right_shift(NDArray, object)

Shift the bits of an integer to the right by a scalar or array-like amount.

public static NDArray right_shift(NDArray x1, object x2)

Parameters

x1 NDArray

Input array (integer types only).

x2 object

Number of bits to shift (scalar or array-like).

Returns

NDArray

Array with bits shifted right.

roll(NDArray, int, int?)

Roll array elements along a given axis.

Elements that roll beyond the last position are re-introduced at the first.

public static NDArray roll(NDArray a, int shift, int? axis = null)

Parameters

a NDArray

Input array.

shift int

The number of places by which elements are shifted.

axis int?

Axis along which elements are shifted. By default, the array is flattened before shifting, after which the original shape is restored.

Returns

NDArray

Output array, with the same shape as a.

Remarks

Matches NumPy's algorithm: empty_like + slice-copy pairs. https://numpy.org/doc/stable/reference/generated/numpy.roll.html

roll(NDArray, long, int?)

Roll array elements along a given axis.

Elements that roll beyond the last position are re-introduced at the first.

public static NDArray roll(NDArray a, long shift, int? axis = null)

Parameters

a NDArray

Input array.

shift long

The number of places by which elements are shifted.

axis int?

Axis along which elements are shifted. By default, the array is flattened before shifting, after which the original shape is restored.

Returns

NDArray

Output array, with the same shape as a.

Remarks

Matches NumPy's algorithm: empty_like + slice-copy pairs. https://numpy.org/doc/stable/reference/generated/numpy.roll.html

rollaxis(NDArray, int, int)

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.

public static NDArray rollaxis(NDArray a, int axis, int start = 0)

Parameters

a NDArray

Input array.

axis int

The axis to roll backwards. The positions of the other axes do not change relative to one another.

start int

The axis is rolled until it lies before this position. The default, 0, results in a “complete” roll.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.rollaxis.html

round_(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload. NumPy's np.round/np.around accept out= only (they are functions, not ufuncs — no where=/dtype= kwargs; probed 2.4.2).

public static NDArray round_(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

dtype NPTypeCode

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

round_(NDArray, int, NDArray)

Evenly round to the given number of decimals.

public static NDArray round_(NDArray x, int decimals = 0, NDArray @out = null)

Parameters

x NDArray

Input array

decimals int

out NDArray

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

round_(NDArray, int, NPTypeCode)

Evenly round to the given number of decimals.

public static NDArray round_(NDArray x, int decimals, NPTypeCode dtype)

Parameters

x NDArray

Input array

decimals int

Number of decimal places to round to

dtype NPTypeCode

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

round_(NDArray, int, Type)

Evenly round to the given number of decimals.

public static NDArray round_(NDArray x, int decimals, Type dtype)

Parameters

x NDArray

Input array

decimals int

Number of decimal places to round to

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

round_(NDArray, Type)

Evenly round to the given number of decimals.

public static NDArray round_(NDArray x, Type dtype)

Parameters

x NDArray

Input array

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.around.html

save(string, NDArray)

public static void save(string filepath, NDArray arr)

Parameters

filepath string

arr NDArray

save(string, Array)

public static void save(string filepath, Array arr)

Parameters

filepath string

arr Array

sctype2char(NPTypeCode)

Return the string representation of a scalar dtype.

public static char sctype2char(NPTypeCode sctype)

Parameters

sctype NPTypeCode

A scalar type.

Returns

char

The character code for the type.

Examples

np.sctype2char(NPTypeCode.Int32)   // 'i'
np.sctype2char(NPTypeCode.Double)  // 'd'

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sctype2char.html

Character codes (NumPy): '?' - boolean 'b' - int8 (signed byte) 'B' - uint8 (unsigned byte) 'h' - int16 (short) 'H' - uint16 (unsigned short) 'i' - int32 'I' - uint32 'q' - int64 'Q' - uint64 'e' - float16 (Half) 'f' - float32 'd' - float64 'D' - complex128

searchsorted(NDArray, NDArray, string, NDArray)

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.

public static NDArray searchsorted(NDArray a, NDArray v, string side = "left", NDArray sorter = null)

Parameters

a NDArray

Input 1-D array. Must be sorted ascending unless sorter is provided.

v NDArray

Values to insert into a. May be a scalar or any shape.

side string

If "left" (default), the index of the first suitable location is returned. If "right", the last such index.

sorter NDArray

Optional indices that sort a into ascending order (typically argsort(a)).

Returns

NDArray

Array of insertion points with the same shape as v, or a scalar if v is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.searchsorted.html

searchsorted(NDArray, double, string, NDArray)

Find index where a scalar should be inserted to maintain order.

public static long searchsorted(NDArray a, double v, string side = "left", NDArray sorter = null)

Parameters

a NDArray

v double

side string

sorter NDArray

Returns

long

searchsorted(NDArray, int, string, NDArray)

Find index where a scalar should be inserted to maintain order.

public static long searchsorted(NDArray a, int v, string side = "left", NDArray sorter = null)

Parameters

a NDArray

Input 1-D array. Must be sorted ascending unless sorter is provided.

v int

Value to insert into a.

side string

If "left" (default), index of the first suitable location is returned. If "right", the last such index.

sorter NDArray

Optional indices that sort a into ascending order (typically argsort(a)).

Returns

long

Scalar index for insertion point.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.searchsorted.html

set_printoptions(int?, int?, int?, int?, bool?, string, string, char?, string)

Set printing options (NumPy's np.set_printoptions). These options determine the way floating point numbers, arrays and other NumPy objects are displayed.

public static void set_printoptions(int? precision = null, int? threshold = null, int? edgeitems = null, int? linewidth = null, bool? suppress = null, string nanstr = null, string infstr = null, char? sign = null, string floatmode = null)

Parameters

precision int?

threshold int?

edgeitems int?

linewidth int?

suppress bool?

nanstr string

infstr string

sign char?

floatmode string

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.set_printoptions.html

sign(NDArray, NDArray, NDArray, NPTypeCode?)

public static NDArray sign(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

sign(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray sign(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sign.html

sign(NDArray, Type)

public static NDArray sign(NDArray x, Type dtype)

Parameters

x NDArray

dtype Type

Returns

NDArray

sin(NDArray, NDArray, NDArray, NPTypeCode?)

Trigonometric sine, element-wise. Mirrors NumPy's ufunc signature: sin(x, /, out=None, *, where=True, dtype=None).

public static NDArray sin(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Angle, in radians (2 \pi rad equals 360 degrees).

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the computation runs at this precision; integer/bool requests raise NumPy's "No loop matching" error.

Returns

NDArray

The sine of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sin.html

sin(NDArray, NPTypeCode)

Trigonometric sine, element-wise, computed in dtype. Positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray sin(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Angle, in radians (2 \pi rad equals 360 degrees).

dtype NPTypeCode

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sin.html

sin(NDArray, Type)

Trigonometric sine, element-wise.

public static NDArray sin(NDArray x, Type dtype)

Parameters

x NDArray

Angle, in radians (2 \pi rad equals 360 degrees).

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The sine of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sin.html

sinh(NDArray, NDArray, NDArray, NPTypeCode?)

Hyperbolic sine, element-wise.
Equivalent to 1/2 * (np.exp(x) - np.exp(-x)) or -1j * np.sin(1j*x).

public static NDArray sinh(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The sine of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sinh.html

sinh(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray sinh(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sinh.html

sinh(NDArray, Type)

Hyperbolic sine, element-wise.
Equivalent to 1/2 * (np.exp(x) - np.exp(-x)) or -1j * np.sin(1j*x).

public static NDArray sinh(NDArray x, Type dtype)

Parameters

x NDArray

Input array.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The sine of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sinh.html

size(NDArray, int?)

Return the number of elements along a given axis.

public static long size(NDArray a, int? axis = null)

Parameters

a NDArray

Input data.

axis int?

Axis along which the elements are counted. By default, give the total number of elements.

Returns

long

Number of elements along the specified axis.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.ma.size.html

sort(NDArray, int?, string)

Return a sorted copy of an array, sorted along axis (default last; null flattens first). NumPy np.sort.

public static NDArray sort(NDArray a, int? axis = -1, string kind = null)

Parameters

a NDArray

Array to sort.

axis int?

Axis to sort along. -1 = last axis. null = sort the flattened array.

kind string

Sort algorithm name (NumPy compatibility). All kinds produce identical sorted output; the kernel is a stable LSD radix (numeric) or BCL introsort (Half/Complex/Decimal).

Returns

NDArray

Remarks

NaN floats sort to the end; complex sorts lexicographically (real then imaginary), any-NaN-part last — matching NumPy 2.4.2.

split(NDArray, int, int)

Split an array into multiple sub-arrays as views into ary.

public static NDArray[] split(NDArray ary, int indices_or_sections, int axis = 0)

Parameters

ary NDArray

Array to be divided into sub-arrays.

indices_or_sections int

If 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.

axis int

The axis along which to split, default is 0.

Returns

NDArray[]

A list of sub-arrays as views into ary.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.split.html

Exceptions

ArgumentException

If indices_or_sections is an integer and does not result in equal division.

split(NDArray, int[], int)

Split an array into multiple sub-arrays as views into ary.

public static NDArray[] split(NDArray ary, int[] indices, int axis = 0)

Parameters

ary NDArray

indices int[]

axis int

Returns

NDArray[]

split(NDArray, long[], int)

Split an array into multiple sub-arrays as views into ary.

public static NDArray[] split(NDArray ary, long[] indices, int axis = 0)

Parameters

ary NDArray

indices long[]

axis int

Returns

NDArray[]

sqrt(NDArray, NDArray, NDArray, NPTypeCode?)

Return the non-negative square-root of an array, element-wise. Mirrors NumPy's ufunc signature: sqrt(x, /, out=None, *, where=True, dtype=None).

public static NDArray sqrt(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

The values whose square-roots are required.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the computation runs at this precision; integer/bool requests raise NumPy's "No loop matching" error.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html

sqrt(NDArray, NPTypeCode)

Return the non-negative square-root of an array, element-wise, computed in dtype. Positional-dtype convenience overload (NumPy accepts dtype only as a keyword; the NumPy-shaped overload above takes it after out/where).

public static NDArray sqrt(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

The values whose square-roots are required.

dtype NPTypeCode

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html

sqrt(NDArray, Type)

Return the non-negative square-root of an array, element-wise.

public static NDArray sqrt(NDArray x, Type dtype)

Parameters

x NDArray

The values whose square-roots are required.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html

square(NDArray)

Return the element-wise square of the input.

public static NDArray square(NDArray x)

Parameters

x NDArray

Input data.

Returns

NDArray

Element-wise x*x, of the same shape and dtype as x. Returns scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.power.html

square(NDArray, NDArray, NDArray, NPTypeCode?)

Return the element-wise square of the input. Mirrors NumPy's ufunc signature: square(x, /, out=None, *, where=True, dtype=None).

public static NDArray square(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input data.

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the input must be same_kind-castable to it.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.square.html

squeeze(NDArray)

Remove single-dimensional entries from the shape of an array.

public static NDArray squeeze(NDArray a)

Parameters

a NDArray

Input data.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.squeeze.html

squeeze(NDArray, int)

Remove single-dimensional entries from the shape of an array.

public static NDArray squeeze(NDArray a, int axis)

Parameters

a NDArray

Input data.

axis int

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.squeeze.html

Exceptions

IncorrectShapeException

If axis is not None, and an axis being squeezed is not of length 1

squeeze(Shape)

Remove single-dimensional entries from a shape.

public static Shape squeeze(Shape shape)

Parameters

shape Shape

Input shape.

Returns

Shape

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.squeeze.html

stack(NDArray[], int)

Join a sequence of arrays along a new axis. The axis parameter specifies the index of the new axis in the dimensions of the result. For example, if axis=0 it will be the first dimension and if axis=-1 it will be the last dimension.

public static NDArray stack(NDArray[] arrays, int axis = 0)

Parameters

arrays NDArray[]

Each array must have the same shape.

axis int

The axis in the result array along which the input arrays are stacked.

Returns

NDArray

The stacked array has one more dimension than the input arrays.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.stack.html

std(NDArray, bool, int?, NPTypeCode?)

Compute the standard deviation along the specified axis. Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray std(NDArray a, bool keepdims = false, int? ddof = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Calculate the standard deviation of these values.

keepdims bool

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.

ddof int?

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.

dtype NPTypeCode?

Returns

NDArray

returns a new array containing the std values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.std.html

std(NDArray, int, NPTypeCode, bool, int?)

Compute the standard deviation along the specified axis. Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray std(NDArray a, int axis, NPTypeCode type, bool keepdims = false, int? ddof = null)

Parameters

a NDArray

Calculate the standard deviation of these values.

axis int

Axis or axes along which the standard deviation is computed. The default is to compute the standard deviation of the flattened array.

type NPTypeCode

keepdims bool

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.

ddof int?

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.

Returns

NDArray

returns a new array containing the std values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.std.html

std(NDArray, int, bool, int?, NPTypeCode?)

Compute the standard deviation along the specified axis. Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray std(NDArray a, int axis, bool keepdims = false, int? ddof = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Calculate the standard deviation of these values.

axis int

Axis or axes along which the standard deviation is computed. The default is to compute the standard deviation of the flattened array.

keepdims bool

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.

ddof int?

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.

dtype NPTypeCode?

Returns

NDArray

returns a new array containing the std values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.std.html

std(NDArray, int, Type, bool, int?)

Compute the standard deviation along the specified axis. Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray std(NDArray a, int axis, Type dtype, bool keepdims = false, int? ddof = null)

Parameters

a NDArray

Calculate the standard deviation of these values.

axis int

Axis or axes along which the standard deviation is computed. The default is to compute the standard deviation of the flattened array.

dtype Type

keepdims bool

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.

ddof int?

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.

Returns

NDArray

returns a new array containing the std values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.std.html

subtract(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

public static NDArray subtract(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

x2 NDArray

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.subtract.html

sum(NDArray)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a)

Parameters

a NDArray

Elements to sum.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

sum(NDArray, bool)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a, bool keepdims)

Parameters

a NDArray

Elements to sum.

keepdims bool

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

sum(NDArray, int)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a, int axis)

Parameters

a NDArray

Elements to sum.

axis int

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

sum(NDArray, NPTypeCode?)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a, NPTypeCode? typeCode)

Parameters

a NDArray

Elements to sum.

typeCode NPTypeCode?

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

sum(NDArray, int?, bool)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a, int? axis, bool keepdims)

Parameters

a NDArray

Elements to sum.

axis int?

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.

keepdims bool

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

sum(NDArray, int?, bool, NPTypeCode?)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a, int? axis, bool keepdims, NPTypeCode? typeCode)

Parameters

a NDArray

Elements to sum.

axis int?

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.

keepdims bool

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.

typeCode NPTypeCode?

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

sum(NDArray, int?, bool, Type)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a, int? axis, bool keepdims, Type dtype)

Parameters

a NDArray

Elements to sum.

axis int?

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.

keepdims bool

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.

dtype Type

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

sum(NDArray, int?, NPTypeCode?)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a, int? axis, NPTypeCode? typeCode)

Parameters

a NDArray

Elements to sum.

axis int?

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.

typeCode NPTypeCode?

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

sum(NDArray, int?, Type)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a, int? axis, Type dtype)

Parameters

a NDArray

Elements to sum.

axis int?

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.

dtype Type

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

sum(NDArray, Type)

Sum of array elements over a given axis.

public static NDArray sum(NDArray a, Type dtype)

Parameters

a NDArray

Elements to sum.

dtype Type

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.

Returns

NDArray

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.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.sum.html

swapaxes(NDArray, int, int)

Interchange two axes of an array.

public static NDArray swapaxes(NDArray a, int axis1, int axis2)

Parameters

a NDArray

Input array.

axis1 int

First axis.

axis2 int

Second axis.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.swapaxes.html

take(NDArray, NDArray, int?, NDArray, string)

Take elements from an array along an axis. Equivalent to fancy indexing along the specified axis.

public static NDArray take(NDArray a, NDArray indices, int? axis = null, NDArray @out = null, string mode = "raise")

Parameters

a NDArray

Source array.

indices NDArray

Integer array of indices to take.

axis int?

Axis along which to take. null (default) flattens a and treats indices as flat indices.

out NDArray

Optional destination array. When supplied, its shape must match the natural take output; values are cast to out's dtype via copyto(NDArray, NDArray, string, NDArray) with unsafe casting and the method returns out itself. When null (default), a fresh array is allocated with a's dtype.

mode string

Boundary mode: "raise" (default — throw on OOB), "wrap" (modulo with sign correction), or "clip" (saturate).

Returns

NDArray

New array with shape:

• axis=None: same as indices.
• axis=k: a.shape[:k] + indices.shape + a.shape[k+1:].

Dtype matches a (or out's dtype when out is supplied).

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.take.html

take(NDArray, long, int?, NDArray, string)

Scalar convenience overload — take a single element by flat index.

public static NDArray take(NDArray a, long index, int? axis = null, NDArray @out = null, string mode = "raise")

Parameters

a NDArray

index long

axis int?

out NDArray

mode string

Returns

NDArray

tan(NDArray, NDArray, NDArray, NPTypeCode?)

Compute tangent element-wise.
Equivalent to np.sin(x)/np.cos(x) element-wise. Mirrors NumPy's ufunc signature: tan(x, /, out=None, *, where=True, dtype=None).

public static NDArray tan(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Angle, in radians (2 \pi rad equals 360 degrees).

out NDArray

where NDArray

Boolean mask: only mask-true elements are computed/written (NumPy ufunc where=).

dtype NPTypeCode?

Explicit loop dtype (NumPy ufunc dtype=): the computation runs at this precision; integer/bool requests raise NumPy's "No loop matching" error.

Returns

NDArray

The tangent of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.tan.html

tan(NDArray, NPTypeCode)

Compute tangent element-wise, computed in dtype. Positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray tan(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Angle, in radians (2 \pi rad equals 360 degrees).

dtype NPTypeCode

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.tan.html

tan(NDArray, Type)

Trigonometric sine, element-wise.

public static NDArray tan(NDArray x, Type dtype)

Parameters

x NDArray

Angle, in radians (2 \pi rad equals 360 degrees).

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The sine of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.tan.html

tanh(NDArray, NDArray, NDArray, NPTypeCode?)

Compute hyperbolic tangent element-wise.
Equivalent to np.sinh(x)/np.cosh(x) or -1j * np.tan(1j*x).

public static NDArray tanh(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The sine of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.tanh.html

tanh(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray tanh(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.tanh.html

tanh(NDArray, Type)

Compute hyperbolic tangent element-wise.
Equivalent to np.sinh(x)/np.cosh(x) or -1j * np.tan(1j*x).

public static NDArray tanh(NDArray x, Type dtype)

Parameters

x NDArray

Input array.

dtype Type

The dtype the returned ndarray should be of, only non integer values are supported.

Returns

NDArray

The sine of each element of x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.tanh.html

tile(NDArray, params int[])

Construct an array by repeating A the number of times given by reps.

If reps has length d, the result has dimension max(d, A.ndim). If A.ndim < d, A is promoted to be d-dimensional by prepending size-1 axes. If A.ndim > d, reps is promoted to A.ndim by prepending 1s.

public static NDArray tile(NDArray A, params int[] reps)

Parameters

A NDArray

The input array.

reps int[]

The number of repetitions of A along each axis. Each rep must be non-negative.

Returns

NDArray

The tiled output array. Expanded outputs are C-contiguous; all-one reps produce a keep-order copy. Dtype matches A.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.tile.html

Exceptions

ArgumentNullException

If A or reps is null.

ArgumentException

If any element of reps is negative.

tile(NDArray, long[])

Construct an array by repeating A the number of times given by reps.

Long overload — see tile(NDArray, params int[]).

public static NDArray tile(NDArray A, long[] reps)

Parameters

A NDArray

reps long[]

Returns

NDArray

trace(NDArray, int, int, int, Type, NDArray)

Return the sum along diagonals of the array. For a 2-D array, trace(a) == sum(a.diagonal()). For an N-D array, traces the diagonals along the 2-D sub-arrays defined by axis1 / axis2 and reduces them, leaving an array with those two axes removed.

public static NDArray trace(NDArray a, int offset = 0, int axis1 = 0, int axis2 = 1, Type dtype = null, NDArray @out = null)

Parameters

a NDArray

Source array. Must have at least 2 dimensions.

offset int

Offset of the diagonal from the main diagonal. See diagonal(NDArray, int, int, int) for details.

axis1 int

First axis of the 2-D sub-array. Default 0.

axis2 int

Second axis of the 2-D sub-array. Default 1.

dtype Type

Output dtype. null (default) preserves a.dtype, except integer dtypes narrower than long promote to long (NEP50 / matches NumPy's "default platform integer" rule). Bool input promotes to long.

out NDArray

Optional output array. Shape must equal the natural reduction output; values are copied with unsafe casting and the method returns out itself.

Returns

NDArray

Sum along the diagonal. 2-D input → 0-d scalar. N-D input → array with a.shape minus axis1 and axis2.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.trace.html

Mirrors NumPy's PyArray_Trace: sum(diagonal(a, offset, axis1, axis2), axis=-1, dtype=dtype, out=out). The diagonal view is the heavy lifting; the sum is a regular reduction that goes through NumSharp's IL reduction kernels.

transpose(NDArray, int[])

Permute the dimensions of an array.

public static NDArray transpose(NDArray a, int[] premute = null)

Parameters

a NDArray

Input array.

premute int[]

By default, reverse the dimensions, otherwise permute the axes according to the values given.

Returns

NDArray

a with its axes permuted. A view is returned whenever possible.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.transpose.html

true_divide(NDArray, NDArray, NDArray, NDArray, NPTypeCode?)

public static NDArray true_divide(NDArray x1, NDArray x2, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x1 NDArray

x2 NDArray

out NDArray

where NDArray

dtype NPTypeCode?

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.true_divide.html

trunc(NDArray, NDArray, NDArray, NPTypeCode?)

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.

public static NDArray trunc(NDArray x, NDArray @out = null, NDArray where = null, NPTypeCode? dtype = null)

Parameters

x NDArray

Input array.

out NDArray

where NDArray

dtype NPTypeCode?

The dtype the returned ndarray should be of.

Returns

NDArray

The truncated value of each element in x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.trunc.html

trunc(NDArray, NPTypeCode)

Computed in dtype — positional-dtype convenience overload (NumPy accepts dtype only as a keyword).

public static NDArray trunc(NDArray x, NPTypeCode dtype)

Parameters

x NDArray

Input array.

dtype NPTypeCode

The loop dtype the computation should run in.

Returns

NDArray

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.trunc.html

trunc(NDArray, Type)

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.

public static NDArray trunc(NDArray x, Type dtype)

Parameters

x NDArray

Input array.

dtype Type

The dtype the returned ndarray should be of.

Returns

NDArray

The truncated value of each element in x. This is a scalar if x is a scalar.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.trunc.html

unique(NDArray)

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:

• the indices of the input array that give the unique values
  
• the indices of the unique array that reconstruct the input array
  
• the number of times each unique value comes up in the input array
  

public static NDArray unique(NDArray ar)

Parameters

ar NDArray

Returns

NDArray

The sorted unique values.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.unique.html

unique(NDArray, bool, bool, bool, int?, bool)

Find the unique elements of an array with full NumPy keyword argument support.

Returns sorted unique elements; optionally returns first-occurrence indices, reconstruction indices, and counts. Supports axis-aware uniqueness.

public static NDArray[] unique(NDArray ar, bool return_index, bool return_inverse = false, bool return_counts = false, int? axis = null, bool equal_nan = true)

Parameters

ar NDArray

Input array.

return_index bool

If True, also return indices of ar (along the specified axis, if provided) that result in the unique array.

return_inverse bool

If True, also return the indices of the unique array that can be used to reconstruct ar.

return_counts bool

If True, also return the number of times each unique item appears in ar.

axis int?

The axis to operate on. If null, the array is flattened first.

equal_nan bool

If True (default), all NaN values are considered equal so only one appears in the output. If False, each NaN is treated as unique.

Returns

NDArray[]

An array of NDArrays in order: [values, index?, inverse?, counts?]. The first element is always the sorted unique values; remaining elements are present only when the corresponding flag is True.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.unique.html

unravel_index(NDArray, int[], char)

Converts a flat index or array of flat indices into a tuple of coordinate arrays. Inverse of ravel_multi_index(NDArray[], int[], string, char).

public static NDArray<long>[] unravel_index(NDArray indices, int[] shape, char order = 'C')

Parameters

indices NDArray

An integer array whose elements are indices into the flattened version of an array of dimensions shape. Cast to int64 internally.

shape int[]

The shape of the array to use for unraveling.

order char

'C' (row-major, default) or 'F' (column-major) — selects the extraction order for the coordinate tuple.

Returns

NDArray<long>[]

A tuple of shape.Length NDArrays. Each output array has the same shape as indices. Element dtype is always Int64.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.unravel_index.html

Exceptions

ArgumentException

shape is empty, has non-positive dims, or the dims' product overflows int64.

ArgumentOutOfRangeException

Any index in indices is < 0 or

= product of shape.

unravel_index(long, int[], char)

Scalar convenience overload — converts a single flat index into a coord array. Equivalent to unravel_index(NDArray.Scalar(index), shape, order) but returns a long[] directly without NDArray wrapping.

public static long[] unravel_index(long index, int[] shape, char order = 'C')

Parameters

index long

shape int[]

order char

Returns

long[]

var(NDArray, bool, int?, NPTypeCode?)

Compute the variance along the specified axis. Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray var(NDArray a, bool keepdims = false, int? ddof = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Array containing numbers whose variance is desired. If a is not an array, a conversion is attempted.

keepdims bool

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.

ddof int?

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.

dtype NPTypeCode?

Returns

NDArray

returns a new array containing the var values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.var.html

var(NDArray, int, NPTypeCode, bool, int?)

Compute the variance along the specified axis. Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray var(NDArray a, int axis, NPTypeCode type, bool keepdims = false, int? ddof = null)

Parameters

a NDArray

Array containing numbers whose variance is desired. If a is not an array, a conversion is attempted.

axis int

Axis or axes along which the variance is computed. The default is to compute the variance of the flattened array.

type NPTypeCode

keepdims bool

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.

ddof int?

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.

Returns

NDArray

returns a new array containing the var values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.var.html

var(NDArray, int, bool, int?, NPTypeCode?)

Compute the variance along the specified axis. Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray var(NDArray a, int axis, bool keepdims = false, int? ddof = null, NPTypeCode? dtype = null)

Parameters

a NDArray

Array containing numbers whose variance is desired. If a is not an array, a conversion is attempted.

axis int

Axis or axes along which the variance is computed. The default is to compute the variance of the flattened array.

keepdims bool

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.

ddof int?

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.

dtype NPTypeCode?

Returns

NDArray

returns a new array containing the var values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.var.html

var(NDArray, int, Type, bool, int?)

Compute the variance along the specified axis. Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.

public static NDArray var(NDArray a, int axis, Type dtype, bool keepdims = false, int? ddof = null)

Parameters

a NDArray

Array containing numbers whose variance is desired. If a is not an array, a conversion is attempted.

axis int

Axis or axes along which the variance is computed. The default is to compute the variance of the flattened array.

dtype Type

keepdims bool

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.

ddof int?

Means Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. By default ddof is zero.

Returns

NDArray

returns a new array containing the var values, otherwise a reference to the output array is returned.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.var.html

vsplit(NDArray, int)

Split an array into multiple sub-arrays vertically (row-wise).

public static NDArray[] vsplit(NDArray ary, int indices_or_sections)

Parameters

ary NDArray

Array to be divided into sub-arrays.

indices_or_sections int

If an integer, N, the array will be divided into N equal arrays along axis 0. If such a split is not possible, an error is raised.

Returns

NDArray[]

A list of sub-arrays as views into ary.

Remarks

Equivalent to split with axis=0. Array must have ndim >= 2. https://numpy.org/doc/stable/reference/generated/numpy.vsplit.html

vsplit(NDArray, int[])

Split an array into multiple sub-arrays vertically (row-wise).

public static NDArray[] vsplit(NDArray ary, int[] indices)

Parameters

ary NDArray

Array to be divided into sub-arrays.

indices int[]

A 1-D array of sorted integers indicating where along axis 0 the array is split. For example, [2, 3] would result in ary[:2], ary[2:3], ary[3:].

Returns

NDArray[]

A list of sub-arrays as views into ary.

Remarks

Equivalent to split with axis=0. Array must have ndim >= 2. https://numpy.org/doc/stable/reference/generated/numpy.vsplit.html

vstack(params NDArray[])

Stack arrays in sequence vertically (row wise).
This is equivalent to concatenation along the first axis after 1-D arrays of shape(N,) have been reshaped to(1, N). Rebuilds arrays divided by vsplit.

public static NDArray vstack(params NDArray[] tup)

Parameters

tup NDArray[]

The arrays must have the same shape along all but the first axis. 1-D arrays must have the same length.

Returns

NDArray

The array formed by stacking the given arrays, will be at least 2-D.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.vstack.html

where(NDArray)

Equivalent to nonzero(NDArray): returns the indices where condition is non-zero.

public static NDArray<long>[] where(NDArray condition)

Parameters

condition NDArray

Input array. Non-zero entries yield their indices.

Returns

NDArray<long>[]

Tuple of arrays with indices where condition is non-zero, one per dimension.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.where.html

where(NDArray, NDArray, NDArray)

Return elements chosen from x or y depending on condition.

public static NDArray where(NDArray condition, NDArray x, NDArray y)

Parameters

condition NDArray

Where True, yield x, otherwise yield y.

x NDArray

Values from which to choose where condition is True.

y NDArray

Values from which to choose where condition is False.

Returns

NDArray

An array with elements from x where condition is True, and elements from y elsewhere.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.where.html

where(NDArray, NDArray, object)

Return elements chosen from x or y depending on condition. Scalar overload for y.

public static NDArray where(NDArray condition, NDArray x, object y)

Parameters

condition NDArray

x NDArray

y object

Returns

NDArray

where(NDArray, object, NDArray)

Return elements chosen from x or y depending on condition. Scalar overload for x.

public static NDArray where(NDArray condition, object x, NDArray y)

Parameters

condition NDArray

x object

y NDArray

Returns

NDArray

where(NDArray, object, object)

Return elements chosen from x or y depending on condition. Scalar overload for both x and y.

public static NDArray where(NDArray condition, object x, object y)

Parameters

condition NDArray

x object

y object

Returns

NDArray

zeros(Shape)

Return a new double array of given shape, filled with zeros.

public static NDArray zeros(Shape shape)

Parameters

shape Shape

Shape of the new array,

Returns

NDArray

Array of zeros with the given shape, dtype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros.html

zeros(Shape, NPTypeCode)

Return a new double array of given shape, filled with zeros.

public static NDArray zeros(Shape shape, NPTypeCode typeCode)

Parameters

shape Shape

Shape of the new array,

typeCode NPTypeCode

The desired data-type for the array, e.g., uint8. Default is float64 / double.

Returns

NDArray

Array of zeros with the given shape, dtype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros.html

zeros(Shape, Type)

Return a new double array of given shape, filled with zeros.

public static NDArray zeros(Shape shape, Type dtype)

Parameters

shape Shape

Shape of the new array,

dtype Type

The desired data-type for the array, e.g., uint8. Default is float64 / double.

Returns

NDArray

Array of zeros with the given shape, dtype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros.html

zeros(int)

Return a new double array of given shape, filled with zeros.

public static NDArray zeros(int shape)

Parameters

shape int

Returns

NDArray

Array of zeros with the given shape, dtype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros.html

zeros(int[])

Return a new double array of given shape, filled with zeros.

public static NDArray zeros(int[] shape)

Parameters

shape int[]

Shape of the new array,

Returns

NDArray

Array of zeros with the given shape, dtype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros.html

zeros(long[])

Return a new double array of given shape, filled with zeros.

public static NDArray zeros(long[] shape)

Parameters

shape long[]

Shape of the new array,

Returns

NDArray

Array of zeros with the given shape, dtype.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros.html

zeros_like(NDArray, Type)

Return an array of zeros with the same shape and type as a given array.

public static NDArray zeros_like(NDArray a, Type dtype = null)

Parameters

a NDArray

The shape and data-type of a define these same attributes of the returned array.

dtype Type

Overrides the data type of the result.

Returns

NDArray

Array of zeros with the same shape and type as nd.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros_like.html

zeros_like(NDArray, Type, char)

Return an array of zeros with the same shape and type as a given array.

public static NDArray zeros_like(NDArray a, Type dtype, char order)

Parameters

a NDArray

The shape and data-type of a define these same attributes of the returned array.

dtype Type

Overrides the data type of the result.

order char

Memory layout: 'C', 'F', 'A' or 'K' (default, preserves source layout).

Returns

NDArray

Array of zeros with the same shape and type as nd.

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros_like.html

zeros<T>(int[])

Return a new double array of given shape, filled with zeros.

public static NDArray zeros<T>(int[] shape) where T : unmanaged

Parameters

shape int[]

Shape of the new array,

Returns

NDArray

Array of zeros with the given shape, type T.

Type Parameters

T

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros.html

zeros<T>(long[])

Return a new double array of given shape, filled with zeros.

public static NDArray zeros<T>(long[] shape) where T : unmanaged

Parameters

shape long[]

Shape of the new array,

Returns

NDArray

Array of zeros with the given shape, type T.

Type Parameters

T

Remarks

https://numpy.org/doc/stable/reference/generated/numpy.zeros.html