[ILNumerics Computing Engine]
ILNumericsILMath
Namespace: ILNumerics
Assembly: ILNumerics.Computing (in ILNumerics.Computing.dll) Version: 5.5.0.0 (5.5.7503.3146)
The ILMath type exposes the following members.
Name | Description | |
---|---|---|
FFT |
FFT implementation, used to compute Fast Fourier Transforms.
[ILNumerics Computing Engine] | |
Lapack |
This member provides the currently selected LAPACK implementation for linear algebra funtions and matrix multiply.
[ILNumerics Computing Engine] |
Name | Description | |
---|---|---|
abs(BaseArraycomplex) |
Absolute values of array elements.
[ILNumerics Computing Engine] | |
abs(BaseArrayfcomplex) |
Absolute values of array elements.
[ILNumerics Computing Engine] | |
abs(BaseArrayDouble) |
Absolute values of array elements.
[ILNumerics Computing Engine] | |
abs(BaseArrayInt16) |
Absolute values of array elements.
[ILNumerics Computing Engine] | |
abs(BaseArrayInt32) |
Absolute values of array elements.
[ILNumerics Computing Engine] | |
abs(BaseArrayInt64) |
Absolute values of array elements.
[ILNumerics Computing Engine] | |
abs(BaseArraySByte) |
Absolute values of array elements.
[ILNumerics Computing Engine] | |
abs(BaseArraySingle) |
Absolute values of array elements.
[ILNumerics Computing Engine] | |
acos(BaseArraycomplex) |
Computes angles for cosine array elements.
[ILNumerics Computing Engine] | |
acos(BaseArrayfcomplex) |
Computes angles for cosine array elements.
[ILNumerics Computing Engine] | |
acos(BaseArrayDouble) |
Computes angles for cosine array elements.
[ILNumerics Computing Engine] | |
acos(BaseArraySingle) |
Computes angles for cosine array elements.
[ILNumerics Computing Engine] | |
add(BaseArraycomplex, BaseArraycomplex) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArrayfcomplex, BaseArrayfcomplex) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArrayByte, BaseArrayByte) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArrayDouble, BaseArrayDouble) |
Binary, elementwise, broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArrayInt16, BaseArrayInt16) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArrayInt32, BaseArrayInt32) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArrayInt64, BaseArrayInt64) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArraySByte, BaseArraySByte) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArraySingle, BaseArraySingle) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArrayUInt16, BaseArrayUInt16) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArrayUInt32, BaseArrayUInt32) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add(BaseArrayUInt64, BaseArrayUInt64) |
Binary broadcasting operation: Add.
[ILNumerics Computing Engine] | |
add_sat(BaseArrayByte, BaseArrayByte) |
Binary broadcasting operation: Add, saturating.
[ILNumerics Computing Engine] | |
add_sat(BaseArrayInt16, BaseArrayInt16) |
Binary broadcasting operation: Add, saturating.
[ILNumerics Computing Engine] | |
add_sat(BaseArrayInt32, BaseArrayInt32) |
Binary broadcasting operation: Add, saturating.
[ILNumerics Computing Engine] | |
add_sat(BaseArrayInt64, BaseArrayInt64) |
Binary broadcasting operation: Add, saturating.
[ILNumerics Computing Engine] | |
add_sat(BaseArraySByte, BaseArraySByte) |
Binary broadcasting operation: Add, saturating.
[ILNumerics Computing Engine] | |
add_sat(BaseArrayUInt16, BaseArrayUInt16) |
Binary broadcasting operation: Add, saturating.
[ILNumerics Computing Engine] | |
add_sat(BaseArrayUInt32, BaseArrayUInt32) |
Binary broadcasting operation: Add, saturating.
[ILNumerics Computing Engine] | |
add_sat(BaseArrayUInt64, BaseArrayUInt64) |
Binary broadcasting operation: Add, saturating.
[ILNumerics Computing Engine] | |
all(BaseArraycomplex, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArrayfcomplex, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArrayBoolean, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are true.
[ILNumerics Computing Engine] | |
all(BaseArrayByte, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArrayDouble, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArrayInt16, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArrayInt32, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArrayInt64, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArraySByte, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArraySingle, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArrayUInt16, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArrayUInt32, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
all(BaseArrayUInt64, Int32, Boolean) |
Determines whether all elements of A along the given dimension dim are 'not zero'.
[ILNumerics Computing Engine] | |
allall(BaseArraycomplex) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayfcomplex) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayBoolean) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayByte) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayDouble) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayInt16) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayInt32) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayInt64) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArraySByte) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArraySingle) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayUInt16) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayUInt32) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
allall(BaseArrayUInt64) |
Tests if all elements of A are non-zero.
[ILNumerics Computing Engine] | |
and(BaseArraycomplex, BaseArraycomplex) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayfcomplex, BaseArrayfcomplex) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayBoolean, BaseArrayBoolean) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayByte, BaseArrayByte) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayDouble, BaseArrayDouble) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayInt16, BaseArrayInt16) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayInt32, BaseArrayInt32) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayInt64, BaseArrayInt64) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArraySByte, BaseArraySByte) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArraySingle, BaseArraySingle) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayUInt16, BaseArrayUInt16) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayUInt32, BaseArrayUInt32) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
and(BaseArrayUInt64, BaseArrayUInt64) |
Elementwise 'And' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
any(BaseArraycomplex, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArrayfcomplex, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArrayBoolean, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is true.
[ILNumerics Computing Engine] | |
any(BaseArrayByte, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArrayDouble, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArrayInt16, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArrayInt32, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArrayInt64, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArraySByte, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArraySingle, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArrayUInt16, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArrayUInt32, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
any(BaseArrayUInt64, Int32, Boolean) |
Determines whether any element of A along the given dimension dim is not zero.
[ILNumerics Computing Engine] | |
anyall(BaseArraycomplex) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayfcomplex) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayBoolean) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayByte) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayDouble) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayInt16) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayInt32) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayInt64) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArraySByte) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArraySingle) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayUInt16) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayUInt32) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
anyall(BaseArrayUInt64) |
Tests if any elements of A are non-zero.
[ILNumerics Computing Engine] | |
apply(BaseArraycomplex, BaseArraycomplex, Funccomplex, complex, complex) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArrayfcomplex, BaseArrayfcomplex, Funcfcomplex, fcomplex, fcomplex) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArrayByte, BaseArrayByte, FuncByte, Byte, Byte) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArrayDouble, BaseArrayDouble, FuncDouble, Double, Double) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArrayInt16, BaseArrayInt16, FuncInt16, Int16, Int16) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArrayInt32, BaseArrayInt32, FuncInt32, Int32, Int32) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArrayInt64, BaseArrayInt64, FuncInt64, Int64, Int64) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArraySByte, BaseArraySByte, FuncSByte, SByte, SByte) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArraySingle, BaseArraySingle, FuncSingle, Single, Single) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArrayUInt16, BaseArrayUInt16, FuncUInt16, UInt16, UInt16) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArrayUInt32, BaseArrayUInt32, FuncUInt32, UInt32, UInt32) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
apply(BaseArrayUInt64, BaseArrayUInt64, FuncUInt64, UInt64, UInt64) |
Binary, elementwise, broadcasting operation: apply(A,B).
[ILNumerics Computing Engine] | |
applyT(BaseArrayT, BaseArrayT, FuncT, T, T) |
Binary, elementwise, broadcasting operation: Apply<T>.
[ILNumerics Computing Engine] | |
applyTin1, Tin2, Tout(BaseArrayTin1, BaseArrayTin2, FuncTin1, Tin2, Tout) |
Binary, elementwise, broadcasting apply<T1,T2,Tout>(A,B). Maps a scalar operation from elements of A and B to a third array. Arbitrary types. Parallelized.
[ILNumerics Computing Engine] | |
applyTin1, Tin2, Tout(BaseArrayTin1, BaseArrayTin2, FuncTin1, Tin2, Int64, Tout) |
Binary, elementwise, broadcasting apply<T1,T2,long,Tout>(A,B). Maps a scalar operation from elements of
A and B to a third array, provides element index. Arbitrary types. Parallelized.
[ILNumerics Computing Engine] | |
arange(Double, Double) |
Creates vector of evenly spaced values over a closed interval, elements of Double.
[ILNumerics Computing Engine] | |
arange(Double, Double, Double) |
Creates vector of evenly spaced values over a closed interval, elements of Double.
[ILNumerics Computing Engine] | |
arangeT(T, T) |
Creates vector of evenly spaced values over a closed interval, elements of type T.
[ILNumerics Computing Engine] | |
arangeT, Ts(T, Ts, T) |
Creates vector of N evenly spaced values of given step size over a closed interval, numeric, real elements of type T.
[ILNumerics Computing Engine] | |
arrayT(T) |
Creates a vector from values. Column major storage.
[ILNumerics Computing Engine] | |
arrayT(T) |
Creates a vector from values. Column major storage.
[ILNumerics Computing Engine] | |
arrayT(T) |
Creates a vector from values. Column major storage.
[ILNumerics Computing Engine] | |
arrayT(T) | Obsolete.
Creates a vector from values. Column major storage.
[ILNumerics Computing Engine] | |
arrayT(T, Int32) | Obsolete.
Create new array, fill element with constant value
[ILNumerics Computing Engine] | |
arrayT(T, Size) | Obsolete.
Creates an array from values. Column major storage.
[ILNumerics Computing Engine] | |
arrayT(T, Int32) | Obsolete.
Creates an array from values and size. Column major storage.
[ILNumerics Computing Engine] | |
arrayT(Size, T) | Obsolete.
Creates an array from values and size. Column major storage.
[ILNumerics Computing Engine] | |
arrayT(T, InArrayInt64, StorageOrders) |
Creates new array of dimension lengths, with all elements having the same value val.
[ILNumerics Computing Engine] | |
arrayT(T, Size, StorageOrders) |
Create new array, fill elements with constant value
[ILNumerics Computing Engine] | |
arrayT(T, Int64, StorageOrders) |
Creates a new ILNumerics array, all elements initialized with the given value.
[ILNumerics Computing Engine] | |
arrayT(T, InArrayInt64, StorageOrders) |
Creates a new ILNumerics array from the values provided in values with the shape given by size.
[ILNumerics Computing Engine] | |
arrayT(InArrayInt64, IEnumerableT, StorageOrders) |
Creates an ILNumerics array from IEnumerableT.
[ILNumerics Computing Engine] | |
arrayT(T, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array, all elements initialized with the given value.
[ILNumerics Computing Engine] | |
arrayT(T, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array, all elements initialized with the given value.
[ILNumerics Computing Engine] | |
arrayT(T, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array, all elements initialized with the given value.
[ILNumerics Computing Engine] | |
arrayT(T, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array, all elements initialized with the given value.
[ILNumerics Computing Engine] | |
arrayT(T, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array, all elements initialized with the given value.
[ILNumerics Computing Engine] | |
arrayT(T, Int64, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array, all elements initialized with the given value.
[ILNumerics Computing Engine] | |
asin(BaseArraycomplex) |
Angles of cosine elements.
[ILNumerics Computing Engine] | |
asin(BaseArrayfcomplex) |
Angles of cosine elements.
[ILNumerics Computing Engine] | |
asin(BaseArrayDouble) |
Angles of cosine elements.
[ILNumerics Computing Engine] | |
asin(BaseArraySingle) |
Angles of cosine elements.
[ILNumerics Computing Engine] | |
asinc(BaseArrayDouble) |
Angles of cosine elements, complex output.
[ILNumerics Computing Engine] | |
asinc(BaseArraySingle) |
Angles of cosine elements, complex output.
[ILNumerics Computing Engine] | |
atan(BaseArraycomplex) |
Angles of tangent array elements.
[ILNumerics Computing Engine] | |
atan(BaseArrayfcomplex) |
Angles of tangent array elements.
[ILNumerics Computing Engine] | |
atan(BaseArrayDouble) |
Angles of tangent array elements.
[ILNumerics Computing Engine] | |
atan(BaseArraySingle) |
Angles of tangent array elements.
[ILNumerics Computing Engine] | |
atan2(BaseArrayDouble, BaseArrayDouble) |
Binary, elementwise, broadcasting operation: Atan2.
[ILNumerics Computing Engine] | |
atan2(BaseArraySingle, BaseArraySingle) |
Binary, elementwise, broadcasting operation: Atan2.
[ILNumerics Computing Engine] | |
besselJ0(InArrayDouble) |
Evaluates the Bessel function of the first kind, integer order 0 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the first kind.
[ILNumerics Computing Engine] | |
besselJ0(InArraySingle) |
Evaluates the Bessel function of the first kind, integer order 0 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the first kind.
[ILNumerics Computing Engine] | |
besselJ1(InArrayDouble) |
Evaluates the Bessel function of the first kind, integer order 1 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the first kind.
[ILNumerics Computing Engine] | |
besselJ1(InArraySingle) |
Evaluates the Bessel function of the first kind, integer order 1 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the first kind.
[ILNumerics Computing Engine] | |
besselJn(InArrayDouble, Int32) |
Evaluates the Bessel function of the first kind, integer order n-th of the argument.
For more details about this function, see Wikipedia - Bessel functions of the first kind.
[ILNumerics Computing Engine] | |
besselJn(InArraySingle, Int32) |
Evaluates the Bessel function of the first kind, integer order n-th of the argument.
For more details about this function, see Wikipedia - Bessel functions of the first kind.
[ILNumerics Computing Engine] | |
besselModifiedI0(InArrayDouble) |
Evaluates the modified Bessel function of the first kind, integer order 0 of the argument.
For more details about this function, see Wikipedia - Modified Bessel functions.
[ILNumerics Computing Engine] | |
besselModifiedI0(InArraySingle) |
Evaluates the modified Bessel function of the first kind, integer order 0 of the argument.
For more details about this function, see Wikipedia - Modified Bessel functions.
[ILNumerics Computing Engine] | |
besselModifiedI1(InArrayDouble) |
Evaluates the modified Bessel function of the first kind, integer order 1 of the argument.
For more details about this function, see Wikipedia - Modified Bessel functions.
[ILNumerics Computing Engine] | |
besselModifiedI1(InArraySingle) |
Evaluates the modified Bessel function of the first kind, integer order 1 of the argument.
For more details about this function, see Wikipedia - Modified Bessel functions.
[ILNumerics Computing Engine] | |
besselModifiedIn(InArrayDouble, Int32) |
Evaluates the modified Bessel function of the first kind, integer order n-th of the argument.
For more details about this function, see Wikipedia - Modified Bessel functions.
[ILNumerics Computing Engine] | |
besselModifiedIn(InArraySingle, Int32) |
Evaluates the modified Bessel function of the first kind, integer order n-th of the argument.
For more details about this function, see Wikipedia - Modified Bessel functions.
[ILNumerics Computing Engine] | |
besselModifiedK0(InArrayDouble) |
Evaluates the modified Bessel function of the second kind, integer order 0 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselModifiedK0(InArraySingle) |
Evaluates the modified Bessel function of the second kind, integer order 0 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselModifiedK1(InArrayDouble) |
Evaluates the modified Bessel function of the second kind, integer order 1 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselModifiedK1(InArraySingle) |
Evaluates the modified Bessel function of the second kind, integer order 1 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselModifiedKn(InArrayDouble, Int32) |
Evaluates the modified Bessel function of the second kind, integer order n-th of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselModifiedKn(InArraySingle, Int32) |
Evaluates the modified Bessel function of the second kind, integer order n-th of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselY0(InArrayDouble) |
Evaluates the Bessel function of the second kind, integer order 0 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselY0(InArraySingle) |
Evaluates the Bessel function of the second kind, integer order 0 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselY1(InArrayDouble) |
Evaluates the Bessel function of the second kind, integer order 1 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselY1(InArraySingle) |
Evaluates the Bessel function of the second kind, integer order 1 of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselYn(InArrayDouble, Int32) |
Evaluates the Bessel function of the second kind, integer order n-th of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
besselYn(InArraySingle, Int32) |
Evaluates the Bessel function of the second kind, integer order n-th of the argument.
For more details about this function, see Wikipedia - Bessel functions of the second kind.
[ILNumerics Computing Engine] | |
beta |
Evaluates the componentwise beta function at an array of points defined by w and z.
For more details about this function, see Wikipedia - Beta function.
[ILNumerics Computing Engine] | |
betaIncomplete |
Evaluates the incomplete Beta function at a given point.
For more details about this function, see Wikipedia - Incomplete beta function.
[ILNumerics Computing Engine] | |
binomialCoefficients |
Binomial coefficients of elements in n and k.
For more details about this function, see Wikipedia - Binomial coefficient.
[ILNumerics Computing Engine] | |
binomialCoefficientsLog |
Natural logarithm of binomial coefficients of elements in n and k.
For more details about this function, see Wikipedia - Binomial coefficient.
[ILNumerics Computing Engine] | |
bitand(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: BitAnd.
[ILNumerics Computing Engine] | |
bitand(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: BitAnd.
[ILNumerics Computing Engine] | |
bitand(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: BitAnd.
[ILNumerics Computing Engine] | |
bitand(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: BitAnd.
[ILNumerics Computing Engine] | |
bitand(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: BitAnd.
[ILNumerics Computing Engine] | |
bitand(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: BitAnd.
[ILNumerics Computing Engine] | |
bitand(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: BitAnd.
[ILNumerics Computing Engine] | |
bitand(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: BitAnd.
[ILNumerics Computing Engine] | |
bitneg(BaseArrayByte) |
Bitwise negation of array elements.
[ILNumerics Computing Engine] | |
bitneg(BaseArrayInt16) |
Bitwise negation of array elements.
[ILNumerics Computing Engine] | |
bitneg(BaseArrayInt32) |
Bitwise negation of array elements.
[ILNumerics Computing Engine] | |
bitneg(BaseArrayInt64) |
Bitwise negation of array elements.
[ILNumerics Computing Engine] | |
bitneg(BaseArraySByte) |
Bitwise negation of array elements.
[ILNumerics Computing Engine] | |
bitneg(BaseArrayUInt16) |
Bitwise negation of array elements.
[ILNumerics Computing Engine] | |
bitneg(BaseArrayUInt32) |
Bitwise negation of array elements.
[ILNumerics Computing Engine] | |
bitneg(BaseArrayUInt64) |
Bitwise negation of array elements.
[ILNumerics Computing Engine] | |
bitor(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: BitOr.
[ILNumerics Computing Engine] | |
bitor(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: BitOr.
[ILNumerics Computing Engine] | |
bitor(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: BitOr.
[ILNumerics Computing Engine] | |
bitor(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: BitOr.
[ILNumerics Computing Engine] | |
bitor(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: BitOr.
[ILNumerics Computing Engine] | |
bitor(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: BitOr.
[ILNumerics Computing Engine] | |
bitor(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: BitOr.
[ILNumerics Computing Engine] | |
bitor(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: BitOr.
[ILNumerics Computing Engine] | |
bitxor(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: BitXor.
[ILNumerics Computing Engine] | |
bitxor(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: BitXor.
[ILNumerics Computing Engine] | |
bitxor(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: BitXor.
[ILNumerics Computing Engine] | |
bitxor(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: BitXor.
[ILNumerics Computing Engine] | |
bitxor(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: BitXor.
[ILNumerics Computing Engine] | |
bitxor(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: BitXor.
[ILNumerics Computing Engine] | |
bitxor(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: BitXor.
[ILNumerics Computing Engine] | |
bitxor(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: BitXor.
[ILNumerics Computing Engine] | |
cart2pol(InArrayDouble, InArrayDouble, InArrayDouble, OutArrayDouble, OutArrayDouble) |
Transform scalar coordinates into polar (cylindrical) coordinates
[ILNumerics Computing Engine] | |
cart2pol(InArraySingle, InArraySingle, InArraySingle, OutArraySingle, OutArraySingle) |
Transforms scalar coordinates into polar (cylindrical) coordinates.
[ILNumerics Computing Engine] | |
cart2sphere(InArrayDouble, InArrayDouble, InArrayDouble, OutArrayDouble, OutArrayDouble) |
Transforms cartesian coordinates into spherical coordinates.
[ILNumerics Computing Engine] | |
cart2sphere(InArraySingle, InArraySingle, InArraySingle, OutArraySingle, OutArraySingle) |
Transforms cartesian coordinates into spherical coordinates.
[ILNumerics Computing Engine] | |
ccomplex(BaseArrayDouble, BaseArrayDouble) |
Binary, elementwise, broadcasting operation: CComplex.
[ILNumerics Computing Engine] | |
ccomplex(BaseArraySingle, BaseArraySingle) |
Binary, elementwise, broadcasting operation: CComplex.
[ILNumerics Computing Engine] | |
ceil(BaseArraycomplex) |
Computes the smallest integer greater than or equal to elements in A [ILNumerics Computing Engine] | |
ceil(BaseArrayfcomplex) |
Computes the smallest integer greater than or equal to elements in A [ILNumerics Computing Engine] | |
ceil(BaseArrayDouble) |
Computes the smallest integer greater than or equal to elements in A [ILNumerics Computing Engine] | |
ceil(BaseArraySingle) |
Computes the smallest integer greater than or equal to elements in A [ILNumerics Computing Engine] | |
cell(BaseArray, Int32) | Obsolete.
Create cell, initialize with arrays and size.
[ILNumerics Computing Engine] | |
cell(InArrayInt64, IEnumerableBaseArray, StorageOrders) |
Creates new cell, initialize size and provide arrays for cell elements.
[ILNumerics Computing Engine] | |
cellv |
Create a cell vector from provided arrays.
[ILNumerics Computing Engine] | |
check(InCell, FuncInCell, RetCell, Boolean, String) |
Check if A is a valid parameter.
[ILNumerics Computing Engine] | |
check(InLogical, FuncInLogical, RetLogical, Boolean, String) |
Checks if A is a valid parameter.
[ILNumerics Computing Engine] | |
checkT(InArrayT, FuncInArrayT, RetArrayT, Boolean, String, InArrayT) |
Checks if A is a valid parameter.
[ILNumerics Computing Engine] | |
checknullT |
Checks if A is valid, assign default if null.
[ILNumerics Computing Engine] | |
chol(InArraycomplex, Boolean) |
Cholesky factorization of a symmetric, positive definite matrix.
[ILNumerics Computing Engine] | |
chol(InArrayfcomplex, Boolean) |
Cholesky factorization of a symmetric, positive definite matrix.
[ILNumerics Computing Engine] | |
chol(InArrayDouble, Boolean) |
Cholesky factorization of a symmetric, positive definite matrix.
[ILNumerics Computing Engine] | |
chol(InArraySingle, Boolean) |
Cholesky factorization of a symmetric, positive definite matrix.
[ILNumerics Computing Engine] | |
columnT | Obsolete.
Creates a column vector. This function is deprecated. Use vector``1(UMP) instead.
[ILNumerics Computing Engine] | |
concatT, LocalT, InT, OutT, RetT, StorageT |
Create new array with the elements of A and B concatenated along dimension dim.
[ILNumerics Computing Engine] | |
conj(BaseArraycomplex) |
Creates the complex conjugate of array elements.
[ILNumerics Computing Engine] | |
conj(BaseArrayfcomplex) |
Creates the complex conjugate of array elements.
[ILNumerics Computing Engine] | |
conjInplace(Mutablecomplex, Arraycomplex, InArraycomplex, OutArraycomplex, RetArraycomplex, Storagecomplex) |
Conjugates complex elements inplace.
[ILNumerics Computing Engine] | |
conjInplace(Mutablefcomplex, Arrayfcomplex, InArrayfcomplex, OutArrayfcomplex, RetArrayfcomplex, Storagefcomplex) |
Conjugates fcomplex elements inplace.
[ILNumerics Computing Engine] | |
convertoutT(BaseArray) |
Converts numeric array of unknown type to a specific array type.
[ILNumerics Computing Engine] | |
convertinT, outT(BaseArrayinT) |
Convert typed source array A into array of element type outT.
[ILNumerics Computing Engine] | |
copyUpperTriangleT |
Copy upper triangle from PHYSICAL array A
[ILNumerics Computing Engine] | |
cos(BaseArraycomplex) |
Cosines of array elements.
[ILNumerics Computing Engine] | |
cos(BaseArrayfcomplex) |
Cosines of array elements.
[ILNumerics Computing Engine] | |
cos(BaseArrayDouble) |
Cosines of array elements.
[ILNumerics Computing Engine] | |
cos(BaseArraySingle) |
Cosines of array elements.
[ILNumerics Computing Engine] | |
cosh(BaseArraycomplex) |
Hyperbolic cosines of array elements.
[ILNumerics Computing Engine] | |
cosh(BaseArrayfcomplex) |
Hyperbolic cosines of array elements.
[ILNumerics Computing Engine] | |
cosh(BaseArrayDouble) |
Hyperbolic cosines of array elements.
[ILNumerics Computing Engine] | |
cosh(BaseArraySingle) |
Hyperbolic cosines of array elements.
[ILNumerics Computing Engine] | |
counter(Int32) | Obsolete.
Create an array with regularly (stepsize 1) spaced elements in multiple dimensions of provided lenghts.
[ILNumerics Computing Engine] | |
counter(Double, Double, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values in double precision.
[ILNumerics Computing Engine] | |
counter(Double, Double, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values, double precision.
[ILNumerics Computing Engine] | |
counter(Double, Double, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values, double precision.
[ILNumerics Computing Engine] | |
counter(Double, Double, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values, double precision.
[ILNumerics Computing Engine] | |
counter(Double, Double, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values, double precision.
[ILNumerics Computing Engine] | |
counter(Double, Double, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values, double precision.
[ILNumerics Computing Engine] | |
counter(Double, Double, Int64, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values, double precision.
[ILNumerics Computing Engine] | |
counterT(T, T, InArrayInt64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values.
[ILNumerics Computing Engine] | |
counterT(T, T, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values.
[ILNumerics Computing Engine] | |
counterT(T, T, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values.
[ILNumerics Computing Engine] | |
counterT(T, T, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values.
[ILNumerics Computing Engine] | |
counterT(T, T, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values.
[ILNumerics Computing Engine] | |
counterT(T, T, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values.
[ILNumerics Computing Engine] | |
counterT(T, T, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values.
[ILNumerics Computing Engine] | |
counterT(T, T, Int64, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array with regularly spaced element values.
[ILNumerics Computing Engine] | |
cross(InArrayDouble, InArrayDouble, Boolean, NullableUInt32) |
Computes the cross product along a dimension of two arrays.
[ILNumerics Computing Engine] | |
cross(InArraySingle, InArraySingle, Boolean, NullableUInt32) |
Computes the cross product along a dimension of two arrays.
[ILNumerics Computing Engine] | |
csvreadT(String, Int32, Int32, NullableInt32, NullableInt32, FuncString, T, String, CultureInfo) |
Reads comma separated values from lines in a string, optionally using custom separators, element and number formats.
[ILNumerics Computing Engine] | |
csvreadT(Stream, Int32, Int32, NullableInt32, NullableInt32, FuncString, T, String, CultureInfo, Encoding, Boolean) |
Reads comma separated values from stream, optionally using custom separators, element and number formats.
[ILNumerics Computing Engine] | |
csvwriteT(InArrayT, String, FuncT, String, String, CultureInfo, Encoding) |
Write ILNumerics array as separated strings to file
[ILNumerics Computing Engine] | |
csvwriteT(InArrayT, Stream, FuncT, String, String, CultureInfo, Encoding, Boolean) |
Write ILNumerics array as separated strings to stream
[ILNumerics Computing Engine] | |
cumprod(BaseArraycomplex, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArrayfcomplex, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArrayByte, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArrayDouble, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArrayInt16, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArrayInt32, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArrayInt64, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArraySByte, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArraySingle, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArrayUInt16, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArrayUInt32, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumprod(BaseArrayUInt64, Int32) |
Computes the product of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArraycomplex, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArrayfcomplex, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArrayByte, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArrayDouble, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArrayInt16, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArrayInt32, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArrayInt64, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArraySByte, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArraySingle, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArrayUInt16, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArrayUInt32, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
cumsum(BaseArrayUInt64, Int32) |
Compute the sum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
det(InArraycomplex) |
Determinant of square matrix.
[ILNumerics Computing Engine] | |
det(InArrayfcomplex) |
Determinant of square matrix.
[ILNumerics Computing Engine] | |
det(InArrayDouble) |
Determinant of square matrix.
[ILNumerics Computing Engine] | |
det(InArraySingle) |
Determinant of square matrix.
[ILNumerics Computing Engine] | |
diagT |
Diagonal matrix or diagonal from matrix.
[ILNumerics Computing Engine] | |
diff(BaseArraycomplex, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArrayfcomplex, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArrayByte, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArrayDouble, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArrayInt16, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArrayInt32, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArrayInt64, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArraySByte, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArraySingle, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArrayUInt16, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArrayUInt32, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diff(BaseArrayUInt64, UInt32, Int32) |
Computes the differences between successive elements of A along the specified dimension dim or the n-th derivative.
[ILNumerics Computing Engine] | |
diGamma |
Computes the Digamma function which is mathematically defined as the derivative of the logarithm of the gamma function.
For more details about this function, see Wikipedia - Digamma function
and Wolfram MathWorld - Digamma function.
[ILNumerics Computing Engine] | |
distL1(InArraycomplex, InArraycomplex) |
Pairwise L1 distance. Aka: Manhattan distance.
[ILNumerics Computing Engine] | |
distL1(InArrayfcomplex, InArrayfcomplex) |
Pairwise L1 distance. Aka: Manhattan distance.
[ILNumerics Computing Engine] | |
distL1(InArrayDouble, InArrayDouble) |
Pairwise L1 distance. Aka: Manhattan distance.
[ILNumerics Computing Engine] | |
distL1(InArrayInt32, InArrayInt32) |
Pairwise L1 distance. Aka: Manhattan distance.
[ILNumerics Computing Engine] | |
distL1(InArrayInt64, InArrayInt64) |
Pairwise L1 distance. Aka: Manhattan distance.
[ILNumerics Computing Engine] | |
distL1(InArraySingle, InArraySingle) |
Pairwise L1 distance. Aka: Manhattan distance.
[ILNumerics Computing Engine] | |
distL2sq(InArrayDouble, InArrayDouble) |
Computes the [m x n] squared pairwise L2 distances between data points provided in A [d x m] and B [d x n].
[ILNumerics Computing Engine] | |
distL2sq(InArraySingle, InArraySingle) |
Computes the [m x n] squared pairwise L2 distances between data points provided in A [d x m] and B [d x n].
[ILNumerics Computing Engine] | |
divide(BaseArraycomplex, BaseArraycomplex) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArrayfcomplex, BaseArrayfcomplex) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArrayDouble, BaseArrayDouble) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArraySingle, BaseArraySingle) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide_sat(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide_sat(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide_sat(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide_sat(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide_sat(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide_sat(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide_sat(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
divide_sat(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: Divide.
[ILNumerics Computing Engine] | |
eig(InArraycomplex) |
Computes eigenvalues of general square matrix A.
[ILNumerics Computing Engine] | |
eig(InArrayfcomplex) |
Computes eigenvalues of general square matrix A.
[ILNumerics Computing Engine] | |
eig(InArrayDouble) |
Computes eigenvalues of general square matrix A.
[ILNumerics Computing Engine] | |
eig(InArraySingle) |
Computes eigenvalues of general square matrix A.
[ILNumerics Computing Engine] | |
eig(InArraycomplex, OutArraycomplex) |
Computes eigenvalues and eigenvectors of general square matrix A.
[ILNumerics Computing Engine] | |
eig(InArrayfcomplex, OutArrayfcomplex) |
Computes eigenvalues and eigenvectors of general square matrix A.
[ILNumerics Computing Engine] | |
eig(InArrayDouble, OutArraycomplex) |
Computes eigenvalues and eigenvectors of general square matrix A.
[ILNumerics Computing Engine] | |
eig(InArraySingle, OutArrayfcomplex) |
Computes eigenvalues and eigenvectors of general square matrix A.
[ILNumerics Computing Engine] | |
eig(InArraycomplex, OutArraycomplex, MatrixProperties, Boolean) |
Find eigenvalues and eigenvectors of square matrix A.
[ILNumerics Computing Engine] | |
eig(InArrayfcomplex, OutArrayfcomplex, MatrixProperties, Boolean) |
Find eigenvalues and eigenvectors of square matrix A.
[ILNumerics Computing Engine] | |
eig(InArrayDouble, OutArraycomplex, MatrixProperties, Boolean) |
Find eigenvalues and eigenvectors of square matrix A.
[ILNumerics Computing Engine] | |
eig(InArraySingle, OutArrayfcomplex, MatrixProperties, Boolean) |
Find eigenvalues and eigenvectors of square matrix A.
[ILNumerics Computing Engine] | |
eigGen(InArraycomplex, InArraycomplex, OutArraycomplex, GenEigenType, Boolean) |
Computes eigenvalues and eigenvectors (optional) of symmetric/hermitian inputs A and B: A*V=lamda*B*V.
[ILNumerics Computing Engine] | |
eigGen(InArrayfcomplex, InArrayfcomplex, OutArrayfcomplex, GenEigenType, Boolean) |
Computes eigenvalues and eigenvectors (optional) of symmetric/hermitian inputs A and B: A*V=lamda*B*V.
[ILNumerics Computing Engine] | |
eigGen(InArrayDouble, InArrayDouble, OutArrayDouble, GenEigenType, Boolean) |
Computes eigenvalues and eigenvectors (optional) of symmetric/hermitian inputs A and B: A*V=lamda*B*V.
[ILNumerics Computing Engine] | |
eigGen(InArraySingle, InArraySingle, OutArraySingle, GenEigenType, Boolean) |
Computes eigenvalues and eigenvectors (optional) of symmetric/hermitian inputs A and B: A*V=lamda*B*V.
[ILNumerics Computing Engine] | |
eigSymm(InArraycomplex) |
Find all eigenvalues of symmetric / hermitian matrix.
[ILNumerics Computing Engine] | |
eigSymm(InArrayfcomplex) |
Find all eigenvalues of symmetric / hermitian matrix.
[ILNumerics Computing Engine] | |
eigSymm(InArrayDouble) |
Find all eigenvalues of symmetric / hermitian matrix.
[ILNumerics Computing Engine] | |
eigSymm(InArraySingle) |
Find all eigenvalues of symmetric / hermitian matrix.
[ILNumerics Computing Engine] | |
eigSymm(InArraycomplex, OutArraycomplex) |
Find all eigenvalues and -vectors of a symmetric /hermitian matrix.
[ILNumerics Computing Engine] | |
eigSymm(InArrayfcomplex, OutArrayfcomplex) |
Find all eigenvalues and -vectors of a symmetric /hermitian matrix.
[ILNumerics Computing Engine] | |
eigSymm(InArrayDouble, OutArrayDouble) |
Find all eigenvalues and -vectors of a symmetric /hermitian matrix.
[ILNumerics Computing Engine] | |
eigSymm(InArraySingle, OutArraySingle) |
Find all eigenvalues and -vectors of a symmetric /hermitian matrix.
[ILNumerics Computing Engine] | |
eigSymm(InArraycomplex, OutArraycomplex, Double, Double) |
Find some eigenvalues and -vectors of symmetric (hermitian) matrix. Filter by value of eigenvalues.
[ILNumerics Computing Engine] | |
eigSymm(InArraycomplex, OutArraycomplex, Int32, Int32) |
Find some eigenvalues and -vectors of symmetric (hermitian) matrix. Filter by (1 based) index of eigenvalues.
[ILNumerics Computing Engine] | |
eigSymm(InArrayfcomplex, OutArrayfcomplex, Int32, Int32) |
Find some eigenvalues and -vectors of symmetric (hermitian) matrix. Filter by (1 based) index of eigenvalues.
[ILNumerics Computing Engine] | |
eigSymm(InArrayfcomplex, OutArrayfcomplex, Single, Single) |
Find some eigenvalues and -vectors of symmetric (hermitian) matrix. Filter by value of eigenvalues.
[ILNumerics Computing Engine] | |
eigSymm(InArrayDouble, OutArrayDouble, Double, Double) |
Find some eigenvalues and -vectors of symmetric (hermitian) matrix. Filter by value of eigenvalues.
[ILNumerics Computing Engine] | |
eigSymm(InArrayDouble, OutArrayDouble, Int32, Int32) |
Find some eigenvalues and -vectors of symmetric (hermitian) matrix. Filter by (1 based) index of eigenvalues.
[ILNumerics Computing Engine] | |
eigSymm(InArraySingle, OutArraySingle, Int32, Int32) |
Find some eigenvalues and -vectors of symmetric (hermitian) matrix. Filter by (1 based) index of eigenvalues.
[ILNumerics Computing Engine] | |
eigSymm(InArraySingle, OutArraySingle, Single, Single) |
Find some eigenvalues and -vectors of symmetric (hermitian) matrix. Filter by value of eigenvalues.
[ILNumerics Computing Engine] | |
empty | Obsolete.
Create empty array with 0 elements of type T.
[ILNumerics Computing Engine] | |
empty(Int32) | Obsolete.
Create array with a size determined by dims and uninitialized elements of type Double.
[ILNumerics Computing Engine] | |
emptyT |
Create empty array with 0 elements of type T.
[ILNumerics Computing Engine] | |
emptyT(Int64) |
Creates a new array of uninitialized values with a size determined by size.
[ILNumerics Computing Engine] | |
emptyT(Int64, StorageOrders) |
Create 1D array of arbitrary size without clearing the elements.
[ILNumerics Computing Engine] | |
emptyT(InArrayInt64, StorageOrders) |
Create 1D array of arbitrary size without clearing the elements.
[ILNumerics Computing Engine] | |
emptyT(Size, StorageOrders) |
Create an empty array of the same size (shape) as another array without clearing the elements.
[ILNumerics Computing Engine] | |
emptyT(Int64, Int64, StorageOrders) |
Create 1D array of arbitrary size without clearing the elements.
[ILNumerics Computing Engine] | |
emptyT(Int64, Int64, Int64, StorageOrders) |
Create 1D array of arbitrary size without clearing the elements.
[ILNumerics Computing Engine] | |
emptyT(Int64, Int64, Int64, Int64, StorageOrders) |
Create 1D array of arbitrary size without clearing the elements.
[ILNumerics Computing Engine] | |
emptyT(Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Create 1D array of arbitrary size without clearing the elements.
[ILNumerics Computing Engine] | |
emptyT(Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Create 1D array of arbitrary size without clearing the elements.
[ILNumerics Computing Engine] | |
emptyT(Int64, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Create 1D array of arbitrary size without clearing the elements.
[ILNumerics Computing Engine] | |
eq(BaseArraycomplex, BaseArraycomplex) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayfcomplex, BaseArrayfcomplex) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayBoolean, BaseArrayBoolean) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayByte, BaseArrayByte) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayDouble, BaseArrayDouble) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayInt16, BaseArrayInt16) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayInt32, BaseArrayInt32) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayInt64, BaseArrayInt64) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArraySByte, BaseArraySByte) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArraySingle, BaseArraySingle) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayUInt16, BaseArrayUInt16) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayUInt32, BaseArrayUInt32) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eq(BaseArrayUInt64, BaseArrayUInt64) |
Elementwise 'EqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
eqnan(BaseArraycomplex, BaseArraycomplex) |
Elementwise 'Equal' comparison operator on two arrays. Compares NaN and Inf like regular values.
[ILNumerics Computing Engine] | |
eqnan(BaseArrayfcomplex, BaseArrayfcomplex) |
Elementwise 'Equal' comparison operator on two arrays. Compares NaN and Inf like regular values.
[ILNumerics Computing Engine] | |
eqnan(BaseArrayDouble, BaseArrayDouble) |
Elementwise 'Equal' comparison operator on two arrays. Compares NaN and Inf like regular values.
[ILNumerics Computing Engine] | |
eqnan(BaseArraySingle, BaseArraySingle) |
Elementwise 'Equal' comparison operator on two arrays. Compares NaN and Inf like regular values.
[ILNumerics Computing Engine] | |
errorFunction |
Evaluates the (Gauss) error function.
For more details about this function, see Wikipedia - Error function.
[ILNumerics Computing Engine] | |
errorFunctionComplement |
Evaluates of the complementary (Gauss) error function.
For more details about this function, see Wikipedia - Complementary Error function.
[ILNumerics Computing Engine] | |
errorFunctionInverse |
Evaluates the inverse of the (Gauss) error function.
For more details about this function, see Wikipedia - Inverse Error function.
[ILNumerics Computing Engine] | |
exp(BaseArraycomplex) |
Raise power of e.
[ILNumerics Computing Engine] | |
exp(BaseArrayfcomplex) |
Raise power of e.
[ILNumerics Computing Engine] | |
exp(BaseArrayDouble) |
Raise power of e.
[ILNumerics Computing Engine] | |
exp(BaseArraySingle) |
Raise power of e.
[ILNumerics Computing Engine] | |
eye(Int32, Int32) |
Creates a new matrix with element type Double having diagonal values of 1.0.
[ILNumerics Computing Engine] | |
eye(Int64, Int64) |
Creates a new matrix with element type Double having diagonal values of 1.0.
[ILNumerics Computing Engine] | |
eyeT(Int32, Int32) |
Create unity matrix, arbitrary numeric type.
[ILNumerics Computing Engine] | |
eyeT(Int64, Int64) |
Create unity matrix, arbitrary numeric type.
[ILNumerics Computing Engine] | |
eyeT(T, Int32, Int32, StorageOrders) |
Creates a diagonal matrix, arbitrary value type, diagonal value and storage order.
[ILNumerics Computing Engine] | |
eyeT(T, Int64, Int64, StorageOrders) |
Creates a diagonal matrix, arbitrary value type, diagonal value and storage order.
[ILNumerics Computing Engine] | |
factorial |
Factorial, from an array of integer elements.
For more details about this function, see Wikipedia - Factorial.
[ILNumerics Computing Engine] | |
factorialLog |
Natural logarithm of factorial, from an array of integer elements.
[ILNumerics Computing Engine] | |
fft(InArraycomplex, NullableUInt32) |
Fast fourier transform along a specific dimension.
[ILNumerics Computing Engine] | |
fft(InArrayfcomplex, NullableUInt32) |
Fast fourier transform along a specific dimension.
[ILNumerics Computing Engine] | |
fft(InArrayDouble, NullableUInt32) |
Fast fourier transform along a specific dimension.
[ILNumerics Computing Engine] | |
fft(InArraySingle, NullableUInt32) |
Fast fourier transform along a specific dimension.
[ILNumerics Computing Engine] | |
fft2(InArraycomplex) |
Fast 2D discrete fourier transform.
[ILNumerics Computing Engine] | |
fft2(InArrayfcomplex) |
Fast 2D discrete fourier transform.
[ILNumerics Computing Engine] | |
fft2(InArrayDouble) |
Fast 2D discrete fourier transform.
[ILNumerics Computing Engine] | |
fft2(InArraySingle) |
Fast 2D discrete fourier transform.
[ILNumerics Computing Engine] | |
fft2(InArraycomplex, UInt32, UInt32) |
Fast fourier transform (2D)
[ILNumerics Computing Engine] | |
fft2(InArrayfcomplex, UInt32, UInt32) |
Fast fourier transform (2D)
[ILNumerics Computing Engine] | |
fft2(InArrayDouble, UInt32, UInt32) |
Fast fourier transform (2D)
[ILNumerics Computing Engine] | |
fft2(InArraySingle, UInt32, UInt32) |
Fast fourier transform (2D)
[ILNumerics Computing Engine] | |
fftn(InArraycomplex) |
Fast fourier transform (n-D)
[ILNumerics Computing Engine] | |
fftn(InArrayfcomplex) |
Fast fourier transform (n-D)
[ILNumerics Computing Engine] | |
fftn(InArrayDouble) |
Fast fourier transform (n-D)
[ILNumerics Computing Engine] | |
fftn(InArraySingle) |
Fast fourier transform (n-D)
[ILNumerics Computing Engine] | |
fftn(InArraycomplex, InArrayInt64) |
Fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
fftn(InArraycomplex, UInt32) | Obsolete.
Fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
fftn(InArrayfcomplex, InArrayInt64) |
Fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
fftn(InArrayfcomplex, UInt32) | Obsolete.
Fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
fftn(InArrayDouble, InArrayInt64) |
Fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
fftn(InArrayDouble, UInt32) | Obsolete.
Fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
fftn(InArraySingle, InArrayInt64) |
Fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
fftn(InArraySingle, UInt32) | Obsolete.
Fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
find(BaseArraycomplex) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayfcomplex) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayBoolean) |
Find true elements in n-d array and give their sequential index (column major order).
[ILNumerics Computing Engine] | |
find(BaseArrayByte) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayDouble) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayInt16) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayInt32) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayInt64) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArraySByte) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArraySingle) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayUInt16) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayUInt32) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayUInt64) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayBoolean, Int64, Boolean, OutArrayInt64) |
Find sequential indices of true elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArraycomplex, Int64, Boolean, OutArrayInt64, OutArraycomplex) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayfcomplex, Int64, Boolean, OutArrayInt64, OutArrayfcomplex) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayByte, Int64, Boolean, OutArrayInt64, OutArrayByte) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayDouble, Int64, Boolean, OutArrayInt64, OutArrayDouble) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayInt16, Int64, Boolean, OutArrayInt64, OutArrayInt16) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayInt32, Int64, Boolean, OutArrayInt64, OutArrayInt32) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayInt64, Int64, Boolean, OutArrayInt64, OutArrayInt64) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArraySByte, Int64, Boolean, OutArrayInt64, OutArraySByte) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArraySingle, Int64, Boolean, OutArrayInt64, OutArraySingle) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayUInt16, Int64, Boolean, OutArrayInt64, OutArrayUInt16) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayUInt32, Int64, Boolean, OutArrayInt64, OutArrayUInt32) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find(BaseArrayUInt64, Int64, Boolean, OutArrayInt64, OutArrayUInt64) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArraycomplex) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayfcomplex) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayBoolean) |
Find true elements in n-d array and give their sequential index (column major order). Assumes <paramref name="A"/>.S.NumberOfElements < uint.MaxValue.
[ILNumerics Computing Engine] | |
find32(BaseArrayByte) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayDouble) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayInt16) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayInt32) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayInt64) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArraySByte) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArraySingle) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayUInt16) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayUInt32) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayUInt64) |
Finds sequential indices of non-zero elements in n-d array, search from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayBoolean, Int64, Boolean, OutArrayInt32) |
Find sequential indices of true elements in n-d array, searches from start to end in column major order. Assumes <paramref name="A"/>.S.NumberOfElements < uint.MaxValue.
[ILNumerics Computing Engine] | |
find32(BaseArraycomplex, Int32, Boolean, OutArrayInt32, OutArraycomplex) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayfcomplex, Int32, Boolean, OutArrayInt32, OutArrayfcomplex) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayByte, Int32, Boolean, OutArrayInt32, OutArrayByte) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayDouble, Int32, Boolean, OutArrayInt32, OutArrayDouble) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayInt16, Int32, Boolean, OutArrayInt32, OutArrayInt16) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayInt32, Int32, Boolean, OutArrayInt32, OutArrayInt32) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayInt64, Int32, Boolean, OutArrayInt32, OutArrayInt64) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArraySByte, Int32, Boolean, OutArrayInt32, OutArraySByte) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArraySingle, Int32, Boolean, OutArrayInt32, OutArraySingle) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayUInt16, Int32, Boolean, OutArrayInt32, OutArrayUInt16) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayUInt32, Int32, Boolean, OutArrayInt32, OutArrayUInt32) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
find32(BaseArrayUInt64, Int32, Boolean, OutArrayInt32, OutArrayUInt64) |
Find sequential indices of non-zero elements in n-d array, searches from start to end in column major order.
[ILNumerics Computing Engine] | |
fix(BaseArraycomplex) |
Round elements towards zero.
[ILNumerics Computing Engine] | |
fix(BaseArrayfcomplex) |
Round elements towards zero.
[ILNumerics Computing Engine] | |
fix(BaseArrayDouble) |
Round elements towards zero.
[ILNumerics Computing Engine] | |
fix(BaseArraySingle) |
Round elements towards zero.
[ILNumerics Computing Engine] | |
flip(BaseArraycomplex, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayfcomplex, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayBoolean, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayByte, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayDouble, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayInt16, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayInt32, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayInt64, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArraySByte, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArraySingle, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayUInt16, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayUInt32, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
flip(BaseArrayUInt64, Int32) |
Flips elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
fliplr(BaseArraycomplex) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayfcomplex) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayBoolean) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayByte) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayDouble) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayInt16) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayInt32) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayInt64) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArraySByte) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArraySingle) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayUInt16) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayUInt32) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
fliplr(BaseArrayUInt64) |
Flips the order of the columns of matrix A, i.e.: works along dimension #1.
[ILNumerics Computing Engine] | |
flipud(BaseArraycomplex) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayfcomplex) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayBoolean) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayByte) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayDouble) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayInt16) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayInt32) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayInt64) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArraySByte) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArraySingle) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayUInt16) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayUInt32) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
flipud(BaseArrayUInt64) |
Flips the order of the rows of matrix A, i.e.: works along dimension #0.
[ILNumerics Computing Engine] | |
floor(BaseArraycomplex) |
Round elements towards negative infinity.
[ILNumerics Computing Engine] | |
floor(BaseArrayfcomplex) |
Round elements towards negative infinity.
[ILNumerics Computing Engine] | |
floor(BaseArrayDouble) |
Round elements towards negative infinity.
[ILNumerics Computing Engine] | |
floor(BaseArraySingle) |
Round elements towards negative infinity.
[ILNumerics Computing Engine] | |
freeT |
Frees the handle for a memory region after use. This is for expert users in rare low-level scenarios only. Use the common array creation functions instead!
[ILNumerics Computing Engine] | |
gamma |
Evaluates the Gamma function at a given point.
For more details about this function, see Wikipedia - Gamma function.
[ILNumerics Computing Engine] | |
gammaIncomplete |
Evaluates the lower incomplete Gamma function at a given point.
For more details about this function, see Wikipedia - Incomplete gamma function.
[ILNumerics Computing Engine] | |
gammaLog |
Evaluates the natural logarithm of the Gamma function at a given point.
For more details about this function, see Wikipedia - Gamma function
and Wolfram MathWorld - Log Gamma function.
[ILNumerics Computing Engine] | |
ge(BaseArraycomplex, BaseArraycomplex) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArrayfcomplex, BaseArrayfcomplex) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArrayByte, BaseArrayByte) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArrayDouble, BaseArrayDouble) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArrayInt16, BaseArrayInt16) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArrayInt32, BaseArrayInt32) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArrayInt64, BaseArrayInt64) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArraySByte, BaseArraySByte) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArraySingle, BaseArraySingle) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArrayUInt16, BaseArrayUInt16) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArrayUInt32, BaseArrayUInt32) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
ge(BaseArrayUInt64, BaseArrayUInt64) |
Elementwise 'GreaterOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArraycomplex, BaseArraycomplex) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArrayfcomplex, BaseArrayfcomplex) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArrayByte, BaseArrayByte) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArrayDouble, BaseArrayDouble) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArrayInt16, BaseArrayInt16) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArrayInt32, BaseArrayInt32) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArrayInt64, BaseArrayInt64) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArraySByte, BaseArraySByte) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArraySingle, BaseArraySingle) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArrayUInt16, BaseArrayUInt16) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArrayUInt32, BaseArrayUInt32) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
gt(BaseArrayUInt64, BaseArrayUInt64) |
Elementwise 'GreaterThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
horzcatT, LocalT, InT, OutT, RetT, StorageT(ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT, ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT) |
Create new array with the rows of A extended by the rows of B.
[ILNumerics Computing Engine] | |
horzcatT, LocalT, InT, OutT, RetT, StorageT(ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT, ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT, ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT) |
Create new array with the rows of A extended by the rows of B and C.
[ILNumerics Computing Engine] | |
horzcatT, LocalT, InT, OutT, RetT, StorageT(ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT, ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT, ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT, ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT) |
Create new array with the rows of A extended by the rows of B and C and D.
[ILNumerics Computing Engine] | |
ifft(InArraycomplex, NullableUInt32) |
Inverse fast fourier transform along a specific dimension.
[ILNumerics Computing Engine] | |
ifft(InArrayfcomplex, NullableUInt32) |
Inverse fast fourier transform along a specific dimension.
[ILNumerics Computing Engine] | |
ifft2(InArraycomplex) |
Inverse fast 2D discrete fourier transform.
[ILNumerics Computing Engine] | |
ifft2(InArrayfcomplex) |
Inverse fast 2D discrete fourier transform.
[ILNumerics Computing Engine] | |
ifft2(InArraycomplex, UInt32, UInt32) |
Inverse fast fourier transform (2D)
[ILNumerics Computing Engine] | |
ifft2(InArrayfcomplex, UInt32, UInt32) |
Inverse fast fourier transform (2D)
[ILNumerics Computing Engine] | |
ifft2sym(InArraycomplex) |
Inverse, 2D, discrete fast fourier transform (hermitian input).
[ILNumerics Computing Engine] | |
ifft2sym(InArrayfcomplex) |
Inverse, 2D, discrete fast fourier transform (hermitian input).
[ILNumerics Computing Engine] | |
ifft2sym(InArraycomplex, UInt32, UInt32) |
Inverse fast fourier transform (2D)
[ILNumerics Computing Engine] | |
ifft2sym(InArrayfcomplex, UInt32, UInt32) |
Inverse fast fourier transform (2D)
[ILNumerics Computing Engine] | |
ifftn(InArraycomplex) |
Inverse fast fourier transform (n-D)
[ILNumerics Computing Engine] | |
ifftn(InArrayfcomplex) |
Inverse fast fourier transform (n-D)
[ILNumerics Computing Engine] | |
ifftn(InArraycomplex, InArrayInt64) |
Inverse fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
ifftn(InArraycomplex, UInt32) | Obsolete.
Inverse fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
ifftn(InArrayfcomplex, InArrayInt64) |
Inverse fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
ifftn(InArrayfcomplex, UInt32) | Obsolete.
Inverse fast fourier transform (n-D, specific size)
[ILNumerics Computing Engine] | |
ifftnsym(InArraycomplex) |
Inverse fast fourier transform (n-D)
[ILNumerics Computing Engine] | |
ifftnsym(InArrayfcomplex) |
Inverse fast fourier transform (n-D)
[ILNumerics Computing Engine] | |
ifftnsym(InArraycomplex, InArrayInt64) |
Inverse fast fourier transform (n-D, complex hermitian, specific size)
[ILNumerics Computing Engine] | |
ifftnsym(InArraycomplex, UInt32) | Obsolete.
Inverse fast fourier transform (n-D, complex hermitian, specific size)
[ILNumerics Computing Engine] | |
ifftnsym(InArrayfcomplex, InArrayInt64) |
Inverse fast fourier transform (n-D, fcomplex hermitian, specific size)
[ILNumerics Computing Engine] | |
ifftnsym(InArrayfcomplex, UInt32) | Obsolete.
Inverse fast fourier transform (n-D, fcomplex hermitian, specific size)
[ILNumerics Computing Engine] | |
ifftsym(InArraycomplex, NullableUInt32) |
Inverse fast fourier transform from complex hermitian input to real data.
[ILNumerics Computing Engine] | |
ifftsym(InArrayfcomplex, NullableUInt32) |
Inverse fast fourier transform from fcomplex hermitian input to real data.
[ILNumerics Computing Engine] | |
imag(BaseArraycomplex) |
Creates array with imaginary parts of complex elements from A.
[ILNumerics Computing Engine] | |
imag(BaseArrayfcomplex) |
Creates array with imaginary parts of complex elements from A.
[ILNumerics Computing Engine] | |
ind2subT, LocalT, InT, OutT, RetT, StorageT(ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT, InArrayInt64, Int32) |
Computes dimensional indices from squential indices.
[ILNumerics Computing Engine] | |
ind2subT, LocalT, InT, OutT, RetT, StorageT(ConcreteArrayT, LocalT, InT, OutT, RetT, StorageT, InArrayUInt32, Int32) |
Computes dimensional indices from squential indices.
[ILNumerics Computing Engine] | |
isempty |
Tests if A has no elements.
[ILNumerics Computing Engine] | |
isequal |
Compares the number, shape, and type of elements of A and B and returns true if both are the same.
[ILNumerics Computing Engine] | |
isequalwithequalnans(InArraycomplex, InArraycomplex) |
Checks if all elements of two arrays are equal, comparing NaN and +/- infinity like regular values.
[ILNumerics Computing Engine] | |
isequalwithequalnans(InArrayfcomplex, InArrayfcomplex) |
Checks if all elements of two arrays are equal, comparing NaN and +/- infinity like regular values.
[ILNumerics Computing Engine] | |
isequalwithequalnans(InArrayDouble, InArrayDouble) |
Checks if all elements of two arrays are equal, comparing NaN and +/- infinity like regular values.
[ILNumerics Computing Engine] | |
isequalwithequalnans(InArraySingle, InArraySingle) |
Checks if all elements of two arrays are equal, comparing NaN and +/- infinity like regular values.
[ILNumerics Computing Engine] | |
isfinite(BaseArraycomplex) |
Checks for finite elements.
[ILNumerics Computing Engine] | |
isfinite(BaseArrayfcomplex) |
Checks for finite elements.
[ILNumerics Computing Engine] | |
isfinite(BaseArrayDouble) |
Checks for non-infinity, non-NaN elements.
[ILNumerics Computing Engine] | |
isfinite(BaseArraySingle) |
Checks for finite elements.
[ILNumerics Computing Engine] | |
ishermitian(InArraycomplex) |
Determines if matrix A is a hermitian matrix.
[ILNumerics Computing Engine] | |
ishermitian(InArrayfcomplex) |
Determines if matrix A is a hermitian matrix.
[ILNumerics Computing Engine] | |
ishermitian(InArrayByte) |
Determines if matrix A is a hermitian matrix.
[ILNumerics Computing Engine] | |
ishermitian(InArrayDouble) |
Determines if matrix A is a hermitian matrix.
[ILNumerics Computing Engine] | |
ishermitian(InArrayInt32) |
Determines if matrix A is a hermitian matrix.
[ILNumerics Computing Engine] | |
ishermitian(InArrayInt64) |
Determines if matrix A is a hermitian matrix.
[ILNumerics Computing Engine] | |
ishermitian(InArraySingle) |
Determines if matrix A is a hermitian matrix.
[ILNumerics Computing Engine] | |
ishesslow(InArraycomplex) |
Determines if matrix A is a lower Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishesslow(InArrayfcomplex) |
Determines if matrix A is a lower Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishesslow(InArrayByte) |
Determines if matrix A is a lower Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishesslow(InArrayDouble) |
Determines if matrix A is a lower Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishesslow(InArrayInt32) |
Determines if matrix A is a lower Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishesslow(InArrayInt64) |
Determines if matrix A is a lower Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishesslow(InArraySingle) |
Determines if matrix A is a lower Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishessup(InArraycomplex) |
Determines if matrix A is an upper Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishessup(InArrayfcomplex) |
Determines if matrix A is an upper Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishessup(InArrayByte) |
Determines if matrix A is an upper Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishessup(InArrayDouble) |
Determines if matrix A is an upper Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishessup(InArrayInt32) |
Determines if matrix A is an upper Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishessup(InArrayInt64) |
Determines if matrix A is an upper Hessenberg matrix.
[ILNumerics Computing Engine] | |
ishessup(InArraySingle) |
Determines if matrix A is an upper Hessenberg matrix.
[ILNumerics Computing Engine] | |
isinf(BaseArraycomplex) |
Checks for infinite elements.
[ILNumerics Computing Engine] | |
isinf(BaseArrayfcomplex) |
Checks for infinite elements.
[ILNumerics Computing Engine] | |
isinf(BaseArrayDouble) |
Checks for infinite elements.
[ILNumerics Computing Engine] | |
isinf(BaseArraySingle) |
Checks for infinite elements.
[ILNumerics Computing Engine] | |
isnan(BaseArraycomplex) |
Checks for elements which are not a number (NaN).
[ILNumerics Computing Engine] | |
isnan(BaseArrayfcomplex) |
Checks for elements which are not a number (NaN).
[ILNumerics Computing Engine] | |
isnan(BaseArrayDouble) |
Checks for elements which are not a number (NaN).
[ILNumerics Computing Engine] | |
isnan(BaseArraySingle) |
Checks for elements which are not a number (NaN).
[ILNumerics Computing Engine] | |
isneginf(BaseArraycomplex) |
Checks for elements which correspond to negative infinity.
[ILNumerics Computing Engine] | |
isneginf(BaseArrayfcomplex) |
Checks for elements which correspond to negative infinity.
[ILNumerics Computing Engine] | |
isneginf(BaseArrayDouble) |
Checks for elements which correspond to negative infinity.
[ILNumerics Computing Engine] | |
isneginf(BaseArraySingle) |
Checks for elements which correspond to negative infinity.
[ILNumerics Computing Engine] | |
isnull |
Determine, if the array A is null (NULL, not assigned).
[ILNumerics Computing Engine] | |
isnullorempty |
Tests if A is null (NULL or not assigned) or has no elements.
[ILNumerics Computing Engine] | |
isposinf(BaseArraycomplex) |
Checks for elements which correspond to positive infinity.
[ILNumerics Computing Engine] | |
isposinf(BaseArrayfcomplex) |
Checks for elements which correspond to positive infinity.
[ILNumerics Computing Engine] | |
isposinf(BaseArrayDouble) |
Checks for elements which correspond to positive infinity.
[ILNumerics Computing Engine] | |
isposinf(BaseArraySingle) |
Checks for elements which correspond to positive infinity.
[ILNumerics Computing Engine] | |
istrilow(InArraycomplex) |
Determines if matrix A is a lower triangular matrix.
[ILNumerics Computing Engine] | |
istrilow(InArrayfcomplex) |
Determines if matrix A is a lower triangular matrix.
[ILNumerics Computing Engine] | |
istrilow(InArrayByte) |
Determines if matrix A is a lower triangular matrix.
[ILNumerics Computing Engine] | |
istrilow(InArrayDouble) |
Determines if matrix A is a lower triangular matrix.
[ILNumerics Computing Engine] | |
istrilow(InArrayInt32) |
Determines if matrix A is a lower triangular matrix.
[ILNumerics Computing Engine] | |
istrilow(InArrayInt64) |
Determines if matrix A is a lower triangular matrix.
[ILNumerics Computing Engine] | |
istrilow(InArraySingle) |
Determines if matrix A is a lower triangular matrix.
[ILNumerics Computing Engine] | |
istriup(InArraycomplex) |
Determines if matrix A is an upper triangular matrix.
[ILNumerics Computing Engine] | |
istriup(InArrayfcomplex) |
Determines if matrix A is an upper triangular matrix.
[ILNumerics Computing Engine] | |
istriup(InArrayByte) |
Determines if matrix A is an upper triangular matrix.
[ILNumerics Computing Engine] | |
istriup(InArrayDouble) |
Determines if matrix A is an upper triangular matrix.
[ILNumerics Computing Engine] | |
istriup(InArrayInt32) |
Determines if matrix A is an upper triangular matrix.
[ILNumerics Computing Engine] | |
istriup(InArrayInt64) |
Determines if matrix A is an upper triangular matrix.
[ILNumerics Computing Engine] | |
istriup(InArraySingle) |
Determines if matrix A is an upper triangular matrix.
[ILNumerics Computing Engine] | |
le(BaseArraycomplex, BaseArraycomplex) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArrayfcomplex, BaseArrayfcomplex) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArrayByte, BaseArrayByte) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArrayDouble, BaseArrayDouble) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArrayInt16, BaseArrayInt16) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArrayInt32, BaseArrayInt32) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArrayInt64, BaseArrayInt64) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArraySByte, BaseArraySByte) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArraySingle, BaseArraySingle) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArrayUInt16, BaseArrayUInt16) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArrayUInt32, BaseArrayUInt32) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
le(BaseArrayUInt64, BaseArrayUInt64) |
Elementwise 'LowerOrEqual' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
length |
Gives the length of the longest dimension of A.
[ILNumerics Computing Engine] | |
linsolve(InArraycomplex, InArraycomplex) |
Solves a system of linear equations, B = A x.
[ILNumerics Computing Engine] | |
linsolve(InArrayfcomplex, InArrayfcomplex) |
Solves a system of linear equations, B = A x.
[ILNumerics Computing Engine] | |
linsolve(InArrayDouble, InArrayDouble) |
Solves a system of linear equations, B = A x.
[ILNumerics Computing Engine] | |
linsolve(InArraySingle, InArraySingle) |
Solves a system of linear equations, B = A x.
[ILNumerics Computing Engine] | |
linsolve(InArraycomplex, InArraycomplex, MatrixProperties, Boolean) |
Solves a system of linear equations, B = Ax, taking hints for the best algorithm.
[ILNumerics Computing Engine] | |
linsolve(InArrayfcomplex, InArrayfcomplex, MatrixProperties, Boolean) |
Solves a system of linear equations, B = Ax, taking hints for the best algorithm.
[ILNumerics Computing Engine] | |
linsolve(InArrayDouble, InArrayDouble, MatrixProperties, Boolean) |
Solves a system of linear equations, B = Ax, taking hints for the best algorithm.
[ILNumerics Computing Engine] | |
linsolve(InArraySingle, InArraySingle, MatrixProperties, Boolean) |
Solves a system of linear equations, B = Ax, taking hints for the best algorithm.
[ILNumerics Computing Engine] | |
linsolveTriLow(InArraycomplex, InArraycomplex, Int32) |
Solve system of linear equations A*x = B, with A being a square, lower triangular matrix.
[ILNumerics Computing Engine] | |
linsolveTriLow(InArrayfcomplex, InArrayfcomplex, Int32) |
Solve system of linear equations A*x = B, with A being a square, lower triangular matrix.
[ILNumerics Computing Engine] | |
linsolveTriLow(InArrayDouble, InArrayDouble, Int32) |
Solve system of linear equations A*x = B, with A being a square, lower triangular matrix.
[ILNumerics Computing Engine] | |
linsolveTriLow(InArraySingle, InArraySingle, Int32) |
Solve system of linear equations A*x = B, with A being a square, lower triangular matrix.
[ILNumerics Computing Engine] | |
linsolveTriUp(InArraycomplex, InArraycomplex, Int32) |
Solve system of linear equations A*x = B, with A being a square, upper triangular matrix.
[ILNumerics Computing Engine] | |
linsolveTriUp(InArrayfcomplex, InArrayfcomplex, Int32) |
Solve system of linear equations A*x = B, with A being a square, upper triangular matrix.
[ILNumerics Computing Engine] | |
linsolveTriUp(InArrayDouble, InArrayDouble, Int32) |
Solve system of linear equations A*x = B, with A being a square, upper triangular matrix.
[ILNumerics Computing Engine] | |
linsolveTriUp(InArraySingle, InArraySingle, Int32) |
Solve system of linear equations A*x = B, with A being a square, upper triangular matrix.
[ILNumerics Computing Engine] | |
linspace(InArrayDouble, InArrayDouble, InArrayDouble) |
Create linearly spaced row vector, double precision.
[ILNumerics Computing Engine] | |
linspaceT(InArrayT, InArrayT) |
Create linearly spaced row vector of 100 elements
[ILNumerics Computing Engine] | |
linspaceT(InArrayT, InArrayT, InArrayT) |
Create linearly spaced row vector, generic element type.
[ILNumerics Computing Engine] | |
loadArrayT |
Load single array from matfile file.
[ILNumerics Computing Engine] | |
loadBinaryT |
Load binary data from stream.
[ILNumerics Computing Engine] | |
loadChannels(Image, NullableRectangle) |
Load ARGB pixel data from image, provide indiviudal channel data.
[ILNumerics Computing Engine] | |
loadChannels(Stream, NullableRectangle) |
Load ARGB pixel data from image, provide indiviudal channel data.
[ILNumerics Computing Engine] | |
loadChannels(String, NullableRectangle) |
Load ARGB pixel data from image, provide indiviudal channel data.
[ILNumerics Computing Engine] | |
loadImage(Image, NullableRectangle) |
Load pixel data from image.
[ILNumerics Computing Engine] | |
loadImage(Stream, NullableRectangle) |
Load pixel data from image stream.
[ILNumerics Computing Engine] | |
loadImage(String, NullableRectangle) |
Load pixel data from image file.
[ILNumerics Computing Engine] | |
localCell |
Create new empty cell array, used for cell class member (attributes) initialization.
[ILNumerics Computing Engine] | |
localLogical |
Create new empty logical array, used for logical class member (attributes) initialization.
[ILNumerics Computing Engine] | |
localMemberT |
Initialize a local array variable as class attribute / field.
[ILNumerics Computing Engine] | |
log(BaseArraycomplex) |
Logarithm of array elements.
[ILNumerics Computing Engine] | |
log(BaseArrayfcomplex) |
Logarithm of array elements.
[ILNumerics Computing Engine] | |
log(BaseArrayDouble) |
Logarithm of array elements - real output.
[ILNumerics Computing Engine] | |
log(BaseArraySingle) |
Logarithm of array elements - real output.
[ILNumerics Computing Engine] | |
log10(BaseArraycomplex) |
Base 10 logarithm of array elements.
[ILNumerics Computing Engine] | |
log10(BaseArrayfcomplex) |
Base 10 logarithm of array elements.
[ILNumerics Computing Engine] | |
log10(BaseArrayDouble) |
Base 10 logarithm of array elements - real output.
[ILNumerics Computing Engine] | |
log10(BaseArraySingle) |
Base 10 logarithm of array elements - real output.
[ILNumerics Computing Engine] | |
log10c(BaseArrayDouble) |
Base 10 logarithm of array elements - complex output.
[ILNumerics Computing Engine] | |
log10c(BaseArraySingle) |
Base 10 logarithm of array elements - complex output.
[ILNumerics Computing Engine] | |
logc(BaseArrayDouble) |
Logarithm of array elements - complex output.
[ILNumerics Computing Engine] | |
logc(BaseArraySingle) |
Logarithm of array elements - complex output.
[ILNumerics Computing Engine] | |
logical(Boolean, InArrayInt64, StorageOrders) |
Creates a new logical array from the values provided in values with the shape given by size.
[ILNumerics Computing Engine] | |
logical(InArrayInt64, NullableStorageOrders, Boolean) |
Creates a new logical array with given shape and optional storage order.
[ILNumerics Computing Engine] | |
logistic |
Evaluates the sigmoid logistic function at a given point.
For more details about this function, see Wikipedia - Logistic function.
[ILNumerics Computing Engine] | |
logit |
Evaluates the inverse of the sigmoid logistic function.
For more details about this function, see Wikipedia - Logit function.
[ILNumerics Computing Engine] | |
logspace(InArrayDouble, InArrayDouble) |
Create logarithmically spaced row vector of 50 elements.
[ILNumerics Computing Engine] | |
logspace(InArrayDouble, InArrayDouble, InArrayDouble) |
Create logarithmically spaced row vector
[ILNumerics Computing Engine] | |
lshift(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: BitShiftLeft.
[ILNumerics Computing Engine] | |
lshift(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: BitShiftLeft.
[ILNumerics Computing Engine] | |
lshift(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: BitShiftLeft.
[ILNumerics Computing Engine] | |
lshift(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: BitShiftLeft.
[ILNumerics Computing Engine] | |
lshift(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: BitShiftLeft.
[ILNumerics Computing Engine] | |
lshift(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: BitShiftLeft.
[ILNumerics Computing Engine] | |
lshift(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: BitShiftLeft.
[ILNumerics Computing Engine] | |
lshift(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: BitShiftLeft.
[ILNumerics Computing Engine] | |
lt(BaseArraycomplex, BaseArraycomplex) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArrayfcomplex, BaseArrayfcomplex) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArrayByte, BaseArrayByte) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArrayDouble, BaseArrayDouble) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArrayInt16, BaseArrayInt16) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArrayInt32, BaseArrayInt32) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArrayInt64, BaseArrayInt64) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArraySByte, BaseArraySByte) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArraySingle, BaseArraySingle) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArrayUInt16, BaseArrayUInt16) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArrayUInt32, BaseArrayUInt32) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lt(BaseArrayUInt64, BaseArrayUInt64) |
Elementwise 'LowerThan' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
lu(InArraycomplex) |
LU matrix decomposition. Decompose general matrix A into strictly upper part and lower part.
[ILNumerics Computing Engine] | |
lu(InArrayfcomplex) |
LU matrix decomposition. Decompose general matrix A into strictly upper part and lower part.
[ILNumerics Computing Engine] | |
lu(InArrayDouble) |
LU matrix decomposition. Decompose general matrix A into strictly upper part and lower part.
[ILNumerics Computing Engine] | |
lu(InArraySingle) |
LU matrix decomposition. Decompose general matrix A into strictly upper part and lower part.
[ILNumerics Computing Engine] | |
lu(InArraycomplex, OutArraycomplex, OutArraycomplex) |
Decompose matrix A into uper and lower triangular matrices. Also generates pivoting permutation matrix.
[ILNumerics Computing Engine] | |
lu(InArrayfcomplex, OutArrayfcomplex, OutArrayfcomplex) |
Decompose matrix A into uper and lower triangular matrices. Also generates pivoting permutation matrix.
[ILNumerics Computing Engine] | |
lu(InArrayDouble, OutArrayDouble, OutArrayDouble) |
Decompose matrix A into uper and lower triangular matrices. Also generates pivoting permutation matrix.
[ILNumerics Computing Engine] | |
lu(InArraySingle, OutArraySingle, OutArraySingle) |
Decompose matrix A into uper and lower triangular matrices. Also generates pivoting permutation matrix.
[ILNumerics Computing Engine] | |
max(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: Maximum.
[ILNumerics Computing Engine] | |
max(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: Maximum.
[ILNumerics Computing Engine] | |
max(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: Maximum.
[ILNumerics Computing Engine] | |
max(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: Maximum.
[ILNumerics Computing Engine] | |
max(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: Maximum.
[ILNumerics Computing Engine] | |
max(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: Maximum.
[ILNumerics Computing Engine] | |
max(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: Maximum.
[ILNumerics Computing Engine] | |
max(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: Maximum.
[ILNumerics Computing Engine] | |
max(BaseArraycomplex, BaseArraycomplex, Boolean) |
Gives the maximum of corresponding elements from A and B. Recognizes NaN values.
[ILNumerics Computing Engine] | |
max(BaseArrayfcomplex, BaseArrayfcomplex, Boolean) |
Gives the maximum of corresponding elements from A and B. Recognizes NaN values.
[ILNumerics Computing Engine] | |
max(BaseArrayDouble, BaseArrayDouble, Boolean) |
Gives the maximum of corresponding elements from A and B. Recognizes NaN values.
[ILNumerics Computing Engine] | |
max(BaseArraySingle, BaseArraySingle, Boolean) |
Gives the maximum of corresponding elements from A and B. Recognizes NaN values.
[ILNumerics Computing Engine] | |
max(BaseArraycomplex, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArrayfcomplex, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArrayByte, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArrayDouble, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArrayInt16, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArrayInt32, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArrayInt64, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArraySByte, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArraySingle, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArrayUInt16, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArrayUInt32, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
max(BaseArrayUInt64, OutArrayInt64, Int32, Boolean) |
Computes the maximum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
maxall(ConcreteArraycomplex, Arraycomplex, InArraycomplex, OutArraycomplex, RetArraycomplex, Storagecomplex, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArrayByte, ArrayByte, InArrayByte, OutArrayByte, RetArrayByte, StorageByte, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArrayDouble, ArrayDouble, InArrayDouble, OutArrayDouble, RetArrayDouble, StorageDouble, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArrayInt16, ArrayInt16, InArrayInt16, OutArrayInt16, RetArrayInt16, StorageInt16, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArrayInt32, ArrayInt32, InArrayInt32, OutArrayInt32, RetArrayInt32, StorageInt32, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArrayInt64, ArrayInt64, InArrayInt64, OutArrayInt64, RetArrayInt64, StorageInt64, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArraySByte, ArraySByte, InArraySByte, OutArraySByte, RetArraySByte, StorageSByte, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArraySingle, ArraySingle, InArraySingle, OutArraySingle, RetArraySingle, StorageSingle, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArrayUInt16, ArrayUInt16, InArrayUInt16, OutArrayUInt16, RetArrayUInt16, StorageUInt16, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArrayUInt32, ArrayUInt32, InArrayUInt32, OutArrayUInt32, RetArrayUInt32, StorageUInt32, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArrayUInt64, ArrayUInt64, InArrayUInt64, OutArrayUInt64, RetArrayUInt64, StorageUInt64, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
maxall(ConcreteArrayfcomplex, Arrayfcomplex, InArrayfcomplex, OutArrayfcomplex, RetArrayfcomplex, Storagefcomplex, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the maximum value in A.
[ILNumerics Computing Engine] | |
mean(InArraycomplex, Int32) |
Mean of A along dimension dim.
[ILNumerics Computing Engine] | |
mean(InArrayfcomplex, Int32) |
Mean of A along dimension dim.
[ILNumerics Computing Engine] | |
mean(InArrayDouble, Int32) |
Mean of A along dimension dim.
[ILNumerics Computing Engine] | |
mean(InArraySingle, Int32) |
Mean of A along dimension dim.
[ILNumerics Computing Engine] | |
meshgrid(InArraycomplex, InArraycomplex, OutArraycomplex) |
Create two matrices for evaluation and visualization of 2 dimensional functions over a 2d grid.
[ILNumerics Computing Engine] | |
meshgrid(InArrayfcomplex, InArrayfcomplex, OutArrayfcomplex) |
Create two matrices for evaluation and visualization of 2 dimensional functions over a 2d grid.
[ILNumerics Computing Engine] | |
meshgrid(InArrayDouble, InArrayDouble, OutArrayDouble) |
Create two matrices for evaluation and visualization of 2 dimensional functions over a 2d grid.
[ILNumerics Computing Engine] | |
meshgrid(InArraySingle, InArraySingle, OutArraySingle) |
Create two matrices for evaluation and visualization of 2 dimensional functions over a 2d grid.
[ILNumerics Computing Engine] | |
meshgrid(InArraycomplex, InArraycomplex, InArraycomplex, OutArraycomplex, OutArraycomplex) |
Create 3d arrays for evaluation and visualization of 3 dimensional functions.
[ILNumerics Computing Engine] | |
meshgrid(InArrayfcomplex, InArrayfcomplex, InArrayfcomplex, OutArrayfcomplex, OutArrayfcomplex) |
Create 3d arrays for evaluation and visualization of 3 dimensional functions.
[ILNumerics Computing Engine] | |
meshgrid(InArrayDouble, InArrayDouble, InArrayDouble, OutArrayDouble, OutArrayDouble) |
Create 3d arrays for evaluation and visualization of 3 dimensional functions.
[ILNumerics Computing Engine] | |
meshgrid(InArraySingle, InArraySingle, InArraySingle, OutArraySingle, OutArraySingle) |
Create 3d arrays for evaluation and visualization of 3 dimensional functions.
[ILNumerics Computing Engine] | |
min(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: Minimum.
[ILNumerics Computing Engine] | |
min(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: Minimum.
[ILNumerics Computing Engine] | |
min(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: Minimum.
[ILNumerics Computing Engine] | |
min(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: Minimum.
[ILNumerics Computing Engine] | |
min(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: Minimum.
[ILNumerics Computing Engine] | |
min(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: Minimum.
[ILNumerics Computing Engine] | |
min(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: Minimum.
[ILNumerics Computing Engine] | |
min(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: Minimum.
[ILNumerics Computing Engine] | |
min(BaseArraycomplex, BaseArraycomplex, Boolean) |
Gives the minimum of corresponding elements from A and B. Recognizes NaN values.
[ILNumerics Computing Engine] | |
min(BaseArrayfcomplex, BaseArrayfcomplex, Boolean) |
Gives the minimum of corresponding elements from A and B. Recognizes NaN values.
[ILNumerics Computing Engine] | |
min(BaseArrayDouble, BaseArrayDouble, Boolean) |
Gives the minimum of corresponding elements from A and B. Recognizes NaN values.
[ILNumerics Computing Engine] | |
min(BaseArraySingle, BaseArraySingle, Boolean) |
Gives the minimum of corresponding elements from A and B. Recognizes NaN values.
[ILNumerics Computing Engine] | |
min(BaseArraycomplex, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArrayfcomplex, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArrayByte, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArrayDouble, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArrayInt16, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArrayInt32, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArrayInt64, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArraySByte, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArraySingle, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArrayUInt16, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArrayUInt32, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
min(BaseArrayUInt64, OutArrayInt64, Int32, Boolean) |
Computes the minimum of elements of A along the specified dimension.
[ILNumerics Computing Engine] | |
minall(ConcreteArraycomplex, Arraycomplex, InArraycomplex, OutArraycomplex, RetArraycomplex, Storagecomplex, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArrayByte, ArrayByte, InArrayByte, OutArrayByte, RetArrayByte, StorageByte, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArrayDouble, ArrayDouble, InArrayDouble, OutArrayDouble, RetArrayDouble, StorageDouble, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArrayInt16, ArrayInt16, InArrayInt16, OutArrayInt16, RetArrayInt16, StorageInt16, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArrayInt32, ArrayInt32, InArrayInt32, OutArrayInt32, RetArrayInt32, StorageInt32, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArrayInt64, ArrayInt64, InArrayInt64, OutArrayInt64, RetArrayInt64, StorageInt64, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArraySByte, ArraySByte, InArraySByte, OutArraySByte, RetArraySByte, StorageSByte, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArraySingle, ArraySingle, InArraySingle, OutArraySingle, RetArraySingle, StorageSingle, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArrayUInt16, ArrayUInt16, InArrayUInt16, OutArrayUInt16, RetArrayUInt16, StorageUInt16, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArrayUInt32, ArrayUInt32, InArrayUInt32, OutArrayUInt32, RetArrayUInt32, StorageUInt32, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArrayUInt64, ArrayUInt64, InArrayUInt64, OutArrayUInt64, RetArrayUInt64, StorageUInt64, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
minall(ConcreteArrayfcomplex, Arrayfcomplex, InArrayfcomplex, OutArrayfcomplex, RetArrayfcomplex, Storagefcomplex, OutArrayInt64, StorageOrders, Boolean) |
Computes the (flattened, row-major) sequential index and value of the element with the minimum value in A.
[ILNumerics Computing Engine] | |
mod(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod(BaseArrayDouble, BaseArrayDouble) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod(BaseArraySingle, BaseArraySingle) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod_sat(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod_sat(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod_sat(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod_sat(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod_sat(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod_sat(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod_sat(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
mod_sat(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: Modulo.
[ILNumerics Computing Engine] | |
multiply(InArraycomplex, InArraycomplex) |
Matrix multiplication for general matrices (2D).
[ILNumerics Computing Engine] | |
multiply(InArrayfcomplex, InArrayfcomplex) |
Matrix multiplication for general matrices (2D).
[ILNumerics Computing Engine] | |
multiply(InArrayDouble, InArrayDouble) |
Matrix multiplication for general matrices (2D).
[ILNumerics Computing Engine] | |
multiply(InArraySingle, InArraySingle) |
Matrix multiplication for general matrices (2D).
[ILNumerics Computing Engine] | |
multiply(InArraycomplex, InArraycomplex, InArraycomplex) |
Matrix multiplication for 3 general matrices (2D). Performs A ** (B ** C).
[ILNumerics Computing Engine] | |
multiply(InArrayfcomplex, InArrayfcomplex, InArrayfcomplex) |
Matrix multiplication for 3 general matrices (2D). Performs A ** (B ** C).
[ILNumerics Computing Engine] | |
multiply(InArrayDouble, InArrayDouble, InArrayDouble) |
Matrix multiplication for 3 general matrices (2D). Performs A ** (B ** C).
[ILNumerics Computing Engine] | |
multiply(InArraySingle, InArraySingle, InArraySingle) |
Matrix multiplication for 3 general matrices (2D). Performs A ** (B ** C).
[ILNumerics Computing Engine] | |
multiplyElem(BaseArraycomplex, BaseArraycomplex) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArrayfcomplex, BaseArrayfcomplex) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArrayDouble, BaseArrayDouble) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArraySingle, BaseArraySingle) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem_sat(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem_sat(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem_sat(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem_sat(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem_sat(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem_sat(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem_sat(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
multiplyElem_sat(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: MultiplyElem.
[ILNumerics Computing Engine] | |
ndims |
Number of dimensions of A.
[ILNumerics Computing Engine] | |
negate(BaseArrayByte) |
Unary negation of array elements.
[ILNumerics Computing Engine] | |
negate(BaseArrayDouble) |
Unary negation of array elements.
[ILNumerics Computing Engine] | |
negate(BaseArrayInt16) |
Unary negation of array elements.
[ILNumerics Computing Engine] | |
negate(BaseArrayInt32) |
Unary negation of array elements.
[ILNumerics Computing Engine] | |
negate(BaseArrayInt64) |
Unary negation of array elements.
[ILNumerics Computing Engine] | |
negate(BaseArraySByte) |
Unary negation of array elements.
[ILNumerics Computing Engine] | |
negate(BaseArraySingle) |
Unary negation of array elements.
[ILNumerics Computing Engine] | |
negate(BaseArrayUInt16) |
Unary negation of array elements.
[ILNumerics Computing Engine] | |
negate(BaseArrayUInt32) |
Unary negation of array elements.
[ILNumerics Computing Engine] | |
neq(BaseArraycomplex, BaseArraycomplex) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayfcomplex, BaseArrayfcomplex) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayBoolean, BaseArrayBoolean) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayByte, BaseArrayByte) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayDouble, BaseArrayDouble) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayInt16, BaseArrayInt16) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayInt32, BaseArrayInt32) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayInt64, BaseArrayInt64) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArraySByte, BaseArraySByte) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArraySingle, BaseArraySingle) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayUInt16, BaseArrayUInt16) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayUInt32, BaseArrayUInt32) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
neq(BaseArrayUInt64, BaseArrayUInt64) |
Elementwise 'UnEqualTo' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
NewT(Int64, UInt32, Boolean) |
Provides memory / T[] array for the current thread. This is for expert users and rare low-level scenarios only. Use the common array creation functions instead!
[ILNumerics Computing Engine] | |
NewT(UInt64, UInt32, Boolean) |
Provides memory / T[] array for the current thread. This is for expert users and rare low-level scenarios only. Use the common array creation functions instead!
[ILNumerics Computing Engine] | |
norm(InArraycomplex, Double) |
Vector or matrix norm.
[ILNumerics Computing Engine] | |
norm(InArrayfcomplex, Single) |
Vector or matrix norm.
[ILNumerics Computing Engine] | |
norm(InArrayDouble, Double) |
Vector or matrix norm.
[ILNumerics Computing Engine] | |
norm(InArraySingle, Single) |
Vector or matrix norm.
[ILNumerics Computing Engine] | |
not |
Logical negation of array elements.
[ILNumerics Computing Engine] | |
numel |
Gives the number of elements of A.
[ILNumerics Computing Engine] | |
ones(Int64) |
Creates a square matrix of 1.0-valued Double elements, size [dim0, dim0].
[ILNumerics Computing Engine] | |
ones(Int64, Int64) |
Creates a new ILNumerics array of 1.0 Double elements.
[ILNumerics Computing Engine] | |
ones(Int64, Int64, Int64) |
Creates a new ILNumerics array of 1.0 Double elements.
[ILNumerics Computing Engine] | |
ones(Int64, Int64, Int64, Int64) |
Creates a new ILNumerics array of 1.0 Double elements.
[ILNumerics Computing Engine] | |
ones(Int64, Int64, Int64, Int64, Int64) |
Creates a new ILNumerics array of 1.0 Double elements.
[ILNumerics Computing Engine] | |
ones(Int64, Int64, Int64, Int64, Int64, Int64) |
Creates a new ILNumerics array of 1.0 Double elements.
[ILNumerics Computing Engine] | |
ones(Int64, Int64, Int64, Int64, Int64, Int64, Int64) |
Creates a new ILNumerics array of 1.0 Double elements.
[ILNumerics Computing Engine] | |
onesT(Int64) |
Creates a new array of ones '1' with a size determined by size.
[ILNumerics Computing Engine] | |
onesT(Int64, StorageOrders) |
Creates a square matrix of 1-valued elements.
[ILNumerics Computing Engine] | |
onesT(InArrayInt64, StorageOrders) |
Creates a new array of ones '1' with a size determined by size.
[ILNumerics Computing Engine] | |
onesT(Size, StorageOrders) |
Creates a new array of ones '1' with the same size as size.
[ILNumerics Computing Engine] | |
onesT(Int64, Int64, StorageOrders) |
Creates a new ILNumerics array of ones for numeric element types T.
[ILNumerics Computing Engine] | |
onesT(Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array of ones for numeric element types T.
[ILNumerics Computing Engine] | |
onesT(Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array of ones for numeric element types T.
[ILNumerics Computing Engine] | |
onesT(Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array of ones for numeric element types T.
[ILNumerics Computing Engine] | |
onesT(Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array of ones for numeric element types T.
[ILNumerics Computing Engine] | |
onesT(Int64, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates a new ILNumerics array of ones for numeric element types T.
[ILNumerics Computing Engine] | |
or(BaseArraycomplex, BaseArraycomplex) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayfcomplex, BaseArrayfcomplex) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayBoolean, BaseArrayBoolean) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayByte, BaseArrayByte) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayDouble, BaseArrayDouble) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayInt16, BaseArrayInt16) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayInt32, BaseArrayInt32) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayInt64, BaseArrayInt64) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArraySByte, BaseArraySByte) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArraySingle, BaseArraySingle) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayUInt16, BaseArrayUInt16) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayUInt32, BaseArrayUInt32) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
or(BaseArrayUInt64, BaseArrayUInt64) |
Elementwise 'Or' comparison operator on two arrays.
[ILNumerics Computing Engine] | |
permuteT(BaseArrayT, InArrayInt32) | Obsolete.
Reorder dimensions of n-dimensional array A.
[ILNumerics Computing Engine] | |
permuteT(BaseArrayT, InArrayInt64) |
Reorder dimensions of n-dimensional array A.
[ILNumerics Computing Engine] | |
permuteT(BaseArrayT, InArrayUInt32) |
Reorder dimensions of n-dimensional array A.
[ILNumerics Computing Engine] | |
pinv(InArraycomplex, Nullablecomplex) |
Moore-Penrose pseudo inverse of A.
[ILNumerics Computing Engine] | |
pinv(InArrayfcomplex, Nullablefcomplex) |
Moore-Penrose pseudo inverse of A.
[ILNumerics Computing Engine] | |
pinv(InArrayDouble, NullableDouble) |
Moore-Penrose pseudo inverse of A.
[ILNumerics Computing Engine] | |
pinv(InArraySingle, NullableSingle) |
Moore-Penrose pseudo inverse of A.
[ILNumerics Computing Engine] | |
pol2cart(InArrayDouble, InArrayDouble, InArrayDouble, OutArrayDouble, OutArrayDouble) |
Transforms polar/ cylindrical coordinates into scalar coordinates.
[ILNumerics Computing Engine] | |
pol2cart(InArraySingle, InArraySingle, InArraySingle, OutArraySingle, OutArraySingle) |
Transforms polar/ cylindrical coordinates into scalar coordinates.
[ILNumerics Computing Engine] | |
poly(InArrayDouble, InArrayDouble) |
Polynomial evaluation
[ILNumerics Computing Engine] | |
poly(InArraySingle, InArraySingle) |
Polynomial evaluation
[ILNumerics Computing Engine] | |
pow(BaseArraycomplex, BaseArraycomplex) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArrayfcomplex, BaseArrayfcomplex) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArrayDouble, BaseArrayDouble) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArraySingle, BaseArraySingle) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow_sat(BaseArrayByte, BaseArrayByte) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow_sat(BaseArrayInt16, BaseArrayInt16) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow_sat(BaseArrayInt32, BaseArrayInt32) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow_sat(BaseArrayInt64, BaseArrayInt64) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow_sat(BaseArraySByte, BaseArraySByte) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow_sat(BaseArrayUInt16, BaseArrayUInt16) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow_sat(BaseArrayUInt32, BaseArrayUInt32) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
pow_sat(BaseArrayUInt64, BaseArrayUInt64) |
Binary, elementwise, broadcasting operation: Pow.
[ILNumerics Computing Engine] | |
prod(BaseArraycomplex, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArrayfcomplex, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArrayByte, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArrayDouble, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArrayInt16, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArrayInt32, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArrayInt64, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArraySByte, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArraySingle, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArrayUInt16, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArrayUInt32, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prod(BaseArrayUInt64, Int32, Boolean) |
Computes the product of elements of A along specific dimension dim.
[ILNumerics Computing Engine] | |
prodall(BaseArraycomplex) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArrayfcomplex) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArrayByte) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArrayDouble) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArrayInt16) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArrayInt32) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArrayInt64) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArraySByte) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArraySingle) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArrayUInt16) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArrayUInt32) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
prodall(BaseArrayUInt64) |
Computes the product of all elements of A.
[ILNumerics Computing Engine] | |
qr(InArraycomplex) |
QR decomposition - raw output as returned from LAPACK.
[ILNumerics Computing Engine] | |
qr(InArrayfcomplex) |
QR decomposition - raw output as returned from LAPACK.
[ILNumerics Computing Engine] | |
qr(InArrayDouble) |
QR decomposition - raw output as returned from LAPACK.
[ILNumerics Computing Engine] | |
qr(InArraySingle) |
QR decomposition - raw output as returned from LAPACK.
[ILNumerics Computing Engine] | |
qr(InArraycomplex, OutArraycomplex, OutArrayInt32, Boolean) |
QR decomposition with pivoting, potentially size saving shapes.
[ILNumerics Computing Engine] | |
qr(InArrayfcomplex, OutArrayfcomplex, OutArrayInt32, Boolean) |
QR decomposition with pivoting, potentially size saving shapes.
[ILNumerics Computing Engine] | |
qr(InArrayDouble, OutArrayDouble, OutArrayInt32, Boolean) |
QR decomposition with pivoting, potentially size saving shapes.
[ILNumerics Computing Engine] | |
qr(InArraySingle, OutArraySingle, OutArrayInt32, Boolean) |
QR decomposition with pivoting, potentially size saving shapes.
[ILNumerics Computing Engine] | |
rand(Int64) |
Creates a new array of uniformly distributed, pseudo random values and a size determined by size.
[ILNumerics Computing Engine] | |
rand(Int64, StorageOrders) |
Creates a symmetric matrix with uniformly distributed, pseudo random values.
[ILNumerics Computing Engine] | |
rand(InArrayInt64, StorageOrders) |
Creates an array with uniformly distributed, pseudo random values.
[ILNumerics Computing Engine] | |
rand(Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo random values.
[ILNumerics Computing Engine] | |
rand(Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo random values.
[ILNumerics Computing Engine] | |
rand(Int64, Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo random values.
[ILNumerics Computing Engine] | |
rand(Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo random values.
[ILNumerics Computing Engine] | |
rand(Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo random values.
[ILNumerics Computing Engine] | |
rand(Int64, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo random values.
[ILNumerics Computing Engine] | |
randn(Int64) |
Creates a new array of normally distributed, pseudo random values and a size determined by size.
[ILNumerics Computing Engine] | |
randn(Int64, StorageOrders) |
Creates a square matrix with normally distributed, pseudo random values.
[ILNumerics Computing Engine] | |
randn(InArrayInt64, StorageOrders) |
Creates an array with normally distributed, pseudo random values.
[ILNumerics Computing Engine] | |
randn(Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo randnom values.
[ILNumerics Computing Engine] | |
randn(Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo randnom values.
[ILNumerics Computing Engine] | |
randn(Int64, Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo randnom values.
[ILNumerics Computing Engine] | |
randn(Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo randnom values.
[ILNumerics Computing Engine] | |
randn(Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly distributed, pseudo randnom values.
[ILNumerics Computing Engine] | |
randn(Int64, Int64, Int64, Int64, Int64, Int64, Int64, StorageOrders) |
Creates an array with uniformly di |