Method Detail

• get

   Double get(Integer pos)

• set

   Unit set(Integer pos, Double value)

• flatten

   F64FlatArray flatten()

  Flattens the array into a 1D view in O(1) time.

  Only implemented for flattenable arrays.

  Viewer method.

• contains

   Boolean contains(Double other)

• along

   Void along(Integer axis)

  Returns a sequence of views along the specified axis.

  For example, for a 2D array axis = 0 means "for each row", and axis = 1 "for each column".

  The array must have at least two dimensions.

  Viewer method.

• view

   Void view(Integer index, Integer axis)

  Returns a view of this array along the specified axis.

  The array must have at least two dimensions. Consider using V with easier syntax.

  Viewer method.

• copyTo

   Unit copyTo(F64Array other)

  Copies elements in this array to other array.

  In-place method for other and copying method for this.

• copy

   F64FlatArray copy()

  Returns a copy of this array.

  The copy has the same shape as the original, but not necessary the same strides, since the copy is always flattenable and dense, even if the original array is not.

  Copying method.

• fill

   Unit fill(Double init)

  Fills this array with a given init value.

  In-place method.

• reorder

   Unit reorder(IntArray indices, Integer axis)

  Applies a given permutation of indices to the elements in the array.

  In-place method.

• dot

   Double dot(ShortArray other)

  Computes a dot product between two vectors.

  Only implemented for flat arrays.

• dot

   Double dot(IntArray other)

  Computes a dot product between two vectors.

  Only implemented for flat arrays.

• dot

   Double dot(F64Array other)

  Computes a dot product between two vectors.

  Only implemented for flat arrays. Optimized for dense arrays.

• sum

   Double sum()

  Returns the sum of the elements.

  Optimized for dense arrays.

• cumSum

   Unit cumSum()

  Computes cumulative sum of the elements.

  In-place method. Only implemented for flat arrays.

• min

   Double min()

  Returns the minimum element.

  If any of array elements is NaN, the result is undefined but will be one of the array elements.

  Optimized for dense arrays.

• argMin

   Integer argMin()

  Returns the index of the minimum element.

  If any of array elements is NaN, the result is undefined but will be a valid index.

  Only implemented for flat arrays.

• max

   Double max()

  Returns the maximum element.

  If any of array elements is NaN, the result is undefined but will be one of the array elements.

  Optimized for dense arrays.

• argMax

   Integer argMax()

  Returns the index of the maximum element.

  If any of array elements is NaN, the result is undefined but will be a valid index.

  Only implemented for flat arrays.

• transformInPlace

   Unit transformInPlace(Function1<Double, Double> op)

  Replaces each element x of this array with op(x) for the given unary operation op.

  If you need to apply one of the exp, expm1, log, log1p, use the appropriate specialized method instead (see the list below); these will generally be much more efficient.

  In-place method.

  Parameters:

  op - the unary operation to be applied.

• transform

   F64FlatArray transform(Function1<Double, Double> op)

  A copying version of transformInPlace.

  If you need to apply one of the exp, expm1, log, log1p, use the appropriate specialized method instead (see the list below); these will generally be much more efficient.

  Copying method.

  Parameters:

  op - the unary operation to be applied.

• fold

   <T extends Any> T fold(T initial, Function2<T, Double, T> op)

  Folds the array using the provided initial value and the folding operation op.

  Equivalent to the following pseudo-code:

      var res = initial
      for (value in array) res = op(res, value)
      return res

  If you need to fold using one of the plus, max, or min with standard initial values, use the appropriate specialized method instead (see the list below); these will generally be much more efficient.

  Parameters:

  initial - the starting value of the fold.

  op - the folding binary operation.

• reduce

   Double reduce(Function2<Double, Double, Double> op)

  Reduces the array using the provided reduction operation op.

  Equivalent to the following pseudo-code:

      var res = first_element
      for (value in remaining_elements) res = op(res, value)
      return res

  If you need to reduce using one of the plus, max, or min, use the appropriate specialized method instead (see the list below); these will generally be much more efficient.

  Parameters:

  op - the binary reduction operation.

• combineInPlace

   Unit combineInPlace(F64Array other, Function2<Double, Double, Double> op)

  Apply the binary operation op in-place.

  If you need to apply an arithmetic operation (including logAddExp), use the appropriate specialized method instead (see the list below); these will generally be more efficient.

  In-place method.

  Parameters:

  other - the array to combine with.

  op - the binary operation.

