Tensor (keanu-project 0.0.26 API)

All Known Subinterfaces:

BooleanTensor, DoubleTensor, FixedPointTensor<N,T>, FloatingPointTensor<N,T>, IntegerTensor, NumberTensor<N,T>

All Known Implementing Classes:

GenericTensor, JVMBooleanTensor, JVMDoubleTensor, JVMFloatingPointTensor, JVMNumberTensor, JVMTensor, Nd4jDoubleTensor, Nd4jFixedPointTensor, Nd4jFloatingPointTensor, Nd4jIntegerTensor, Nd4jNumberTensor, Nd4jTensor, ScalarIntegerTensor
```
public interface Tensor<N,T extends Tensor<N,T>>
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static interface Tensor.FlattenedView<N>

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`Tensor.FlattenedView<N>`

Field Summary

Fields
Modifier and Type Field and Description

static long[] ONE_BY_ONE_SHAPE

static long[] SCALAR_SHAPE

static long[] SCALAR_STRIDE

Fields
Modifier and Type	Field and Description
`static long[]`	`ONE_BY_ONE_SHAPE`
`static long[]`	`SCALAR_SHAPE`
`static long[]`	`SCALAR_STRIDE`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`N[]`	`asFlatArray()`
`default java.util.List<N>`	`asFlatList()`
`T`	`broadcast(long... toShape)`
`static <DATA,TENSOR extends Tensor<DATA,TENSOR>> TENSOR`	`create(DATA[] data, long[] shape)`
`static <DATA,TENSOR extends Tensor<DATA,TENSOR>> TENSOR`	`createFilled(DATA data, long[] shape)`
`T`	`diag()`
`T`	`duplicate()`
`BooleanTensor`	`elementwiseEquals(N value)`
`default BooleanTensor`	`elementwiseEquals(Tensor that)`
`static BooleanTensor`	`elementwiseEquals(Tensor a, Tensor b)`
`default T`	`expandDims(int axis)`
`T`	`get(BooleanTensor booleanIndex)`
`Tensor.FlattenedView<N>`	`getFlattenedView()`
`long`	`getLength()`
`int`	`getRank()`
`long[]`	`getShape()`
`long[]`	`getStride()` Returns the stride for each dimension of the tensor (based on C ordering).
`default N`	`getValue(long... index)` getValue returns a single primitive value from a specified index.
`default boolean`	`hasSameShapeAs(long[] shape)`
`default boolean`	`hasSameShapeAs(Tensor that)`
`default boolean`	`isLengthOne()`
`default boolean`	`isMatrix()`
`default boolean`	`isScalar()`
`default boolean`	`isVector()` Returns true if the tensor is a vector.
`default T`	`moveAxis(int source, int destination)`
`T`	`permute(int... rearrange)`
`T`	`reshape(long... newShape)`
`default N`	`scalar()`
`static <DATA,TENSOR extends Tensor<DATA,TENSOR>> TENSOR`	`scalar(DATA data)`
`default void`	`setValue(N value, long... index)`
`T`	`slice(int dimension, long index)`
`T`	`slice(Slicer slicer)`
`default T`	`slice(java.lang.String sliceArg)`
`default java.util.List<T>`	`sliceAlongDimension(int dimension, long indexStart, long indexEnd)`
`java.util.List<T>`	`split(int dimension, long... splitAtIndices)`
`default T`	`squeeze()`
`default T`	`swapAxis(int axis1, int axis2)`
`T`	`take(long... index)`
`default T`	`transpose()`

Field Detail

SCALAR_SHAPE
```
static final long[] SCALAR_SHAPE
```

SCALAR_STRIDE
```
static final long[] SCALAR_STRIDE
```

ONE_BY_ONE_SHAPE
```
static final long[] ONE_BY_ONE_SHAPE
```

Method Detail

scalar

static <DATA,TENSOR extends Tensor<DATA,TENSOR>> TENSOR scalar(DATA data)

createFilled

static <DATA,TENSOR extends Tensor<DATA,TENSOR>> TENSOR createFilled(DATA data,
                                                                     long[] shape)

create

static <DATA,TENSOR extends Tensor<DATA,TENSOR>> TENSOR create(DATA[] data,
                                                               long[] shape)

elementwiseEquals

static BooleanTensor elementwiseEquals(Tensor a,
                                       Tensor b)

getRank
```
int getRank()
```

getShape
```
long[] getShape()
```

getStride
```
long[] getStride()
```
Returns the stride for each dimension of the tensor (based on C ordering).
The stride is the distance you'd move in a flat representation of the tensor for each index within that dimension EG) For a 2x2 Tensor the Tensor would be laid out (in C order): [{0, 0}, {0, 1}, {1, 0}, {1, 1}] Thus the stride array would be provided as: [2, 1]

Returns:

The stride array for this tensor

getLength
```
long getLength()
```

getValue
```
default N getValue(long... index)
```
getValue returns a single primitive value from a specified index. The number of indices supplied must match the rank of the tensor.

Parameters:

index - the index of the scalar value.

Returns:

The primitive value at the specified index

get
```
T get(BooleanTensor booleanIndex)
```
Parameters:

booleanIndex - a boolean tensor the same shape as this tensor where true is specified if the element should be kept and false if not.

Returns:

a vector with the values that align with true from the boolean index.

setValue

default void setValue(N value,
                      long... index)

scalar
```
default N scalar()
```

duplicate
```
T duplicate()
```

slice

T slice(int dimension,
        long index)

slice

default T slice(java.lang.String sliceArg)

slice
```
T slice(Slicer slicer)
```

take
```
T take(long... index)
```

split
```
java.util.List<T> split(int dimension,
                        long... splitAtIndices)
