ndarray-simd/com.martmists.ndarray.simd/F64Array/Companion

Companion

object Companion

Properties

equalNan

var equalNan: Boolean

Whether or not nan == nan for eq/neq.

simdSize

val simdSize: Int

The minimum size of a flat array to use SIMD operations. Depends on the System, but usually 8 or 16.

tolerance

var tolerance: Pair<Double, Double>

The relative and absolute tolerance for eq/neq. This is implemented similar to numpy: absolute(a - b) <= (atol + rtol * absolute(b))

Functions

concat

@JvmStatic

@JvmOverloads

fun concat(first: F64Array, vararg rest: F64Array, axis: Int = 0): F64Array

@JvmStatic

@JvmOverloads

fun concat(first: F64TwoAxisArray, vararg rest: F64TwoAxisArray, axis: Int = 0): F64TwoAxisArray

Concatenates the given arrays along the specified axis.

diagonal

@JvmStatic

fun diagonal(values: F64Array): F64TwoAxisArray

@JvmStatic

fun diagonal(values: DoubleArray): F64TwoAxisArray

Creates a 2D diagonal matrix from the given values.

fromCSV

fun F64Array.Companion.fromCSV(csv: Sequence<String>, separator: String = ","): F64Array

Reads a CSV file into an F64Array.

fun F64Array.Companion.fromCSV(csv: <Error class: unknown class>, separator: String = ","): F64Array

Reads a CSV file into an F64Array.

fromImage

fun F64Array.Companion.fromImage(img: Bitmap): F64ImageArray

Reads a Bitmap into an F64Array.

fun F64Array.Companion.fromImage(img: BufferedImage): F64ImageArray

Reads a BufferedImage into an F64Array.

fun F64Array.Companion.fromImage(file: File): F64ImageArray

Reads an image file into an F64Array.

full

@JvmStatic

fun full(vararg shape: Int, init: Double): F64Array

@JvmStatic

fun full(rows: Int, cols: Int, init: Double): F64TwoAxisArray

Creates a new array with the given shape, filled with the given value.

identity

@JvmStatic

fun identity(size: Int): F64TwoAxisArray

Creates a 2D identity matrix of the given size.

invoke

@JvmStatic

@JvmName(name = "create")

operator fun invoke(vararg shape: Int): F64Array

@JvmStatic

@JvmName(name = "create")

operator fun invoke(rows: Int, cols: Int): F64TwoAxisArray

Creates a new array with the specified shape.

@JvmStatic

@JvmName(name = "create1D")

operator fun invoke(size: Int, init: (Int) -> Double): F64FlatArray

Creates a new flat array with the specified size and initializes it with the given function.

@JvmStatic

@JvmName(name = "create2D")

operator fun invoke(numRows: Int, numColumns: Int, init: (Int, Int) -> Double): F64TwoAxisArray

Creates a new 2D array with the specified shape and initializes it with the given function.

@JvmStatic

@JvmName(name = "create3D")

operator fun invoke(x: Int, y: Int, z: Int, init: (Int, Int, Int) -> Double): F64Array

Creates a new 3D array with the specified shape and initializes it with the given function.

linear

@JvmStatic

fun linear(range: IntRange): F64FlatArray

@JvmStatic

@JvmOverloads

fun linear(start: Double, stop: Double, num: Int = 50): F64FlatArray

Creates an array with a linear range of values.

@JvmStatic

fun of(vararg values: Double): F64FlatArray

@JvmStatic

@JvmName(name = "ofArray")

fun of(data: DoubleArray): F64FlatArray

Creates a new flat array from the given values.

ofRows

@JvmStatic

@JvmName(name = "ofRowsArray")

fun ofRows(rows: List<F64Array>): F64TwoAxisArray

@JvmStatic

fun ofRows(rows: List<DoubleArray>): F64TwoAxisArray

Creates a new array from the given list of rows.

ones

@JvmStatic

fun ones(vararg shape: Int): F64Array

@JvmStatic

fun ones(rows: Int, cols: Int): F64TwoAxisArray

Creates a new array with the given shape, filled with ones.

random

@JvmStatic

@JvmOverloads

fun random(vararg shape: Int, random: Random = Random): F64Array

@JvmStatic

@JvmOverloads

fun random(rows: Int, cols: Int, random: Random = Random): F64TwoAxisArray

Creates an array of the given shape with random values. The values are uniformly distributed between 0 (inclusive) and 1 (exclusive).

zeros

@JvmStatic

fun zeros(vararg shape: Int): F64Array

@JvmStatic

fun zeros(rows: Int, cols: Int): F64TwoAxisArray

Creates a new array with the given shape, filled with zeros.