• combine

   F64FlatArray combine(F64Array other, Function2<Double, Double, Double> op)

  Apply the binary operation op and return a new array.

  If you need to apply an arithmetic operation (including logAddExp), use the appropriate specialized method instead (see the list below); these will generally be more efficient.

  Copying method.

  Parameters:

  other - the array to combine with.

  op - the binary operation.

• exp

   F64FlatArray exp()

  A copying version of expInPlace.

  Copying method. Optimized for dense arrays.

• expm1

   F64FlatArray expm1()

  A copying version of expm1InPlace.

  Copying method. Optimized for dense arrays.

• log

   F64FlatArray log()

  A copying version of logInPlace.

  Copying method. Optimized for dense arrays.

• log1p

   F64FlatArray log1p()

  A copying version of log1pInPlace.

  Copying method. Optimized for dense arrays.

• logSumExp

   Double logSumExp()

  Computes

      log(Σ_x exp(x))

  in a numerically stable way.

• logAddExpAssign

   Unit logAddExpAssign(F64Array other)

  Plus-assign for values stored as logarithms.

  In other words, the same as invoking

      this[*i] = log(exp(this[*i]) + exp(other[*i]))

  for every valid i.

  In-place method.

• logAddExp

   F64FlatArray logAddExp(F64Array other)

  Computes elementwise

      log(exp(this[*i]) + exp(other[*i]))

  in a numerically stable way.

  Copying method.

• plusAssign

   Unit plusAssign(F64Array other)

• plus

   F64FlatArray plus(F64Array other)

• minusAssign

   Unit minusAssign(F64Array other)

• minus

   F64FlatArray minus(F64Array other)

• timesAssign

   Unit timesAssign(F64Array other)

• times

   F64FlatArray times(F64Array other)

• divAssign

   Unit divAssign(F64Array other)

• div

   F64FlatArray div(F64Array other)

• reshape

   F64Array reshape(Integer shape)

  Reshapes this array.

  The original and the new array contain the same elements in the same order, if both are enumerated row-major.

  For example, F64Array.of(1.0, 2.0, 3.0, 4.0, 5.0, 6.0).reshape(2, 3) produces a 2x3 matrix: [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ]

  Only supported for flattenable arrays.

  Viewer method.

• toArray

   DoubleArray toArray()

  Converts this array to a conventional Kotlin structure.

  For example, a vector will be converted to a DoubleArray, a matrix will become Array<DoubleArray> etc.

  Copying method.

• toGenericArray

   Void toGenericArray()

  Converts this array to an Array.

  For example, a matrix will become Array<DoubleArray> etc.

  Copying method. Not implemented for flat arrays.

• toDoubleArray

   DoubleArray toDoubleArray()

  Converts this vector to a DoubleArray.

  Copying method. Only implemented for flat arrays.

• toString

   String toString(Integer maxDisplay, DecimalFormat format)

  Creates a String representation of the given array.

  At most maxDisplay elements are printed for each dimension.

• equals

   Boolean equals(Object other)

• hashCode

   Integer hashCode()

• getNDim

   final Integer getNDim()

  Number of axes in this array.

• getLength

   final Integer getLength()

  Number of elements along the first axis.

• getSize

   final Integer getSize()

• getIsFlattenable

   final Boolean getIsFlattenable()

  Returns true if this array can be flattened using flatten.

  Flattenable array's elements are laid out with a constant stride. This allows using simple loops when iterating. Calling flatten on a non-flattenable array will produce an IllegalStateException.

  A particular case of a flattenable array is a dense array whose elements occupy a contiguous block of memory. Large dense arrays employ native SIMD optimizations, see F64LargeDenseArray.

• getV

   final F64Array.Viewer getV()

  A broadcasted viewer for this array.

  The main difference between a... and a.V... is that the array's getter/setter methods deal with scalar Double values, while the viewer's methods deal with F64Arrays. Another difference is that the viewer's methods can skip dimensions by providing _I object instead of an index.

  Consider a matrix (2D array) a. Then the following invocations have the following effect: a4 // fails, since it doesn't reference a scalar a4, 2 // returns a Double a.V4 // returns 4th row a.V_I, 2 // returns 2nd column a.V4, 2 // fails, since it doesn't reference an array

• getData

   final DoubleArray getData()

  Raw data array.

• getOffset

   final Integer getOffset()

  Offset of the first vector element in the raw data array.

• getStrides

   final IntArray getStrides()

  Indexing steps along each axis.

• getShape

   final IntArray getShape()

  Number of elements along each axis.