Clears the internal flags on a tensor. Uses bitwise operators for flags.

Get the underlying data as a haskell list from the tensor

NOTE: This _cannot_ use a Tensor's storage size because ATen's Storage allocates up to the next 64-byte line on the CPU (needs reference, this is the unofficial response from @soumith in slack).

get a value from dimension 1

get a value from dimension 2

get a value from dimension 3

get a value from dimension 4

get a value from a dynamic tensor at a given index, Dims d.

whether or not the tensor is contiguous in memory.

check to see if to tensors are the same size as eachother.

Returns true iff the Tensor is set to the argument Tensor.

Note: this is only true if the tensors are the same size, have the same strides and share the same storage and offset.

check to see if the tensor is the same size as the LongStorage.

Returns the number of dimensions in a Tensor.

Returns the number of elements in a Tensor.

returns a tensor which shares the same Storage as the original. Hence, any modification in the memory of the sub-tensor will have an impact on the primary tensor, and vice-versa. These methods are very fast, as they do not involve any memory copy.

Returns an empty tensor.

pure version of _expand

Expanding a tensor does not allocate new memory, but only creates a new view on the existing tensor where singleton dimensions can be expanded to multiple ones by setting the stride to 0. Any dimension that has size 1 can be expanded to arbitrary value without any new memory allocation. Attempting to expand along a dimension that does not have size 1 will result in an error which we do not currently handle in hasktorch.

FIXME: doublecheck what this does.

purely clone a tensor

purely clone a tensor to have a contiguous memory layout.

returns a tensor which shares the same Storage as the original. Hence, any modification in the memory of the sub-tensor will have an impact on the primary tensor, and vice-versa. These methods are very fast, as they do not involve any memory copy.

returns a tensor which shares the same Storage as the original. Hence, any modification in the memory of the sub-tensor will have an impact on the primary tensor, and vice-versa. These methods are very fast, as they do not involve any memory copy.

get the sizes of each dimension

FIXME: doublecheck this

get the strides of each dimension

FIXME: doublecheck this

pure version of _transpose

pure version of _unfold

Creates a view with different dimensions of the storage associated with tensor, returning a new tensor.

FIXME: I think resizeAs is the non-cloning version of this function. See: https://github.com/torch/torch7/blob/master/doc/tensor.md#result-viewresult-tensor-sizes

for more.

NOTE(stites): I think this API can only be kept pure via linear types.

create an uninitialized tensor with the given size and strides (?)

FIXME: doublecheck what the IndexStorages stands for

create an uninitialized 1d tensor

create an uninitialized 2d tensor

create an uninitialized 3d tensor

create an uninitialized 4d tensor

create a new tensor with the given size and strides, storage offset and storage.

create a new 1d tensor with the given storage's first dimension.

create a new 2d tensor with the given storage's first 2 dimensions.

create a new 3d tensor with the given storage's first 3 dimensions.

create a new 4d tensor with the given storage's first 4 dimensions.

create a new tensor with the given tensor's underlying storage.

Resize the tensor according to the given LongStorage size (and strides?) FIXME: doublecheck what the IndexStorages stands for

resize dimension 1 of a tensor.

resize the first 2 dimensions of a tensor.

resize the first 3 dimensions of a tensor.

resize the first 4 dimensions of a tensor.

resize the first 5 dimensions of a tensor.

Resize the tensor as the given tensor.

resize a tensor with given strides, sizes and a magical parameter.

FIXME: Someone needs to find out what the magical parameter is.

Increment the reference counter of the tensor.

From: https://github.com/torch/torch7/blob/aed31711c6b8846b8337a263a7f9f998697994e7/doc/tensor.md#reference-counting

Tensors are reference-counted. It means that each time an object (C or the Lua state) need to keep a reference over a tensor, the corresponding tensor reference counter will be increased. The reference counter is decreased when the object does not need the tensor anymore.

These methods should be used with extreme care. In general, they should never be called, except if you know what you are doing, as the handling of references is done automatically. They can be useful in threaded environments. Note that these methods are atomic operations.

