io.improbable.keanu.tensor

Class TensorShape

java.lang.Object

io.improbable.keanu.tensor.TensorShape

public class TensorShape
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
TensorShape(long[] shape)

Method Summary

Modifier and Type	Method and Description
static long[]	calculateShapeForLengthOneBroadcast(long[] shape1, long[] shape2)
static long[]	concat(long[] shape1, long[] shape2)
static long	convertFromFlatIndexToPermutedFlatIndex(long fromFlatIndex, long[] shape, long[] stride, long[] permutedShape, long[] permutedStride, int[] rearrange)
static int[]	dimensionRange(int fromDimension, int toDimension)
boolean	equals(java.lang.Object o)
static int	getAbsoluteDimension(int dimension, int rank) Finds the absolute dimension for a shape
static long	getBroadcastedFlatIndex(long fromFlatIndex, long[] fromStride, long[] toShape, long[] toStride)
static long[]	getBroadcastResultShape(long[] left, long[] right)
static long[]	getConcatResultShape(int dimension, Tensor... toConcat)
static long	getFlatIndex(long[] shape, long[] stride, long... index)
static long	getLength(long[] shape)
static int	getLengthAsInt(long[] shape)
static int[]	getPermutationForDimensionToDimensionZero(int dimension, long[] shape)
static long[]	getPermutedIndices(long[] indices, int... rearrange)
int	getRank()
static long[]	getReductionResultShape(long[] inputShape, int[] sumOverDimensions)
static long[]	getReshapeAllowingWildcard(long[] oldShape, long oldShapeLength, long[] newShape)
static long[]	getRowFirstStride(long[] shape)
long[]	getShape()
static long[]	getShapeIndices(long[] shape, long[] stride, long flatIndex) This method can be interpreted as the opposite to getFlatIndex.
int	hashCode()
static boolean	incrementIndexByShape(long[] shape, long[] index, int[] dimensionOrder)
static int[]	invertedPermute(int[] rearrange)
boolean	isLengthOne()
static boolean	isLengthOne(long[] shape)
boolean	isScalar()
static boolean	isScalar(long[] shape)
static long[]	removeDimension(int dimension, long[] shape) Removes a dimension from a shape.
static long[]	selectDimensions(int from, int to, long[] shape)
static int[]	setToAbsoluteDimensions(int rank, int[] dimensions) It's possible to express negative dimensions, which are relative to the rank of a tensor.
static long[]	shapeDesiredToRankByAppendingOnes(long[] lowRankTensorShape, int desiredRank)
static long[]	shapeToDesiredRankByPrependingOnes(long[] lowRankTensorShape, int desiredRank)
static int[]	slideDimension(int from, int to, int rank)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TensorShape

public TensorShape(long[] shape)

Method Detail

getShape

public long[] getShape()

isScalar

public boolean isScalar()

isLengthOne

public boolean isLengthOne()

getRank

public int getRank()

equals

public boolean equals(java.lang.Object o)

Overrides:

equals in class java.lang.Object

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

getLength

public static long getLength(long[] shape)

Parameters:

shape - for finding length of

Returns:

the number of elements in a tensor. This is the product of all ints in shape.

getLengthAsInt

public static int getLengthAsInt(long[] shape)

getRowFirstStride

public static long[] getRowFirstStride(long[] shape)

Parameters:

shape - shape to find stride for

Returns:

the stride which is used to convert from a N dimensional index to a buffer array flat index. This is based on the C convention of row first instead of column.

getFlatIndex

public static long getFlatIndex(long[] shape,
                                long[] stride,
                                long... index)

Parameters:

shape - shape to find the index for

stride - stride to find the index for

index - the index in each dimension

Returns:

the flat index from a N dimensional index

getShapeIndices

public static long[] getShapeIndices(long[] shape,
                                     long[] stride,
                                     long flatIndex)

This method can be interpreted as the opposite to getFlatIndex.

Parameters:

shape - the shape to find the index of

stride - the stride to find the index of

flatIndex - the index to f

Returns:

converts from a flat index to a N dimensional index. Where N = the dimensionality of the shape.

isScalar

public static boolean isScalar(long[] shape)

isLengthOne

