api / koma.extensions

Package koma.extensions

Extensions for External Classes

Name Summary
kotlin.Double
kotlin.Int

Functions

Name Summary
all funMatrix<Double>.all(f: (Double) ->Boolean):Boolean
funMatrix<Float>.all(f: (Float) ->Boolean):Boolean
fun <T>Matrix<T>.all(f: (T) ->Boolean):Boolean
funMatrix<Int>.all(f: (Int) ->Boolean):Boolean
Checks to see if all elements cause f to return true.
allClose funMatrix<Double>.allClose(other:Matrix<Double>, rtol:Double= 1e-05, atol:Double= 1e-08):Boolean
funMatrix<Float>.allClose(other:Matrix<Float>, rtol:Double= 1e-05, atol:Double= 1e-08):Boolean
any funMatrix<Double>.any(f: (Double) ->Boolean):Boolean
funMatrix<Float>.any(f: (Float) ->Boolean):Boolean
fun <T>Matrix<T>.any(f: (T) ->Boolean):Boolean
funMatrix<Int>.any(f: (Int) ->Boolean):Boolean
Checks to see if any element in the matrix causes f to return true.
create funNumericalNDArrayFactory<Byte>.create(vararg lengths:Int, filler: (idx:IntArray) ->Byte):NDArray<Byte>
funNumericalNDArrayFactory<Double>.create(vararg lengths:Int, filler: (idx:IntArray) ->Double):NDArray<Double>
funNumericalNDArrayFactory<Float>.create(vararg lengths:Int, filler: (idx:IntArray) ->Float):NDArray<Float>
fun <T>GenericNDArrayFactory<T>.create(vararg lengths:Int, filler: (idx:IntArray) ->T):DefaultGenericNDArray<T>
funNumericalNDArrayFactory<Int>.create(vararg lengths:Int, filler: (idx:IntArray) ->Int):NDArray<Int>
funNumericalNDArrayFactory<Long>.create(vararg lengths:Int, filler: (idx:IntArray) ->Long):NDArray<Long>
funNumericalNDArrayFactory<Short>.create(vararg lengths:Int, filler: (idx:IntArray) ->Short):NDArray<Short>
div operator funNDArray<Byte>.div(other:Byte):NDArray<Byte>
operator funNDArray<Double>.div(other:Double):NDArray<Double>
operator funNDArray<Float>.div(other:Float):NDArray<Float>
operator funNDArray<Int>.div(other:Int):NDArray<Int>
operator funNDArray<Long>.div(other:Long):NDArray<Long>
operator funNDArray<Short>.div(other:Short):NDArray<Short>
emul infix funMatrix<Double>.emul(other:Matrix<Double>):Matrix<Double>
Allow infix operator "a emul b" to be element-wise multiplication of two matrices.
fill funMatrix<Double>.fill(f: (row:Int, col:Int) ->Double):Matrix<Double>
funMatrix<Float>.fill(f: (row:Int, col:Int) ->Float):Matrix<Float>
fun <T>Matrix<T>.fill(f: (row:Int, col:Int) ->T):Matrix<T>
funMatrix<Int>.fill(f: (row:Int, col:Int) ->Int):Matrix<Int>
Fills the matrix with the values returned by the input function.funNDArray<Byte>.fill(f: (idx:IntArray) ->Byte):NDArray<Byte>
funNDArray<Double>.fill(f: (idx:IntArray) ->Double):NDArray<Double>
funNDArray<Float>.fill(f: (idx:IntArray) ->Float):NDArray<Float>
fun <T>NDArray<T>.fill(f: (idx:IntArray) ->T):NDArray<T>
funNDArray<Int>.fill(f: (idx:IntArray) ->Int):NDArray<Int>
funNDArray<Long>.fill(f: (idx:IntArray) ->Long):NDArray<Long>
funNDArray<Short>.fill(f: (idx:IntArray) ->Short):NDArray<Short>
fillBoth funNDArray<Byte>.fillBoth(f: (nd:IntArray, linear:Int) ->Byte):NDArray<Byte>
funNDArray<Double>.fillBoth(f: (nd:IntArray, linear:Int) ->Double):NDArray<Double>
funNDArray<Float>.fillBoth(f: (nd:IntArray, linear:Int) ->Float):NDArray<Float>
fun <T>NDArray<T>.fillBoth(f: (nd:IntArray, linear:Int) ->T):NDArray<T>
funNDArray<Int>.fillBoth(f: (nd:IntArray, linear:Int) ->Int):NDArray<Int>
funNDArray<Long>.fillBoth(f: (nd:IntArray, linear:Int) ->Long):NDArray<Long>
funNDArray<Short>.fillBoth(f: (nd:IntArray, linear:Int) ->Short):NDArray<Short>
fillLinear funNDArray<Byte>.fillLinear(f: (idx:Int) ->Byte):NDArray<Byte>
funNDArray<Double>.fillLinear(f: (idx:Int) ->Double):NDArray<Double>
funNDArray<Float>.fillLinear(f: (idx:Int) ->Float):NDArray<Float>
fun <T>NDArray<T>.fillLinear(f: (idx:Int) ->T):NDArray<T>
funNDArray<Int>.fillLinear(f: (idx:Int) ->Int):NDArray<Int>
funNDArray<Long>.fillLinear(f: (idx:Int) ->Long):NDArray<Long>
funNDArray<Short>.fillLinear(f: (idx:Int) ->Short):NDArray<Short>
forEach funMatrix<Double>.forEach(f: (Double) ->Unit):Unit
funMatrix<Float>.forEach(f: (Float) ->Unit):Unit
fun <T>Matrix<T>.forEach(f: (T) ->Unit):Unit
funMatrix<Int>.forEach(f: (Int) ->Unit):Unit
Passes each element in row major order into a function.funNDArray<Byte>.forEach(f: (ele:Byte) ->Unit):Unit
funNDArray<Double>.forEach(f: (ele:Double) ->Unit):Unit
funNDArray<Float>.forEach(f: (ele:Float) ->Unit):Unit
fun <T>NDArray<T>.forEach(f: (ele:T) ->Unit):Unit
funNDArray<Int>.forEach(f: (ele:Int) ->Unit):Unit
funNDArray<Long>.forEach(f: (ele:Long) ->Unit):Unit
funNDArray<Short>.forEach(f: (ele:Short) ->Unit):Unit
Takes each element in a NDArray and passes them through f.
forEachIndexed funMatrix<Double>.forEachIndexed(f: (row:Int, col:Int, ele:Double) ->Unit):Unit
funMatrix<Float>.forEachIndexed(f: (row:Int, col:Int, ele:Float) ->Unit):Unit
fun <T>Matrix<T>.forEachIndexed(f: (row:Int, col:Int, ele:T) ->Unit):Unit
funMatrix<Int>.forEachIndexed(f: (row:Int, col:Int, ele:Int) ->Unit):Unit
Passes each element in row major order into a function along with its index location.funNDArray<Byte>.forEachIndexed(f: (idx:Int, ele:Byte) ->Unit):Unit
funNDArray<Double>.forEachIndexed(f: (idx:Int, ele:Double) ->Unit):Unit
funNDArray<Float>.forEachIndexed(f: (idx:Int, ele:Float) ->Unit):Unit
fun <T>NDArray<T>.forEachIndexed(f: (idx:Int, ele:T) ->Unit):Unit
funNDArray<Int>.forEachIndexed(f: (idx:Int, ele:Int) ->Unit):Unit
funNDArray<Long>.forEachIndexed(f: (idx:Int, ele:Long) ->Unit):Unit
funNDArray<Short>.forEachIndexed(f: (idx:Int, ele:Short) ->Unit):Unit
Takes each element in a NDArray and passes them through f. Index given to f is a linear index, depending on the underlying storage major dimension.
forEachIndexedN funNDArray<Byte>.forEachIndexedN(f: (idx:IntArray, ele:Byte) ->Unit):Unit
funNDArray<Double>.forEachIndexedN(f: (idx:IntArray, ele:Double) ->Unit):Unit
funNDArray<Float>.forEachIndexedN(f: (idx:IntArray, ele:Float) ->Unit):Unit
fun <T>NDArray<T>.forEachIndexedN(f: (idx:IntArray, ele:T) ->Unit):Unit
funNDArray<Int>.forEachIndexedN(f: (idx:IntArray, ele:Int) ->Unit):Unit
funNDArray<Long>.forEachIndexedN(f: (idx:IntArray, ele:Long) ->Unit):Unit
funNDArray<Short>.forEachIndexedN(f: (idx:IntArray, ele:Short) ->Unit):Unit
Takes each element in a NDArray and passes them through f. Index given to f is the full ND index of the element.
get operator funMatrix<Double>.get(i:Int, j:Int):Double
operator funMatrix<Float>.get(i:Int, j:Int):Float
operator fun <T>Matrix<T>.get(i:Int, j:Int):T
operator funMatrix<Int>.get(i:Int, j:Int):Int
operator funNDArray<Byte>.get(vararg indices:IntRange):NDArray<Byte>
operator funNDArray<Byte>.get(vararg indices:Int):Byte
operator funNDArray<Double>.get(vararg indices:IntRange):NDArray<Double>
operator funNDArray<Double>.get(vararg indices:Int):Double
operator funNDArray<Float>.get(vararg indices:IntRange):NDArray<Float>
operator funNDArray<Float>.get(vararg indices:Int):Float
operator fun <T>NDArray<T>.get(vararg indices:IntRange):NDArray<T>
operator fun <T>NDArray<T>.get(vararg indices:Int):T
operator funNDArray<Int>.get(vararg indices:IntRange):NDArray<Int>
operator funNDArray<Int>.get(vararg indices:Int):Int
operator funNDArray<Long>.get(vararg indices:IntRange):NDArray<Long>
operator funNDArray<Long>.get(vararg indices:Int):Long
operator funNDArray<Short>.get(vararg indices:IntRange):NDArray<Short>
operator funNDArray<Short>.get(vararg indices:Int):Shortoperator funMatrix<Double>.get(i:Int):Double
operator funMatrix<Float>.get(i:Int):Float
operator fun <T>Matrix<T>.get(i:Int):T
operator funMatrix<Int>.get(i:Int):Int
Gets the ith element in the matrix. If 2D, selects elements in row-major order.operator funMatrix<Double>.get(rows:IntRange, cols:IntRange):Matrix<Double>
operator funMatrix<Float>.get(rows:IntRange, cols:IntRange):Matrix<Float>
operator fun <T>Matrix<T>.get(rows:IntRange, cols:IntRange):Matrix<T>
operator funMatrix<Int>.get(rows:IntRange, cols:IntRange):Matrix<Int>
Allow slicing, e.g. matrix[1..2, 3..4]. Note that the range 1..2 is inclusive, so it will retrieve row 1 and 2. Use 1.until(2) for a non-inclusive range.operator funMatrix<Double>.get(rows:IntRange, cols:Int):Matrix<Double>
operator funMatrix<Float>.get(rows:IntRange, cols:Int):Matrix<Float>
operator fun <T>Matrix<T>.get(rows:IntRange, cols:Int):Matrix<T>
operator funMatrix<Int>.get(rows:IntRange, cols:Int):Matrix<Int>
Allows for slicing of the rows and selection of a single columnoperator funMatrix<Double>.get(rows:Int, cols:IntRange):Matrix<Double>
operator funMatrix<Float>.get(rows:Int, cols:IntRange):Matrix<Float>
operator fun <T>Matrix<T>.get(rows:Int, cols:IntRange):Matrix<T>
operator funMatrix<Int>.get(rows:Int, cols:IntRange):Matrix<Int>
Allows for slicing of the cols and selection of a single row
map funMatrix<Double>.map(f: (Double) ->Double):Matrix<Double>
funMatrix<Float>.map(f: (Float) ->Float):Matrix<Float>
fun <T>Matrix<T>.map(f: (T) ->T):Matrix<T>
funMatrix<Int>.map(f: (Int) ->Int):Matrix<Int>
Takes each element in a matrix, passes them through f, and puts the output of f into an output matrix. This process is done in row-major order.funNDArray<Byte>.map(f: (Byte) ->Byte):NDArray<Byte>
funNDArray<Double>.map(f: (Double) ->Double):NDArray<Double>
funNDArray<Float>.map(f: (Float) ->Float):NDArray<Float>
fun <T>NDArray<T>.map(f: (T) ->T):DefaultGenericNDArray<T>
funNDArray<Int>.map(f: (Int) ->Int):NDArray<Int>
funNDArray<Long>.map(f: (Long) ->Long):NDArray<Long>
funNDArray<Short>.map(f: (Short) ->Short):NDArray<Short>
Takes each element in a NDArray, passes them through f, and puts the output of f into an output NDArray.
mapIndexed funMatrix<Double>.mapIndexed(f: (row:Int, col:Int, ele:Double) ->Double):Matrix<Double>
funMatrix<Float>.mapIndexed(f: (row:Int, col:Int, ele:Float) ->Float):Matrix<Float>
fun <T>Matrix<T>.mapIndexed(f: (row:Int, col:Int, ele:T) ->T):Matrix<T>
funMatrix<Int>.mapIndexed(f: (row:Int, col:Int, ele:Int) ->Int):Matrix<Int>
Takes each element in a matrix, passes them through f, and puts the output of f into an output matrix. This process is done in row-major order.funNDArray<Byte>.mapIndexed(f: (idx:Int, ele:Byte) ->Byte):NDArray<Byte>
funNDArray<Double>.mapIndexed(f: (idx:Int, ele:Double) ->Double):NDArray<Double>
funNDArray<Float>.mapIndexed(f: (idx:Int, ele:Float) ->Float):NDArray<Float>
fun <T>NDArray<T>.mapIndexed(f: (idx:Int, ele:T) ->T):DefaultGenericNDArray<T>
funNDArray<Int>.mapIndexed(f: (idx:Int, ele:Int) ->Int):NDArray<Int>
funNDArray<Long>.mapIndexed(f: (idx:Int, ele:Long) ->Long):NDArray<Long>
funNDArray<Short>.mapIndexed(f: (idx:Int, ele:Short) ->Short):NDArray<Short>
Takes each element in a NDArray, passes them through f, and puts the output of f into an output NDArray. Index given to f is a linear index, depending on the underlying storage major dimension.
mapIndexedN funNDArray<Byte>.mapIndexedN(f: (idx:IntArray, ele:Byte) ->Byte):NDArray<Byte>
funNDArray<Double>.mapIndexedN(f: (idx:IntArray, ele:Double) ->Double):NDArray<Double>
funNDArray<Float>.mapIndexedN(f: (idx:IntArray, ele:Float) ->Float):NDArray<Float>
fun <T>NDArray<T>.mapIndexedN(f: (idx:IntArray, ele:T) ->T):NDArray<T>
funNDArray<Int>.mapIndexedN(f: (idx:IntArray, ele:Int) ->Int):NDArray<Int>
funNDArray<Long>.mapIndexedN(f: (idx:IntArray, ele:Long) ->Long):NDArray<Long>
funNDArray<Short>.mapIndexedN(f: (idx:IntArray, ele:Short) ->Short):NDArray<Short>
Takes each element in a NDArray, passes them through f, and puts the output of f into an output NDArray. Index given to f is the full ND index of the element.
minus operator funNDArray<Byte>.minus(other:Byte):NDArray<Byte>
operator funNDArray<Byte>.minus(other:NDArray<Byte>):NDArray<Byte>
operator funNDArray<Double>.minus(other:Double):NDArray<Double>
operator funNDArray<Double>.minus(other:NDArray<Double>):NDArray<Double>
operator funNDArray<Float>.minus(other:Float):NDArray<Float>
operator funNDArray<Float>.minus(other:NDArray<Float>):NDArray<Float>
operator funNDArray<Int>.minus(other:Int):NDArray<Int>
operator funNDArray<Int>.minus(other:NDArray<Int>):NDArray<Int>
operator funNDArray<Long>.minus(other:Long):NDArray<Long>
operator funNDArray<Long>.minus(other:NDArray<Long>):NDArray<Long>
operator funNDArray<Short>.minus(other:Short):NDArray<Short>
operator funNDArray<Short>.minus(other:NDArray<Short>):NDArray<Short>``operator funMatrix<Double>.minus(value:Int):Matrix<Double>
Allow operator overloading with non-Double scalars
plus operator funNDArray<Byte>.plus(other:Byte):NDArray<Byte>
operator funNDArray<Byte>.plus(other:NDArray<Byte>):NDArray<Byte>
operator funNDArray<Double>.plus(other:Double):NDArray<Double>
operator funNDArray<Double>.plus(other:NDArray<Double>):NDArray<Double>
operator funNDArray<Float>.plus(other:Float):NDArray<Float>
operator funNDArray<Float>.plus(other:NDArray<Float>):NDArray<Float>
operator funNDArray<Int>.plus(other:Int):NDArray<Int>
operator funNDArray<Int>.plus(other:NDArray<Int>):NDArray<Int>
operator funNDArray<Long>.plus(other:Long):NDArray<Long>
operator funNDArray<Long>.plus(other:NDArray<Long>):NDArray<Long>
operator funNDArray<Short>.plus(other:Short):NDArray<Short>
operator funNDArray<Short>.plus(other:NDArray<Short>):NDArray<Short>``operator funMatrix<Double>.plus(value:Int):Matrix<Double>
Allow operator overloading with non-Double scalars
pow infix funNDArray<Byte>.pow(exponent:Int):NDArray<Byte>
infix funNDArray<Double>.pow(exponent:Int):NDArray<Double>
infix funNDArray<Float>.pow(exponent:Int):NDArray<Float>
infix funNDArray<Int>.pow(exponent:Int):NDArray<Int>
infix funNDArray<Long>.pow(exponent:Int):NDArray<Long>
infix funNDArray<Short>.pow(exponent:Int):NDArray<Short>
reshape funNDArray<Double>.reshape(rows:Int, cols:Int):Matrix<Double>
funNDArray<Float>.reshape(rows:Int, cols:Int):Matrix<Float>
fun <T>Matrix<T>.reshape(rows:Int, cols:Int):Matrix<T>
funNDArray<Int>.reshape(rows:Int, cols:Int):Matrix<Int>
Returns a new Matrix with the given shape, populated with the data in this array.funNDArray<Byte>.reshape(vararg dims:Int):NDArray<Byte>
funNDArray<Double>.reshape(vararg dims:Int):NDArray<Double>
funNDArray<Float>.reshape(vararg dims:Int):NDArray<Float>
fun <T>NDArray<T>.reshape(vararg dims:Int):NDArray<T>
funNDArray<Int>.reshape(vararg dims:Int):NDArray<Int>
funNDArray<Long>.reshape(vararg dims:Int):NDArray<Long>
funNDArray<Short>.reshape(vararg dims:Int):NDArray<Short>
Returns a new NDArray with the given shape, populated with the data in this array.
set operator funMatrix<Double>.set(i:Int, v:Double):Unit
operator funMatrix<Float>.set(i:Int, v:Float):Unit
operator fun <T>Matrix<T>.set(i:Int, v:T):Unit
operator funMatrix<Int>.set(i:Int, v:Int):Unit
Set the ith element in the matrix. If 2D, selects elements in row-major order.operator funMatrix<Double>.set(i:Int, j:Int, v:Double):Unit
operator funMatrix<Double>.set(rows:IntRange, cols:IntRange, value:Double):Unit
operator funMatrix<Double>.set(rows:Int, cols:IntRange, value:Double):Unit
operator funMatrix<Double>.set(rows:IntRange, cols:Int, value:Double):Unit
operator funMatrix<Double>.set(i:Int, v:Int):Unit
operator funMatrix<Double>.set(i:Int, j:Int, v:Int):Unit
operator funMatrix<Float>.set(i:Int, j:Int, v:Float):Unit
operator funMatrix<Float>.set(rows:IntRange, cols:IntRange, value:Float):Unit
operator funMatrix<Float>.set(rows:Int, cols:IntRange, value:Float):Unit
operator funMatrix<Float>.set(rows:IntRange, cols:Int, value:Float):Unit
operator funMatrix<Float>.set(i:Int, v:Int):Unit
operator funMatrix<Float>.set(i:Int, j:Int, v:Int):Unit
operator fun <T>Matrix<T>.set(i:Int, j:Int, v:T):Unit
operator fun <T>Matrix<T>.set(rows:IntRange, cols:IntRange, value:T):Unit
operator fun <T>Matrix<T>.set(rows:Int, cols:IntRange, value:T):Unit
operator fun <T>Matrix<T>.set(rows:IntRange, cols:Int, value:T):Unit
operator funMatrix<Int>.set(i:Int, j:Int, v:Int):Unit
operator funMatrix<Int>.set(rows:IntRange, cols:IntRange, value:Int):Unit
operator funMatrix<Int>.set(rows:Int, cols:IntRange, value:Int):Unit
operator funMatrix<Int>.set(rows:IntRange, cols:Int, value:Int):Unit
operator funNDArray<Byte>.set(vararg indices:Int, value:NDArray<Byte>):Unit
operator funNDArray<Byte>.set(vararg indices:Int, value:Byte):Unit
operator funNDArray<Double>.set(vararg indices:Int, value:NDArray<Double>):Unit
operator funNDArray<Double>.set(vararg indices:Int, value:Double):Unit
operator funNDArray<Float>.set(vararg indices:Int, value:NDArray<Float>):Unit
operator funNDArray<Float>.set(vararg indices:Int, value:Float):Unit
operator fun <T>NDArray<T>.set(vararg indices:Int, value:NDArray<T>):Unit
operator fun <T>NDArray<T>.set(vararg indices:Int, value:T):Unit
operator funNDArray<Int>.set(vararg indices:Int, value:NDArray<Int>):Unit
operator funNDArray<Int>.set(vararg indices:Int, value:Int):Unit
operator funNDArray<Long>.set(vararg indices:Int, value:NDArray<Long>):Unit
operator funNDArray<Long>.set(vararg indices:Int, value:Long):Unit
operator funNDArray<Short>.set(vararg indices:Int, value:NDArray<Short>):Unit
operator funNDArray<Short>.set(vararg indices:Int, value:Short):Unitoperator funMatrix<Double>.set(rows:IntRange, cols:IntRange, value:Matrix<Double>):Unit
operator funMatrix<Float>.set(rows:IntRange, cols:IntRange, value:Matrix<Float>):Unit
operator fun <T>Matrix<T>.set(rows:IntRange, cols:IntRange, value:Matrix<T>):Unit
operator funMatrix<Int>.set(rows:IntRange, cols:IntRange, value:Matrix<Int>):Unit
Allow assignment to a slice, e.g. matrix[1..2, 3..4]=something. Note that the range 1..2 is inclusive, so it will retrieve row 1 and 2. Use 1.until(2) for a non-inclusive range.operator funMatrix<Double>.set(rows:Int, cols:IntRange, value:Matrix<Double>):Unit
operator funMatrix<Float>.set(rows:Int, cols:IntRange, value:Matrix<Float>):Unit
operator fun <T>Matrix<T>.set(rows:Int, cols:IntRange, value:Matrix<T>):Unit
operator funMatrix<Int>.set(rows:Int, cols:IntRange, value:Matrix<Int>):Unit
Allow assignment to a slice, e.g. matrix[2, 3..4]=something. Note that the range 3..4 is inclusive, so it will retrieve col 3 and 4. Use 1.until(2) for a non-inclusive range.operator funMatrix<Double>.set(rows:IntRange, cols:Int, value:Matrix<Double>):Unit
operator funMatrix<Float>.set(rows:IntRange, cols:Int, value:Matrix<Float>):Unit
operator fun <T>Matrix<T>.set(rows:IntRange, cols:Int, value:Matrix<T>):Unit
operator funMatrix<Int>.set(rows:IntRange, cols:Int, value:Matrix<Int>):Unit
Allow assignment to a slice, e.g. matrix[1..2, 3]=something. Note that the range 1..2 is inclusive, so it will retrieve row 1 and 2. Use 1.until(2) for a non-inclusive range.
times operator funNDArray<Byte>.times(other:NDArray<Byte>):NDArray<Byte>
operator funNDArray<Byte>.times(other:Byte):NDArray<Byte>
operator funNDArray<Double>.times(other:NDArray<Double>):NDArray<Double>
operator funNDArray<Double>.times(other:Double):NDArray<Double>
operator funNDArray<Float>.times(other:NDArray<Float>):NDArray<Float>
operator funNDArray<Float>.times(other:Float):NDArray<Float>
operator funNDArray<Int>.times(other:NDArray<Int>):NDArray<Int>
operator funNDArray<Int>.times(other:Int):NDArray<Int>
operator funNDArray<Long>.times(other:NDArray<Long>):NDArray<Long>
operator funNDArray<Long>.times(other:Long):NDArray<Long>
operator funNDArray<Short>.times(other:NDArray<Short>):NDArray<Short>
operator funNDArray<Short>.times(other:Short):NDArray<Short>``operator funMatrix<Double>.times(other:Int):Matrix<Double>
Multiply a scalar by a matrix
toByteArray funNDArray<Byte>.toByteArray():ByteArray
Converts this NDArray into a one-dimensional ByteArray in row-major order.
toDoubleArray funNDArray<Double>.toDoubleArray():DoubleArray
Converts this NDArray into a one-dimensional DoubleArray in row-major order.
toFloatArray funNDArray<Float>.toFloatArray():FloatArray
Converts this NDArray into a one-dimensional FloatArray in row-major order.
toIntArray funNDArray<Int>.toIntArray():IntArray
Converts this NDArray into a one-dimensional IntArray in row-major order.
toLongArray funNDArray<Long>.toLongArray():LongArray
Converts this NDArray into a one-dimensional LongArray in row-major order.
toMatrix funNDArray<Double>.toMatrix():Matrix<Double>
funNDArray<Float>.toMatrix():Matrix<Float>
funNDArray<Int>.toMatrix():Matrix<Int>
toMatrixOrNull fun <T>NDArray<T>.toMatrixOrNull():Matrix<T>?
toShortArray funNDArray<Short>.toShortArray():ShortArray
Converts this NDArray into a one-dimensional ShortArray in row-major order.
toTypedArray fun <T>NDArray<T>.toTypedArray():Array<T>
Converts this NDArray into a one-dimensional Array in row-major order.
unaryMinus operator funNDArray<Byte>.unaryMinus():NDArray<Byte>
operator funNDArray<Double>.unaryMinus():NDArray<Double>
operator funNDArray<Float>.unaryMinus():NDArray<Float>
operator funNDArray<Int>.unaryMinus():NDArray<Int>
operator funNDArray<Long>.unaryMinus():NDArray<Long>
operator funNDArray<Short>.unaryMinus():NDArray<Short>