Uses of Interface io.github.hakkelt.ndarrays.NDArray (NDArrays 2.2.1 API)

Packages that use NDArray
Package	Description
io.github.hakkelt.ndarrays	General framework for N-dimensional arrays holding either complex or real values.
io.github.hakkelt.ndarrays.basic	Simple reference implementation for NDArrays backed by 1D arrays of primitive values.
io.github.hakkelt.ndarrays.internal	Internal classes meant to be used for developing new NDArray-based packages, but should not be used directly.

Uses of NDArray in io.github.hakkelt.ndarrays

Subinterfaces of NDArray in io.github.hakkelt.ndarrays
Modifier and Type	Interface	Description
`interface`	`ComplexNDArray<T extends Number>`	General N-dimensional arrays holding complex values.

Classes in io.github.hakkelt.ndarrays that implement NDArray
Modifier and Type	Class	Description
`class`	`AbstractBigDecimalNDArray`	Abstract NDArray class for arbitrary precision floating point values.
`class`	`AbstractBigIntegerNDArray`	Abstract NDArray class for arbitrary precision integer values.
`class`	`AbstractByteNDArray`	Abstract NDArray class for byte (8-bit integer) values.
`class`	`AbstractComplexNDArray<T extends Number>`	Abstract NDArray class for Complex values.
`class`	`AbstractDoubleNDArray`	Abstract NDArray class for double (8-bit integer) values.
`class`	`AbstractFloatNDArray`	Abstract NDArray class for float (8-bit integer) values.
`class`	`AbstractIntegerNDArray`	Abstract NDArray class for int (8-bit integer) values.
`class`	`AbstractLongNDArray`	Abstract NDArray class for long (8-bit integer) values.
`class`	`AbstractShortNDArray`	Abstract NDArray class for short (8-bit integer) values.