public static boolean isLengthOne(long[] shape)

concat

public static long[] concat(long[] shape1,
                            long[] shape2)

dimensionRange

public static int[] dimensionRange(int fromDimension,
                                   int toDimension)

Parameters:

fromDimension - starting from and including this dimension

toDimension - up to but excluding this dimension

Returns:

an int array containing the dimension numbers from a given dimension to a higher dimension. e.g. dimensionRange(0, 3) = int[]{0, 1, 2}

selectDimensions

public static long[] selectDimensions(int from,
                                      int to,
                                      long[] shape)

slideDimension

public static int[] slideDimension(int from,
                                   int to,
                                   int rank)

shapeDesiredToRankByAppendingOnes

public static long[] shapeDesiredToRankByAppendingOnes(long[] lowRankTensorShape,
                                                       int desiredRank)

shapeToDesiredRankByPrependingOnes

public static long[] shapeToDesiredRankByPrependingOnes(long[] lowRankTensorShape,
                                                        int desiredRank)

calculateShapeForLengthOneBroadcast

public static long[] calculateShapeForLengthOneBroadcast(long[] shape1,
                                                         long[] shape2)

getBroadcastResultShape

public static long[] getBroadcastResultShape(long[] left,
                                             long[] right)

setToAbsoluteDimensions

public static int[] setToAbsoluteDimensions(int rank,
                                            int[] dimensions)

It's possible to express negative dimensions, which are relative to the rank of a tensor. E.g. given a rank 3 tensor, dimensions [-1, -2] would refer to the 3rd and 2nd dimension.

Parameters:

rank - the rank that the dimension array is related to

dimensions - positive dimensions are absolute and negative are relative to the rank

Returns:

the dimensions converted to all absolute (positive). This mutates the passed in dimension argument.

removeDimension

public static long[] removeDimension(int dimension,
                                     long[] shape)

Removes a dimension from a shape. This will lower the rank by one.

Parameters:

dimension - the dimension to remove

shape - the shape to remove the dimension from

Returns:

the shape without the given dimension

Throws:

java.lang.IllegalArgumentException - if the dimension does not exist

getAbsoluteDimension

public static int getAbsoluteDimension(int dimension,
                                       int rank)

Finds the absolute dimension for a shape

Parameters:

dimension - the negative or positive dimension to find the absolute of

rank - the rank

Returns:

an absolute dimension from a shape

getReductionResultShape

public static long[] getReductionResultShape(long[] inputShape,
                                             int[] sumOverDimensions)

getPermutedIndices

public static long[] getPermutedIndices(long[] indices,
                                        int... rearrange)

invertedPermute

public static int[] invertedPermute(int[] rearrange)

convertFromFlatIndexToPermutedFlatIndex

public static long convertFromFlatIndexToPermutedFlatIndex(long fromFlatIndex,
                                                           long[] shape,
                                                           long[] stride,
                                                           long[] permutedShape,
                                                           long[] permutedStride,
                                                           int[] rearrange)

getReshapeAllowingWildcard

public static long[] getReshapeAllowingWildcard(long[] oldShape,
                                                long oldShapeLength,
                                                long[] newShape)

Parameters:

oldShape - The original shape to reshape from. This should have a shape length that matches oldShapeLength

oldShapeLength - The length of the old shape. e.g shape = [2, 2] then the length is 4

newShape - A shape that must be the same length as oldShape unless a single -1 dimension length is specified. If -1 is used then a dimension length will be calculated in order to ensure the new shape length is equal to the old shape length.

Returns:

a copy of newShape if there is no wildcard used or a wildcard free shape with a length that matches the oldShapeLength

getConcatResultShape

public static long[] getConcatResultShape(int dimension,
                                          Tensor... toConcat)

getPermutationForDimensionToDimensionZero

public static int[] getPermutationForDimensionToDimensionZero(int dimension,
                                                              long[] shape)

getBroadcastedFlatIndex

public static long getBroadcastedFlatIndex(long fromFlatIndex,
                                           long[] fromStride,
                                           long[] toShape,
                                           long[] toStride)

incrementIndexByShape

public static boolean incrementIndexByShape(long[] shape,
                                            long[] index,
                                            int[] dimensionOrder)