returns a tensor which shares the same Storage as the original. Hence, any modification in the memory of the sub-tensor will have an impact on the primary tensor, and vice-versa. These methods are very fast, as they do not involve any memory copy.

set the source tensor's storage to another tensor.

set a value in dimension 1, inplace.

set a value in dimension 2, inplace.

set a value in dimension 3, inplace.

set a value in dimension 4, inplace.

set the flags on a tensor inplace

Set the storage of a tensor.

FIXME: doublecheck what the IndexStorages stands for

Set the storage of a tensor, only referencing 1 dimension of storage

Set the storage of a tensor, only referencing 2 dimensions of storage

Set the storage of a tensor, only referencing 3 dimensions of storage

Set the storage of a tensor, only referencing 4 dimensions of storage

Set the storage of a tensor, referencing any number of dimensions of storage

get the size of a tensor's specific dimension.

FIXME: this can throw an exception if the dimension is out-of-bound.

primarily used for debugging. Get the size description from a c call.

Removes all singleton dimensions of the tensor.

Removes a singleton dimensions of the tensor at a given dimension.

Removes a singleton dimensions of the tensor at a given dimension.

get the underlying storage of a tensor

get the storage offset of a tensor

Returns the jump necessary to go from one element to the next one in the specified dimension dim.

Returns a tensor where dimensions dim1 and dim2 have been swapped.

Returns a tensor which contains all slices of size size in the dimension dim. Step between two slices is given by step.

If sizedim is the original size of dimension dim, the size of dimension dim in the returned tensor will be (sizedim - size) / step + 1

An additional dimension of size size is appended in the returned tensor.

FIXME: this still takes C-like arguments which mutates the first arg inplace.

unsqueeze a tensor inplace

unsqueeze a tensor, adding a singleton dimension at the specified dimval.

return the a runtime shape representing the dimensions of a Dynamic

set the storage dimensionality of a dynamic tensor, inplace, to any new size and stride pair.

set a value of a dynamic tensor, inplace, with any dimensionality.

resize a dynamic tensor, inplace, to any new dimensionality

create a 1d Dynamic tensor from a list of elements.

FIXME construct this with TH, not by using setDim inplace (one-by-one) which might be doing a second linear pass. FIXME: CUDA doesn't like the storage allocation:

create a 2d Dynamic tensor from a list of list of elements.

create a 3d Dynamic tensor (ie: rectangular cuboid) from a nested list of elements.

create a 4d Dynamic tensor (ie: hyperrectangle) from a nested list of elements.

get the runtime dimension list of a dynamic tensor

alias to getDimList which wraps the dimensions list in a SomeDims

create a new dynamic tensor of size Dims d

set a specific runtime SomeDims position of a dynamic tensor.

resize a dynamic tensor inplace with runtime SomeDims representation of its new shape.

build a new tensor with a runtime SomeDims

resize a tensor to take the shape of the second Dynamic argument. This is a pure function.

run a function with a dynamic tensor and storage's underlying implementation details. withDynamicStateAndStorage :: Sig.Dynamic -> Sig.Storage -> (Ptr Sig.CState -> Ptr Sig.CTensor -> Ptr Sig.CStorage -> IO x) -> IO x withDynamicStateAndStorage t s fn = flip with pure $ do s' <- managedState t' <- managedTensor t liftIO $ withForeignPtr (Sig.cstorage s) (fn s' t')

exported helper function. Not actually "inplace" this is actually "with return and static dimensions"

exported helper function. not actually "inplace" this is actually "with return and runtime dimensions"

exported helper function. This is actually inplace

exported helper function. Should be renamed to newFromSize withEmpty :: Dynamic -> (Dynamic -> IO ()) -> IO Dynamic withEmpty t op = let r = new' (getSomeDimsList t) in op r >> pure r

exported helper function. We can get away with this some of the time, when Torch does the resizing in C, but you need to look at the c implementation