Methods in io.github.hakkelt.ndarrays that return NDArray
Modifier and Type	Method	Description
`NDArray<T>`	AbstractComplexNDArray.`abs()`
`NDArray<T>`	ComplexNDArray.`abs()`	Returns a new array holding the magnitude / absolute values of the elements.
`NDArray<T>`	NDArray.`accumulate(BinaryOperator<T> func, int... selectedDims)`	Returns the accumulation of all elements along the specified dimensions in this NDArray.
`default NDArray<T>`	NDArray.`add(byte addend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray incremented by the given value.
`default NDArray<T>`	NDArray.`add(double addend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray incremented by the given value.
`default NDArray<T>`	NDArray.`add(float addend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray incremented by the given value.
`default NDArray<T>`	NDArray.`add(int addend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray incremented by the given value.
`default NDArray<T>`	NDArray.`add(long addend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray incremented by the given value.
`default NDArray<T>`	NDArray.`add(short addend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray incremented by the given value.
`default NDArray<T>`	NDArray.`add(NDArray<?> addend)`	Creates a new NDArray of the same shape and fills it with the element-wise sum of this NDArray and the NDArray given as parameter.
`NDArray<T>`	NDArray.`add(Object... addends)`	Creates a new NDArray of the same shape and fills it with the element-wise sum of this NDArray and the parameter NDArrays and scalars.
`default NDArray<T>`	NDArray.`addInplace(byte addend)`	Updates this NDArray by incrementing all entries with the given value.
`default NDArray<T>`	NDArray.`addInplace(double addend)`	Updates this NDArray by incrementing all entries with the given value.
`default NDArray<T>`	NDArray.`addInplace(float addend)`	Updates this NDArray by incrementing all entries with the given value.
`default NDArray<T>`	NDArray.`addInplace(int addend)`	Updates this NDArray by incrementing all entries with the given value.
`default NDArray<T>`	NDArray.`addInplace(long addend)`	Updates this NDArray by incrementing all entries with the given value.
`default NDArray<T>`	NDArray.`addInplace(short addend)`	Updates this NDArray by incrementing all entries with the given value.
`default NDArray<T>`	NDArray.`addInplace(NDArray<?> addend)`	Updates this NDArray with the element-wise sum of this NDArray and the one given as parameter.
`NDArray<T>`	NDArray.`addInplace(Object... addends)`	Updates this NDArray with the element-wise sum of this NDArray and the ones given as parameters.
`NDArray<T>`	NDArray.`apply(UnaryOperator<T> func)`	Apply the given function to each element of the array, and override each entry with the calculated new values.
`NDArray<T>`	NDArray.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`	Apply the given function to each slices of the array, and override each entry with the returned slice.
`NDArray<T>`	NDArray.`applyWithCartesianIndices(BiFunction<T,int[],T> func)`	Apply the given function to each element of the array, and override each entry with the calculated new values.
`NDArray<T>`	NDArray.`applyWithLinearIndices(BiFunction<T,Integer,T> func)`	Apply the given function to each element of the array, and override each entry with the calculated new values.
`NDArray<T>`	AbstractComplexNDArray.`argument()`
`NDArray<T>`	ComplexNDArray.`argument()`	Returns a new array holding the argument / argument of the elements.
`NDArray<T>`	NDArray.`concatenate(int axis, NDArray<?>... arrays)`	Creates a new NDArray that contains the elements of this NDArrays and all other NDArrays concatenated along the dimension/axis specified by the first parameter.
`NDArray<T>`	NDArray.`copy()`	Returns a copy of this NDArray.
`NDArray<T>`	NDArray.`copyFrom(byte[] array)`	Updates this NDArray with the elements of the array given as parameter.
`NDArray<T>`	NDArray.`copyFrom(double[] array)`	Updates this NDArray with the elements of the array given as parameter.
`NDArray<T>`	NDArray.`copyFrom(float[] array)`	Updates this NDArray with the elements of the array given as parameter.
`NDArray<T>`	NDArray.`copyFrom(int[] array)`	Updates this NDArray with the elements of the array given as parameter.
`NDArray<T>`	NDArray.`copyFrom(long[] array)`	Updates this NDArray with the elements of the array given as parameter.
`NDArray<T>`	NDArray.`copyFrom(short[] array)`	Updates this NDArray with the elements of the array given as parameter.
`NDArray<T>`	NDArray.`copyFrom(NDArray<?> array)`	Updates this NDArray with the elements of the NDArray given as parameter.
`NDArray<T>`	NDArray.`copyFrom(Object[] array)`	Updates this NDArray with the elements of the array given as parameter.
`default NDArray<T>`	NDArray.`divide(byte divisor)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divide(double divisor)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divide(float divisor)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divide(int divisor)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divide(long divisor)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divide(short divisor)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divide(NDArray<?> divisor)`	Creates a new NDArray of the same shape and fills it with the element-wise division of this NDArray and the NDArray given as parameter.
`NDArray<T>`	NDArray.`divide(Object... divisors)`	Creates a new NDArray of the same shape and fills it with the result of the element-wise division of this NDArray by the parameter NDArrays and scalars.
`default NDArray<T>`	NDArray.`divideInplace(byte divisor)`	Updates the elements this NDArray with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divideInplace(double divisor)`	Updates the elements this NDArray with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divideInplace(float divisor)`	Updates the elements this NDArray with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divideInplace(int divisor)`	Updates the elements this NDArray with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divideInplace(long divisor)`	Updates the elements this NDArray with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divideInplace(short divisor)`	Updates the elements this NDArray with the values of this NDArray divided by the given value.
`default NDArray<T>`	NDArray.`divideInplace(NDArray<?> divisor)`	Updates the elements this NDArray with the element-wise division of this NDArray and the NDArray given as parameter.
`NDArray<T>`	NDArray.`divideInplace(Object... divisors)`	Updates the elements this NDArray with the result of the element-wise division of this NDArray by the parameter NDArrays and scalars.
`NDArray<T>`	NDArray.`dropDims(int... droppedDims)`	Returns a view that references this NDArray as parent, and skips all singleton dimensions included in the parameter list.
`NDArray<T>`	NDArray.`fill(double value)`	Fill this NDArray with the specified value
`NDArray<T>`	NDArray.`fill(T value)`	Fill this NDArray with the specified value
`NDArray<T>`	NDArray.`fillUsingCartesianIndices(Function<int[],T> func)`	Apply the given function to each element of the array, and override each entry with the calculated new values.
`NDArray<T>`	NDArray.`fillUsingLinearIndices(IntFunction<T> func)`	Apply the given function to each element of the array, and override each entry with the calculated new values.
`NDArray<T>`	AbstractComplexNDArray.`imaginary()`
`NDArray<T>`	ComplexNDArray.`imaginary()`	Returns a new array holding the imaginary part of the array
`NDArray<T>`	NDArray.`inverseMask(NDArray<?> inverseMask)`	Returns an array view referencing this NDArray as parent that gives read-write access to a specific elements of the array selected by the given inverseMask.
`NDArray<T>`	NDArray.`map(UnaryOperator<T> func)`	Apply the given function to each element of the array, and create a new NDArray with the calculated new values.
`NDArray<T>`	NDArray.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`	Apply the given function to each slices of the array, and create a new NDArray with the calculated new values.
`NDArray<T>`	NDArray.`mapWithCartesianIndices(BiFunction<T,int[],T> func)`	Apply the given function to each element of the array, and create a new NDArray with the calculated new values.
`NDArray<T>`	NDArray.`mapWithLinearIndices(BiFunction<T,Integer,T> func)`	Apply the given function to each element of the array, and create a new NDArray with the calculated new values.
`NDArray<T>`	NDArray.`mask(NDArray<?> mask)`	Returns an array view referencing this NDArray as parent that gives read-write access to a specific elements of the array selected by the given mask.
`NDArray<T>`	NDArray.`mask(Predicate<T> func)`	Returns an array view referencing this NDArray as parent that gives read-write access to a specific elements for which the given function returns true.
`NDArray<T>`	NDArray.`maskWithCartesianIndices(BiPredicate<T,int[]> func)`	Returns an array view referencing this NDArray as parent that gives read-write access to a specific elements for which the given function returns true.
`NDArray<T>`	NDArray.`maskWithLinearIndices(BiPredicate<T,Integer> func)`	Returns an array view referencing this NDArray as parent that gives read-write access to a specific elements for which the given function returns true.
`default NDArray<T>`	NDArray.`multiply(byte multiplicand)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiply(double multiplicand)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiply(float multiplicand)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiply(int multiplicand)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiply(long multiplicand)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiply(short multiplicand)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiply(NDArray<?> multiplicand)`	Creates a new NDArray of the same shape and fills it with the element-wise product of this NDArray and the NDArray given as parameter.
`NDArray<T>`	NDArray.`multiply(Object... multiplicands)`	Creates a new NDArray of the same shape and fills it with the element-wise product of this NDArray and the parameter NDArrays and scalars.
`default NDArray<T>`	NDArray.`multiplyInplace(byte multiplicand)`	Updates the elements of this NDArray with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiplyInplace(double multiplicand)`	Updates the elements of this NDArray with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiplyInplace(float multiplicand)`	Updates the elements of this NDArray with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiplyInplace(int multiplicand)`	Updates the elements of this NDArray with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiplyInplace(long multiplicand)`	Updates the elements of this NDArray with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiplyInplace(short multiplicand)`	Updates the elements of this NDArray with the values of this NDArray multiplied by the given value.
`default NDArray<T>`	NDArray.`multiplyInplace(NDArray<?> multiplicand)`	Updates the elements of this NDArray with the element-wise product of this NDArray and the NDArray given as parameter.
`NDArray<T>`	NDArray.`multiplyInplace(Object... multiplicands)`	Updates the elements of this NDArray with the element-wise product of this NDArray and the parameter NDArrays and scalars.
`NDArray<T>`	NDArray.`permuteDims(int... permutation)`	Returns a view that references this NDArray as parent, but the order of dimensions are swiched in this view.
`NDArray<T>`	NDArray.`prod(int... selectedDims)`	Returns the product of all elements along the specified dimensions in this NDArray.
`NDArray<T>`	AbstractComplexNDArray.`real()`
`NDArray<T>`	ComplexNDArray.`real()`	Returns a new array holding the real part of the array
`NDArray<T>`	NDArray.`reduceSlices(BiFunction<NDArray<T>,int[],T> func, int... selectedDims)`	Reduces slices along the specified dimensions in this NDArray to scalar values, reducing the number of dimensions.
`NDArray<T>`	NDArray.`reshape(int... newShape)`	Returns a view that references this NDArray as parent but has a different shape.
`NDArray<T>`	NDArray.`selectDims(int... selectedDims)`	Returns a view that references this NDArray as parent, and skips all singleton dimensions not included in the parameter list.
`NDArray<T>`	NDArray.`similar()`	Returns a new array of the same shape as this NDArray filled with zeros.
`NDArray<T>`	NDArray.`slice(Object... slicingExpressions)`	Returns an array view referencing this NDArray as parent that gives read-write access to a specific multi-dimensional slice of the array.
`NDArray<T>`	NDArray.`squeeze()`	Returns a view that references this NDArray as parent, and skips all singleton dimensions.
`default NDArray<T>`	NDArray.`subtract(byte subtrahend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray minus the given value.
`default NDArray<T>`	NDArray.`subtract(double subtrahend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray minus the given value.
`default NDArray<T>`	NDArray.`subtract(float subtrahend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray minus the given value.
`default NDArray<T>`	NDArray.`subtract(int subtrahend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray minus the given value.
`default NDArray<T>`	NDArray.`subtract(long subtrahend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray minus the given value.
`default NDArray<T>`	NDArray.`subtract(short subtrahend)`	Creates a new NDArray of the same shape and fills it with the values of this NDArray minus the given value.
`default NDArray<T>`	NDArray.`subtract(NDArray<?> subtrahend)`	Creates a new NDArray of the same shape and fills it with the element-wise subtraction of the given NDArray from this NDArray.
`NDArray<T>`	NDArray.`subtract(Object... subtrahends)`	Creates a new NDArray of the same shape and fills it with the result of the element-wise substraction the parameter NDArrays and scalars from this NDArray.
`default NDArray<T>`	NDArray.`subtractInplace(byte subtrahend)`	Updates this NDArray by subtracting the given value from all entries of this NDArray.
`default NDArray<T>`	NDArray.`subtractInplace(double subtrahend)`	Updates this NDArray by subtracting the given value from all entries of this NDArray.
`default NDArray<T>`	NDArray.`subtractInplace(float subtrahend)`	Updates this NDArray by subtracting the given value from all entries of this NDArray.
`default NDArray<T>`	NDArray.`subtractInplace(int subtrahend)`	Updates this NDArray by subtracting the given value from all entries of this NDArray.
`default NDArray<T>`	NDArray.`subtractInplace(long subtrahend)`	Updates this NDArray by subtracting the given value from all entries of this NDArray.
`default NDArray<T>`	NDArray.`subtractInplace(short subtrahend)`	Updates this NDArray by subtracting the given value from all entries of this NDArray.
`default NDArray<T>`	NDArray.`subtractInplace(NDArray<?> subtrahend)`	Updates this NDArray with the element-wise subtraction of the given NDArray from this NDArray.
`NDArray<T>`	NDArray.`subtractInplace(Object... subtrahends)`	Updates the elements this NDArray with the result of the element-wise subtraction the parameter NDArrays and scalars from this NDArray.
`NDArray<T>`	NDArray.`sum(int... selectedDims)`	Returns the sum of all elements along the specified dimensions in this NDArray.

Methods in io.github.hakkelt.ndarrays with parameters of type NDArray
Modifier and Type	Method	Description
`default ComplexNDArray<T>`	ComplexNDArray.`add(NDArray<?> addend)`
`default NDArray<T>`	NDArray.`add(NDArray<?> addend)`	Creates a new NDArray of the same shape and fills it with the element-wise sum of this NDArray and the NDArray given as parameter.
`default ComplexNDArray<T>`	ComplexNDArray.`addInplace(NDArray<?> addend)`
`default NDArray<T>`	NDArray.`addInplace(NDArray<?> addend)`	Updates this NDArray with the element-wise sum of this NDArray and the one given as parameter.
`static void`	NDArrayUtils.`checkDTypeCompatibility(NDArray<?> me, Object array)`
`static void`	NDArrayUtils.`checkShapeCompatibility(NDArray<?> me, int[] arrayDims)`
`default ComplexNDArray<T>`	ComplexNDArray.`concatenate(int axis, NDArray<?>... arrays)`
`NDArray<T>`	NDArray.`concatenate(int axis, NDArray<?>... arrays)`	Creates a new NDArray that contains the elements of this NDArrays and all other NDArrays concatenated along the dimension/axis specified by the first parameter.
`default ComplexNDArray<T>`	ComplexNDArray.`copyFrom(NDArray<?> array)`
`default ComplexNDArray<T>`	ComplexNDArray.`copyFrom(NDArray<? extends Number> real, NDArray<? extends Number> imag)`	Updates this NDArray with the elements of the arrays given as parameters.
`NDArray<T>`	NDArray.`copyFrom(NDArray<?> array)`	Updates this NDArray with the elements of the NDArray given as parameter.
`default ComplexNDArray<T>`	ComplexNDArray.`divide(NDArray<?> divisor)`
`default NDArray<T>`	NDArray.`divide(NDArray<?> divisor)`	Creates a new NDArray of the same shape and fills it with the element-wise division of this NDArray and the NDArray given as parameter.
`default ComplexNDArray<T>`	ComplexNDArray.`divideInplace(NDArray<?> divisor)`
`default NDArray<T>`	NDArray.`divideInplace(NDArray<?> divisor)`	Updates the elements this NDArray with the element-wise division of this NDArray and the NDArray given as parameter.
`default ComplexNDArray<T>`	ComplexNDArray.`inverseMask(NDArray<?> mask)`
`NDArray<T>`	NDArray.`inverseMask(NDArray<?> inverseMask)`	Returns an array view referencing this NDArray as parent that gives read-write access to a specific elements of the array selected by the given inverseMask.
`default ComplexNDArray<T>`	ComplexNDArray.`mask(NDArray<?> mask)`
`NDArray<T>`	NDArray.`mask(NDArray<?> mask)`	Returns an array view referencing this NDArray as parent that gives read-write access to a specific elements of the array selected by the given mask.
`default ComplexNDArray<T>`	ComplexNDArray.`multiply(NDArray<?> multiplicand)`
`default NDArray<T>`	NDArray.`multiply(NDArray<?> multiplicand)`	Creates a new NDArray of the same shape and fills it with the element-wise product of this NDArray and the NDArray given as parameter.
`default ComplexNDArray<T>`	ComplexNDArray.`multiplyInplace(NDArray<?> multiplicand)`
`default NDArray<T>`	NDArray.`multiplyInplace(NDArray<?> multiplicand)`	Updates the elements of this NDArray with the element-wise product of this NDArray and the NDArray given as parameter.
`default ComplexNDArray<T>`	ComplexNDArray.`subtract(NDArray<?> substrahend)`
`default NDArray<T>`	NDArray.`subtract(NDArray<?> subtrahend)`	Creates a new NDArray of the same shape and fills it with the element-wise subtraction of the given NDArray from this NDArray.
`default ComplexNDArray<T>`	ComplexNDArray.`subtractInplace(NDArray<?> substrahend)`
`default NDArray<T>`	NDArray.`subtractInplace(NDArray<?> subtrahend)`	Updates this NDArray with the element-wise subtraction of the given NDArray from this NDArray.

Method parameters in io.github.hakkelt.ndarrays with type arguments of type NDArray
Modifier and Type	Method	Description
`ComplexNDArray<T>`	AbstractComplexNDArray.`applyOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T>`	ComplexNDArray.`applyOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`	Apply the given function to each slices of the array, and override each entry with the returned slice.
`NDArray<T>`	NDArray.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`	Apply the given function to each slices of the array, and override each entry with the returned slice.
`NDArray<T>`	NDArray.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`	Apply the given function to each slices of the array, and override each entry with the returned slice.
`ComplexNDArray<T>`	AbstractComplexNDArray.`mapOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T>`	ComplexNDArray.`mapOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`	Apply the given function to each slices of the array, and create a new NDArray with the calculated new values.
`NDArray<T>`	NDArray.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`	Apply the given function to each slices of the array, and create a new NDArray with the calculated new values.
`NDArray<T>`	NDArray.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`	Apply the given function to each slices of the array, and create a new NDArray with the calculated new values.
`NDArray<T>`	NDArray.`reduceSlices(BiFunction<NDArray<T>,int[],T> func, int... selectedDims)`	Reduces slices along the specified dimensions in this NDArray to scalar values, reducing the number of dimensions.

Uses of NDArray in io.github.hakkelt.ndarrays.basic

Classes in io.github.hakkelt.ndarrays.basic that implement NDArray
Modifier and Type	Class	Description
`class`	`BasicBigDecimalNDArray`	Reference implementation for the NDArray of BigDecimal (arbitrary precision floating-point) values.
`class`	`BasicBigIntegerNDArray`	Reference implementation for the NDArray of BigInteger (arbitrary precision integer) values.
`class`	`BasicByteNDArray`	Reference implementation for the NDArray of byte (8 bit integer) values.
`class`	`BasicComplexDoubleNDArray`	Reference implementation for the NDArray of complex double (single-precision, 32 bit doubleing point) values.
`class`	`BasicComplexFloatNDArray`	Reference implementation for the NDArray of complex float (single-precision, 32 bit floating point) values.
`class`	`BasicDoubleNDArray`	Reference implementation for the NDArray of double (double precision, 64 bit floating-point) values.
`class`	`BasicFloatNDArray`	Reference implementation for the NDArray of float (single precision, 32 bit floating-point) values.
`class`	`BasicIntegerNDArray`	Reference implementation for the NDArray of int (32 bit integer) values.
`class`	`BasicLongNDArray`	Reference implementation for the NDArray of long (64 bit integer) values.
`class`	`BasicShortNDArray`	Reference implementation for the NDArray of short (16 bit integer) values.

Methods in io.github.hakkelt.ndarrays.basic that return NDArray
Modifier and Type	Method	Description
`NDArray<BigDecimal>`	BasicBigDecimalNDArray.`copyFrom(NDArray<?> array)`
`NDArray<BigInteger>`	BasicBigIntegerNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Byte>`	BasicByteNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Double>`	BasicDoubleNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Float>`	BasicFloatNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Integer>`	BasicIntegerNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Long>`	BasicLongNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Short>`	BasicShortNDArray.`copyFrom(NDArray<?> array)`
`static NDArray<BigDecimal>`	BasicBigDecimalNDArray.`of(byte... array)`	Factory method that creates an NDArray from a list or 1D array of BigDecimal values.
`static NDArray<BigDecimal>`	BasicBigDecimalNDArray.`of(double... array)`	Factory method that creates an NDArray from a list or 1D array of BigDecimal values.
`static NDArray<BigDecimal>`	BasicBigDecimalNDArray.`of(float... array)`	Factory method that creates an NDArray from a list or 1D array of BigDecimal values.
`static NDArray<BigDecimal>`	BasicBigDecimalNDArray.`of(int... array)`	Factory method that creates an NDArray from a list or 1D array of BigDecimal values.
`static NDArray<BigDecimal>`	BasicBigDecimalNDArray.`of(long... array)`	Factory method that creates an NDArray from a list or 1D array of BigDecimal values.
`static NDArray<BigDecimal>`	BasicBigDecimalNDArray.`of(short... array)`	Factory method that creates an NDArray from a list or 1D array of BigDecimal values.
`static NDArray<BigDecimal>`	BasicBigDecimalNDArray.`of(Object[] array)`	Factory method that creates an NDArray from a multi-dimensional array of numeric values.
`static NDArray<BigInteger>`	BasicBigIntegerNDArray.`of(byte... array)`	Factory method that creates an NDArray from a list or 1D array of BigInteger values.
`static NDArray<BigInteger>`	BasicBigIntegerNDArray.`of(double... array)`	Factory method that creates an NDArray from a list or 1D array of BigInteger values.
`static NDArray<BigInteger>`	BasicBigIntegerNDArray.`of(float... array)`	Factory method that creates an NDArray from a list or 1D array of BigInteger values.
`static NDArray<BigInteger>`	BasicBigIntegerNDArray.`of(int... array)`	Factory method that creates an NDArray from a list or 1D array of BigInteger values.
`static NDArray<BigInteger>`	BasicBigIntegerNDArray.`of(long... array)`	Factory method that creates an NDArray from a list or 1D array of BigInteger values.
`static NDArray<BigInteger>`	BasicBigIntegerNDArray.`of(short... array)`	Factory method that creates an NDArray from a list or 1D array of BigInteger values.
`static NDArray<BigInteger>`	BasicBigIntegerNDArray.`of(Object[] array)`	Factory method that creates an NDArray from a multi-dimensional array of numeric values.
`static NDArray<Byte>`	BasicByteNDArray.`of(byte... array)`	Factory method that creates an NDArray from a list or 1D array of byte values.
`static NDArray<Byte>`	BasicByteNDArray.`of(double... array)`	Factory method that creates an NDArray from a list or 1D array of byte values.
`static NDArray<Byte>`	BasicByteNDArray.`of(float... array)`	Factory method that creates an NDArray from a list or 1D array of byte values.
`static NDArray<Byte>`	BasicByteNDArray.`of(int... array)`	Factory method that creates an NDArray from a list or 1D array of byte values.
`static NDArray<Byte>`	BasicByteNDArray.`of(long... array)`	Factory method that creates an NDArray from a list or 1D array of byte values.
`static NDArray<Byte>`	BasicByteNDArray.`of(short... array)`	Factory method that creates an NDArray from a list or 1D array of byte values.
`static NDArray<Byte>`	BasicByteNDArray.`of(Object[] array)`	Factory method that creates an NDArray from a multi-dimensional array of numeric values.
`static NDArray<Double>`	BasicDoubleNDArray.`of(byte... array)`	Factory method that creates an NDArray from a list or 1D array of double values.
`static NDArray<Double>`	BasicDoubleNDArray.`of(double... array)`	Factory method that creates an NDArray from a list or 1D array of double values.
`static NDArray<Double>`	BasicDoubleNDArray.`of(float... array)`	Factory method that creates an NDArray from a list or 1D array of double values.
`static NDArray<Double>`	BasicDoubleNDArray.`of(int... array)`	Factory method that creates an NDArray from a list or 1D array of double values.
`static NDArray<Double>`	BasicDoubleNDArray.`of(long... array)`	Factory method that creates an NDArray from a list or 1D array of double values.
`static NDArray<Double>`	BasicDoubleNDArray.`of(short... array)`	Factory method that creates an NDArray from a list or 1D array of double values.
`static NDArray<Double>`	BasicDoubleNDArray.`of(Object[] array)`	Factory method that creates an NDArray from a multi-dimensional array of numeric values.
`static NDArray<Float>`	BasicFloatNDArray.`of(byte... array)`	Factory method that creates an NDArray from a list or 1D array of float values.
`static NDArray<Float>`	BasicFloatNDArray.`of(double... array)`	Factory method that creates an NDArray from a list or 1D array of float values.
`static NDArray<Float>`	BasicFloatNDArray.`of(float... array)`	Factory method that creates an NDArray from a list or 1D array of float values.
`static NDArray<Float>`	BasicFloatNDArray.`of(int... array)`	Factory method that creates an NDArray from a list or 1D array of float values.
`static NDArray<Float>`	BasicFloatNDArray.`of(long... array)`	Factory method that creates an NDArray from a list or 1D array of float values.
`static NDArray<Float>`	BasicFloatNDArray.`of(short... array)`	Factory method that creates an NDArray from a list or 1D array of float values.
`static NDArray<Float>`	BasicFloatNDArray.`of(Object[] array)`	Factory method that creates an NDArray from a multi-dimensional array of numeric values.
`static NDArray<Integer>`	BasicIntegerNDArray.`of(byte... array)`	Factory method that creates an NDArray from a list or 1D array of int values.
`static NDArray<Integer>`	BasicIntegerNDArray.`of(double... array)`	Factory method that creates an NDArray from a list or 1D array of int values.
`static NDArray<Integer>`	BasicIntegerNDArray.`of(float... array)`	Factory method that creates an NDArray from a list or 1D array of int values.
`static NDArray<Integer>`	BasicIntegerNDArray.`of(int... array)`	Factory method that creates an NDArray from a list or 1D array of int values.
`static NDArray<Integer>`	BasicIntegerNDArray.`of(long... array)`	Factory method that creates an NDArray from a list or 1D array of int values.
`static NDArray<Integer>`	BasicIntegerNDArray.`of(short... array)`	Factory method that creates an NDArray from a list or 1D array of int values.
`static NDArray<Integer>`	BasicIntegerNDArray.`of(Object[] array)`	Factory method that creates an NDArray from a multi-dimensional array of numeric values.
`static NDArray<Long>`	BasicLongNDArray.`of(byte... array)`	Factory method that creates an NDArray from a list or 1D array of long values.
`static NDArray<Long>`	BasicLongNDArray.`of(double... array)`	Factory method that creates an NDArray from a list or 1D array of long values.
`static NDArray<Long>`	BasicLongNDArray.`of(float... array)`	Factory method that creates an NDArray from a list or 1D array of long values.
`static NDArray<Long>`	BasicLongNDArray.`of(int... array)`	Factory method that creates an NDArray from a list or 1D array of long values.
`static NDArray<Long>`	BasicLongNDArray.`of(long... array)`	Factory method that creates an NDArray from a list or 1D array of long values.
`static NDArray<Long>`	BasicLongNDArray.`of(short... array)`	Factory method that creates an NDArray from a list or 1D array of long values.
`static NDArray<Long>`	BasicLongNDArray.`of(Object[] array)`	Factory method that creates an NDArray from a multi-dimensional array of numeric values.
`static NDArray<Short>`	BasicShortNDArray.`of(byte... array)`	Factory method that creates an NDArray from a list or 1D array of short values.
`static NDArray<Short>`	BasicShortNDArray.`of(double... array)`	Factory method that creates an NDArray from a list or 1D array of short values.
`static NDArray<Short>`	BasicShortNDArray.`of(float... array)`	Factory method that creates an NDArray from a list or 1D array of short values.
`static NDArray<Short>`	BasicShortNDArray.`of(int... array)`	Factory method that creates an NDArray from a list or 1D array of short values.
`static NDArray<Short>`	BasicShortNDArray.`of(long... array)`	Factory method that creates an NDArray from a list or 1D array of short values.
`static NDArray<Short>`	BasicShortNDArray.`of(short... array)`	Factory method that creates an NDArray from a list or 1D array of short values.
`static NDArray<Short>`	BasicShortNDArray.`of(Object[] array)`	Factory method that creates an NDArray from a multi-dimensional array of numeric values.

Methods in io.github.hakkelt.ndarrays.basic that return types with arguments of type NDArray
Modifier and Type	Method	Description
`static Collector<Object,List<Object>,NDArray<BigDecimal>>`	BasicBigDecimalNDArray.`getCollector(int... shape)`
`static Collector<Object,List<Object>,NDArray<BigInteger>>`	BasicBigIntegerNDArray.`getCollector(int... shape)`
`static Collector<Object,List<Object>,NDArray<Byte>>`	BasicByteNDArray.`getCollector(int... shape)`
`static Collector<Object,List<Object>,NDArray<org.apache.commons.math3.complex.Complex>>`	BasicComplexDoubleNDArray.`getCollector(int... shape)`
`static Collector<Object,List<Object>,NDArray<org.apache.commons.math3.complex.Complex>>`	BasicComplexFloatNDArray.`getCollector(int... shape)`
`static Collector<Object,List<Object>,NDArray<Double>>`	BasicDoubleNDArray.`getCollector(int... shape)`
`static Collector<Object,List<Object>,NDArray<Float>>`	BasicFloatNDArray.`getCollector(int... shape)`
`static Collector<Object,List<Object>,NDArray<Integer>>`	BasicIntegerNDArray.`getCollector(int... shape)`
`static Collector<Object,List<Object>,NDArray<Long>>`	BasicLongNDArray.`getCollector(int... shape)`
`static Collector<Object,List<Object>,NDArray<Short>>`	BasicShortNDArray.`getCollector(int... shape)`

Methods in io.github.hakkelt.ndarrays.basic with parameters of type NDArray
Modifier and Type	Method	Description
`NDArray<BigDecimal>`	BasicBigDecimalNDArray.`copyFrom(NDArray<?> array)`
`NDArray<BigInteger>`	BasicBigIntegerNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Byte>`	BasicByteNDArray.`copyFrom(NDArray<?> array)`
`ComplexNDArray<Double>`	BasicComplexDoubleNDArray.`copyFrom(NDArray<?> array)`
`ComplexNDArray<Float>`	BasicComplexFloatNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Double>`	BasicDoubleNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Float>`	BasicFloatNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Integer>`	BasicIntegerNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Long>`	BasicLongNDArray.`copyFrom(NDArray<?> array)`
`NDArray<Short>`	BasicShortNDArray.`copyFrom(NDArray<?> array)`
`static ComplexNDArray<Double>`	BasicComplexDoubleNDArray.`ofMagnitudePhase(NDArray<? extends Number> magnitude, NDArray<? extends Number> phase)`	Factory method that creates a ComplexNDArray from two multi-dimensional arrays of numeric values.
`static ComplexNDArray<Float>`	BasicComplexFloatNDArray.`ofMagnitudePhase(NDArray<? extends Number> magnitude, NDArray<? extends Number> phase)`	Factory method that creates a ComplexNDArray from two multi-dimensional arrays of numeric values.

Constructors in io.github.hakkelt.ndarrays.basic with parameters of type NDArray
Constructor	Description
`BasicBigDecimalNDArray(NDArray<? extends Number> array)`	Copy constructor.
`BasicBigIntegerNDArray(NDArray<? extends Number> array)`	Copy constructor.
`BasicByteNDArray(NDArray<? extends Number> array)`	Copy constructor.
`BasicComplexDoubleNDArray(NDArray<?> array)`	Copy constructor.
`BasicComplexDoubleNDArray(NDArray<? extends Number> real, NDArray<? extends Number> imag)`	Copy constructor.
`BasicComplexFloatNDArray(NDArray<?> array)`	Copy constructor.
`BasicComplexFloatNDArray(NDArray<? extends Number> real, NDArray<? extends Number> imag)`	Copy constructor.
`BasicDoubleNDArray(NDArray<? extends Number> array)`	Copy constructor.
`BasicFloatNDArray(NDArray<? extends Number> array)`	Copy constructor.
`BasicIntegerNDArray(NDArray<? extends Number> array)`	Copy constructor.
`BasicLongNDArray(NDArray<? extends Number> array)`	Copy constructor.
`BasicShortNDArray(NDArray<? extends Number> array)`	Copy constructor.

Uses of NDArray in io.github.hakkelt.ndarrays.internal

Subinterfaces of NDArray in io.github.hakkelt.ndarrays.internal
Modifier and Type	Interface	Description
`interface`	`RealNDArray<T extends Number>`	General N-dimensional arrays holding real values.

Classes in io.github.hakkelt.ndarrays.internal that implement NDArray
Modifier and Type	Class	Description
`class`	`AbstractNDArray<T,T2 extends Number>`	Base class for all NDArrays and NDArray views.
`class`	`AbstractNDArrayMaskView<T,T2 extends Number>`
`class`	`AbstractNDArrayPermuteDimsView<T,T2 extends Number>`
`class`	`AbstractNDArrayReshapeView<T,T2 extends Number>`
`class`	`AbstractNDArraySliceView<T,T2 extends Number>`
`class`	`AbstractNDArrayView<T,T2 extends Number>`
`class`	`AbstractRealNDArray<T extends Number>`
`class`	`ComplexNDArrayMaskView<T extends Number>`	A view for a ComplexNDArray that selects values based on a specified mask.
`class`	`ComplexNDArrayPermuteDimsView<T extends Number>`	A view for a ComplexNDArray that permutes the order of dimensions.
`class`	`ComplexNDArrayReshapeView<T extends Number>`	A view for a ComplexNDArray that changes the shape of the parent NDArray.
`class`	`ComplexNDArraySliceView<T extends Number>`	A view for a ComplexNDArray that slices the parent ComplexNDArray.
`class`	`RealNDArrayMaskView<T extends Number>`	A view for an NDArray holding real values that selects values based on a specified mask.
`class`	`RealNDArrayPermuteDimsView<T extends Number>`	A view for an NDArray holding real values that permutes the order of dimensions.
`class`	`RealNDArrayReshapeView<T extends Number>`	A view for an NDArray holding real values that changes the shape of the parent NDArray.
`class`	`RealNDArraySliceView<T extends Number>`	A view for an NDArray holding real values that slices the parent NDArray.

Methods in io.github.hakkelt.ndarrays.internal that return NDArray
Modifier and Type	Method	Description
`NDArray<T>`	ComplexNDArrayMaskView.`abs()`
`NDArray<T>`	ComplexNDArrayPermuteDimsView.`abs()`
`NDArray<T>`	ComplexNDArrayReshapeView.`abs()`
`NDArray<T>`	ComplexNDArraySliceView.`abs()`
`default NDArray<T>`	RealNDArray.`accumulate(BinaryOperator<T> func, int... selectedDims)`
`NDArray<T>`	ArrayOperations.`add(AbstractNDArray<T,T2> me, Object... addends)`
`default NDArray<T>`	RealNDArray.`add(Object... addends)`
`NDArray<T>`	ArrayOperations.`addInplace(AbstractNDArray<T,T2> me, Object... addends)`
`default NDArray<T>`	RealNDArray.`addInplace(Object... addends)`
`NDArray<T>`	AbstractNDArray.`apply(UnaryOperator<T> func)`
`NDArray<T>`	AbstractNDArray.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayMaskView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayPermuteDimsView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayReshapeView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArraySliceView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`static <T> NDArray<T>`	SliceOperations.`applyOnSlices(NDArray<T> array, BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArray.`applyWithCartesianIndices(BiFunction<T,int[],T> func)`
`NDArray<T>`	AbstractNDArray.`applyWithLinearIndices(BiFunction<T,Integer,T> func)`
`NDArray<T>`	ComplexNDArrayMaskView.`argument()`
`NDArray<T>`	ComplexNDArrayPermuteDimsView.`argument()`
`NDArray<T>`	ComplexNDArrayReshapeView.`argument()`
`NDArray<T>`	ComplexNDArraySliceView.`argument()`
`NDArray<T>`	ArrayOperations.`concatenate(AbstractNDArray<T,T2> me, int axis, NDArray<?>... arrays)`
`default NDArray<T>`	RealNDArray.`concatenate(int axis, NDArray<?>... arrays)`
`NDArray<T>`	AbstractNDArray.`copy()`
`NDArray<T>`	AbstractNDArrayView.`copy()`
`NDArray<T>`	AbstractRealNDArray.`copyFrom(NDArray<?> array)`
`NDArray<T>`	CopyFromOperations.`copyFrom(AbstractNDArray<T,T2> me, byte[] array)`
`NDArray<T>`	CopyFromOperations.`copyFrom(AbstractNDArray<T,T2> me, double[] array)`
`NDArray<T>`	CopyFromOperations.`copyFrom(AbstractNDArray<T,T2> me, float[] array)`
`NDArray<T>`	CopyFromOperations.`copyFrom(AbstractNDArray<T,T2> me, int[] array)`
`NDArray<T>`	CopyFromOperations.`copyFrom(AbstractNDArray<T,T2> me, long[] array)`
`NDArray<T>`	CopyFromOperations.`copyFrom(AbstractNDArray<T,T2> me, short[] array)`
`NDArray<T>`	CopyFromOperations.`copyFrom(AbstractNDArray<T,T2> me, Object[] array)`
`NDArray<T2>`	CopyFromOperations.`copyFrom(RealNDArray<T2> me, NDArray<?> array)`
`default NDArray<T>`	RealNDArray.`copyFrom(byte[] array)`
`default NDArray<T>`	RealNDArray.`copyFrom(double[] array)`
`default NDArray<T>`	RealNDArray.`copyFrom(float[] array)`
`default NDArray<T>`	RealNDArray.`copyFrom(int[] array)`
`default NDArray<T>`	RealNDArray.`copyFrom(long[] array)`
`default NDArray<T>`	RealNDArray.`copyFrom(short[] array)`
`default NDArray<T>`	RealNDArray.`copyFrom(Object[] array)`
`NDArray<T>`	RealNDArrayMaskView.`copyFrom(NDArray<?> array)`
`NDArray<T>`	RealNDArrayPermuteDimsView.`copyFrom(NDArray<?> array)`
`NDArray<T>`	RealNDArrayReshapeView.`copyFrom(NDArray<?> array)`
`NDArray<T>`	RealNDArraySliceView.`copyFrom(NDArray<?> array)`
`NDArray<T>`	ArrayOperations.`divide(AbstractNDArray<T,T2> me, Object... divisors)`
`default NDArray<T>`	RealNDArray.`divide(Object... divisor)`
`NDArray<T>`	ArrayOperations.`divideInplace(AbstractNDArray<T,T2> me, Object... divisors)`
`default NDArray<T>`	RealNDArray.`divideInplace(Object... divisor)`
`default NDArray<T>`	RealNDArray.`dropDims(int... selectedDims)`
`NDArray<T>`	ViewOperations.`dropDims(AbstractNDArray<T,T2> me, int... droppedDims)`
`NDArray<T>`	ArrayOperations.`fill(AbstractNDArray<T,T2> me, double value)`
`NDArray<T>`	ArrayOperations.`fill(AbstractNDArray<T,T2> me, T value)`
`default NDArray<T>`	RealNDArray.`fill(double value)`
`default NDArray<T>`	RealNDArray.`fill(T value)`
`NDArray<T>`	AbstractNDArray.`fillUsingCartesianIndices(Function<int[],T> func)`
`NDArray<T>`	AbstractNDArray.`fillUsingLinearIndices(IntFunction<T> func)`
`NDArray<T>`	ComplexNDArrayMaskView.`imaginary()`
`NDArray<T>`	ComplexNDArrayPermuteDimsView.`imaginary()`
`NDArray<T>`	ComplexNDArrayReshapeView.`imaginary()`
`NDArray<T>`	ComplexNDArraySliceView.`imaginary()`
`NDArray<T2>`	ViewOperations.`internalSlice(RealNDArray<T2> me, NormalizedRange[] slicingExpressions)`
`default NDArray<T>`	RealNDArray.`inverseMask(NDArray<?> mask)`
`default NDArray<T>`	RealNDArray.`map(UnaryOperator<T> func)`
`NDArray<T>`	AbstractNDArray.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayMaskView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayPermuteDimsView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayReshapeView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArraySliceView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`default NDArray<T>`	RealNDArray.`mapWithCartesianIndices(BiFunction<T,int[],T> func)`
`default NDArray<T>`	RealNDArray.`mapWithLinearIndices(BiFunction<T,Integer,T> func)`
`default NDArray<T>`	RealNDArray.`mask(NDArray<?> mask)`
`default NDArray<T>`	RealNDArray.`mask(Predicate<T> func)`
`NDArray<T2>`	ViewOperations.`mask(RealNDArray<T2> me, NDArray<?> mask, boolean isInverse)`
`NDArray<T2>`	ViewOperations.`mask(RealNDArray<T2> me, BiPredicate<T2,?> func, boolean withLinearIndices)`
`NDArray<T2>`	ViewOperations.`mask(RealNDArray<T2> me, Predicate<T2> func)`
`default NDArray<T>`	RealNDArray.`maskWithCartesianIndices(BiPredicate<T,int[]> func)`
`default NDArray<T>`	RealNDArray.`maskWithLinearIndices(BiPredicate<T,Integer> func)`
`NDArray<T>`	ArrayOperations.`multiply(AbstractNDArray<T,T2> me, Object... multiplicands)`
`default NDArray<T>`	RealNDArray.`multiply(Object... multiplicand)`
`NDArray<T>`	ArrayOperations.`multiplyInplace(AbstractNDArray<T,T2> me, Object... multiplicands)`
`default NDArray<T>`	RealNDArray.`multiplyInplace(Object... multiplicand)`
`default NDArray<T>`	RealNDArray.`permuteDims(int... permutation)`
`NDArray<T2>`	ViewOperations.`permuteDims(RealNDArray<T2> me, int... permutation)`
`default NDArray<T>`	RealNDArray.`prod(int... selectedDims)`
`NDArray<T>`	ComplexNDArrayMaskView.`real()`
`NDArray<T>`	ComplexNDArrayPermuteDimsView.`real()`
`NDArray<T>`	ComplexNDArrayReshapeView.`real()`
`NDArray<T>`	ComplexNDArraySliceView.`real()`
`NDArray<T>`	AbstractNDArray.`reduceSlices(BiFunction<NDArray<T>,int[],T> func, int... iterationDims)`
`static <T> NDArray<T>`	SliceOperations.`reduceSlices(NDArray<T> array, BiFunction<NDArray<T>,int[],T> func, int... reducedDims)`
`default NDArray<T>`	RealNDArray.`reshape(int... newShape)`
`NDArray<T2>`	ViewOperations.`reshape(RealNDArray<T2> me, int... newShape)`
`default NDArray<T>`	RealNDArray.`selectDims(int... selectedDims)`
`NDArray<T>`	ViewOperations.`selectDims(AbstractNDArray<T,T2> me, int... selectedDims)`
`NDArray<T>`	AbstractNDArray.`similar()`
`NDArray<T>`	AbstractNDArrayView.`similar()`
`default NDArray<T>`	RealNDArray.`slice(Object... slicingExpressions)`
`NDArray<T2>`	ViewOperations.`slice(RealNDArray<T2> me, Object... slicingExpressions)`
`default NDArray<T>`	RealNDArray.`squeeze()`
`NDArray<T>`	ViewOperations.`squeeze(AbstractNDArray<T,T2> me)`
`NDArray<T>`	ArrayOperations.`subtract(AbstractNDArray<T,T2> me, Object... substrahends)`
`default NDArray<T>`	RealNDArray.`subtract(Object... substrahends)`
`NDArray<T>`	ArrayOperations.`subtractInplace(AbstractNDArray<T,T2> me, Object... substrahends)`
`default NDArray<T>`	RealNDArray.`subtractInplace(Object... substrahends)`
`default NDArray<T>`	RealNDArray.`sum(int... selectedDims)`

Methods in io.github.hakkelt.ndarrays.internal that return types with arguments of type NDArray
Modifier and Type	Method	Description
`Function<List<Object>,NDArray<org.apache.commons.math3.complex.Complex>>`	ComplexNDArrayCollector.`finisher()`
`Function<List<Object>,NDArray<T>>`	RealNDArrayCollector.`finisher()`

Methods in io.github.hakkelt.ndarrays.internal with parameters of type NDArray
Modifier and Type	Method	Description
`static <T> NDArray<T>`	SliceOperations.`applyOnSlices(NDArray<T> array, BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T2>`	ArrayOperations.`concatenate(ComplexNDArray<T2> me, int axis, NDArray<?>... arrays)`
`NDArray<T>`	ArrayOperations.`concatenate(AbstractNDArray<T,T2> me, int axis, NDArray<?>... arrays)`
`default NDArray<T>`	RealNDArray.`concatenate(int axis, NDArray<?>... arrays)`
`NDArray<T>`	AbstractRealNDArray.`copyFrom(NDArray<?> array)`
`ComplexNDArray<T2>`	CopyFromOperations.`copyFrom(ComplexNDArray<T2> me, NDArray<?> array)`
`ComplexNDArray<T2>`	CopyFromOperations.`copyFrom(ComplexNDArray<T2> me, NDArray<? extends Number> real, NDArray<? extends Number> imag)`
`NDArray<T2>`	CopyFromOperations.`copyFrom(RealNDArray<T2> me, NDArray<?> array)`
`NDArray<T>`	RealNDArrayMaskView.`copyFrom(NDArray<?> array)`
`NDArray<T>`	RealNDArrayPermuteDimsView.`copyFrom(NDArray<?> array)`
`NDArray<T>`	RealNDArrayReshapeView.`copyFrom(NDArray<?> array)`
`NDArray<T>`	RealNDArraySliceView.`copyFrom(NDArray<?> array)`
`ComplexNDArray<T2>`	CopyFromOperations.`copyFromMagnitudePhase(ComplexNDArray<T2> me, NDArray<? extends Number> magnitude, NDArray<? extends Number> phase)`
`default NDArray<T>`	RealNDArray.`inverseMask(NDArray<?> mask)`
`static boolean`	ViewOperations.`isThisSlicingAnIdentityOperation(NDArray<?> me, NormalizedRange[] slicingExpressions)`
`default NDArray<T>`	RealNDArray.`mask(NDArray<?> mask)`
`ComplexNDArray<T2>`	ViewOperations.`mask(ComplexNDArray<T2> me, NDArray<?> mask, boolean isInverse)`
`NDArray<T2>`	ViewOperations.`mask(RealNDArray<T2> me, NDArray<?> mask, boolean isInverse)`
`static <T> NDArray<T>`	SliceOperations.`reduceSlices(NDArray<T> array, BiFunction<NDArray<T>,int[],T> func, int... reducedDims)`

Method parameters in io.github.hakkelt.ndarrays.internal with type arguments of type NDArray
Modifier and Type	Method	Description
`ComplexNDArray<T>`	ComplexNDArrayMaskView.`applyOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T>`	ComplexNDArrayPermuteDimsView.`applyOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T>`	ComplexNDArrayReshapeView.`applyOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T>`	ComplexNDArraySliceView.`applyOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArray.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArray.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayMaskView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayMaskView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayPermuteDimsView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayPermuteDimsView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayReshapeView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayReshapeView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArraySliceView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArraySliceView.`applyOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`static <T extends Number> ComplexNDArray<T>`	SliceOperations.`applyOnSlices(ComplexNDArray<T> array, BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`static <T> NDArray<T>`	SliceOperations.`applyOnSlices(NDArray<T> array, BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`static <T> NDArray<T>`	SliceOperations.`applyOnSlices(NDArray<T> array, BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T>`	ComplexNDArrayMaskView.`mapOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T>`	ComplexNDArrayPermuteDimsView.`mapOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T>`	ComplexNDArrayReshapeView.`mapOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`ComplexNDArray<T>`	ComplexNDArraySliceView.`mapOnComplexSlices(BiFunction<ComplexNDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArray.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArray.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayMaskView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayMaskView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayPermuteDimsView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayPermuteDimsView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayReshapeView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArrayReshapeView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArraySliceView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArraySliceView.`mapOnSlices(BiFunction<NDArray<T>,int[],NDArray<?>> func, int... iterationDims)`
`NDArray<T>`	AbstractNDArray.`reduceSlices(BiFunction<NDArray<T>,int[],T> func, int... iterationDims)`
`static <T> NDArray<T>`	SliceOperations.`reduceSlices(NDArray<T> array, BiFunction<NDArray<T>,int[],T> func, int... reducedDims)`

Constructors in io.github.hakkelt.ndarrays.internal with parameters of type NDArray
Constructor	Description
`ComplexNDArrayMaskView(NDArray<org.apache.commons.math3.complex.Complex> parent, NDArray<?> mask, boolean isInverse)`
`ComplexNDArrayMaskView(NDArray<org.apache.commons.math3.complex.Complex> parent, BiPredicate<org.apache.commons.math3.complex.Complex,?> func, boolean withLinearIndices)`
`ComplexNDArrayMaskView(NDArray<org.apache.commons.math3.complex.Complex> parent, Predicate<org.apache.commons.math3.complex.Complex> func)`
`ComplexNDArrayPermuteDimsView(NDArray<org.apache.commons.math3.complex.Complex> parent, int... dimsOrder)`
`ComplexNDArrayReshapeView(NDArray<org.apache.commons.math3.complex.Complex> parent, int... newShape)`
`ComplexNDArraySliceView(NDArray<org.apache.commons.math3.complex.Complex> parent, Range[] slicingExpressions)`
`RealNDArrayCollector(NDArray<T> destination)`
`RealNDArrayMaskView(NDArray<T> parent, NDArray<?> mask, boolean isInverse)`
`RealNDArrayMaskView(NDArray<T> parent, BiPredicate<T,?> func, boolean withLinearIndices)`
`RealNDArrayMaskView(NDArray<T> parent, Predicate<T> func)`
`RealNDArrayPermuteDimsView(NDArray<T> parent, int... dimsOrder)`
`RealNDArrayReshapeView(NDArray<T> parent, int... newShape)`
`RealNDArraySliceView(NDArray<T> parent, NormalizedRange[] slicingExpressions)`

Uses of Interfaceio.github.hakkelt.ndarrays.NDArray

Uses of NDArray in io.github.hakkelt.ndarrays

Uses of NDArray in io.github.hakkelt.ndarrays.basic

Uses of NDArray in io.github.hakkelt.ndarrays.internal

Uses of Interface
io.github.hakkelt.ndarrays.NDArray