```
Parameters:

dimension - the dimension to split on

splitAtIndices - the indices that the dimension to split on should be split on

Returns:

pieces of the tensor split in the order specified by splitAtIndices. To get pieces that encompasses the entire tensor, the last index in the splitAtIndices must be the length of the dimension being split on.
e.g A = [ 1, 2, 3, 4, 5, 6 7, 8, 9, 1, 2, 3 ]
A.split(0, [1]) gives List([1, 2, 3, 4, 5, 6]) A.split(0, [1, 2]) gives List([1, 2, 3, 4, 5, 6], [7, 8, 9, 1, 2, 3]
A.split(1, [1, 3, 6]) gives List( [1, [2, 3 , [4, 5, 6, 7] 8, 9] 1, 2, 3] )

sliceAlongDimension

default java.util.List<T> sliceAlongDimension(int dimension,
                                              long indexStart,
                                              long indexEnd)

diag
```
T diag()
```

transpose
```
default T transpose()
```

asFlatArray
```
N[] asFlatArray()
```

reshape
```
T reshape(long... newShape)
```

squeeze
```
default T squeeze()
```

expandDims
```
default T expandDims(int axis)
```

moveAxis

default T moveAxis(int source,
                   int destination)

swapAxis

default T swapAxis(int axis1,
                   int axis2)

permute
```
T permute(int... rearrange)
```

broadcast
```
T broadcast(long... toShape)
```

getFlattenedView

Tensor.FlattenedView<N> getFlattenedView()

asFlatList

default java.util.List<N> asFlatList()

isLengthOne
```
default boolean isLengthOne()
```

isScalar
```
default boolean isScalar()
```

isVector
```
default boolean isVector()
```
Returns true if the tensor is a vector. A vector being a 1xn or a nx1 tensor.
(1, 2, 3) is a 1x3 vector.
(1) (2) (3) is a 3x1 vector.

Returns:

true if the tensor is a vector

isMatrix
```
default boolean isMatrix()
```

hasSameShapeAs

default boolean hasSameShapeAs(Tensor that)

hasSameShapeAs

default boolean hasSameShapeAs(long[] shape)

elementwiseEquals

default BooleanTensor elementwiseEquals(Tensor that)

elementwiseEquals

BooleanTensor elementwiseEquals(N value)

Interface Tensor<N,T extends Tensor<N,T>>

Nested Class Summary

Field Summary

Method Summary

Field Detail

SCALAR_SHAPE

SCALAR_STRIDE

ONE_BY_ONE_SHAPE

Method Detail

scalar

createFilled

create

elementwiseEquals

getRank

getShape

getStride

getLength

getValue

get

setValue

scalar

duplicate

slice

slice

slice

take

split

sliceAlongDimension

diag

transpose

asFlatArray

reshape

squeeze

expandDims

moveAxis

swapAxis

permute

broadcast

getFlattenedView

asFlatList

isLengthOne

isScalar

isVector

isMatrix

hasSameShapeAs

hasSameShapeAs

elementwiseEquals

elementwiseEquals