diff --git a/cbits/expand_polyfill.c b/cbits/expand_polyfill.c new file mode 100644 --- /dev/null +++ b/cbits/expand_polyfill.c @@ -0,0 +1,579 @@ +#include "TH/THTensor.h" +#include "TH/THStorage.h" + + +THByteTensor* THByteTensor_newExpand(THByteTensor *tensor, THLongStorage *sizes) { + THByteTensor *result = THByteTensor_new(); + THByteTensor_expand(result, tensor, sizes); + return result; +} + +void THByteTensor_expand(THByteTensor *r, THByteTensor *tensor, THLongStorage *sizes) { + THArgCheck(THByteTensor_nDimension(tensor) > 0, 0, "can't expand an empty tensor"); + THArgCheck(THLongStorage_size(sizes) >= THByteTensor_nDimension(tensor), 1, + "the number of sizes provided must be greater or equal to the " + "number of dimensions in the tensor"); + + long *expandedSizes; + long *expandedStrides; + char error_buffer[1024]; + int ret = + THLongStorage_inferExpandGeometry(tensor->size, tensor->stride, THByteTensor_nDimension(tensor), + sizes, &expandedSizes, &expandedStrides, error_buffer, 1024); + + if (ret != 0) { + THError(error_buffer); + return; + } + + THByteTensor_setStorageNd(r, THByteTensor_storage(tensor), THByteTensor_storageOffset(tensor), + THLongStorage_size(sizes), expandedSizes, expandedStrides); + THFree(expandedSizes); + THFree(expandedStrides); +} + + +void THByteTensor_expandNd(THByteTensor **rets, THByteTensor **ops, int count) { + for (int i = 0; i < count; ++i) { + THArgCheck(THByteTensor_nDimension(ops[i]) > 0, i, "can't expand empty tensor %d", i); + } + + long *op_sizes[count]; + long op_dims[count]; + + for (int i = 0; i < count; ++i) { + op_sizes[i] = ops[i]->size; + op_dims[i] = ops[i]->nDimension; + } + + THLongStorage *sizes = THLongStorage_new(); + char error_buffer[1024]; + int ret = THLongStorage_inferSizeN(sizes, + count, + op_sizes, + op_dims, + error_buffer, + 1024); + + if(ret != 0) { + THLongStorage_free(sizes); + THError(error_buffer); + return; + } + + for (int i = 0; i < count; ++i) { + THByteTensor_expand(rets[i], ops[i], sizes); + } + + THLongStorage_free(sizes); +} + + + +// Polyfilling expand functions for Byte: + + + +THCharTensor* THCharTensor_newExpand(THCharTensor *tensor, THLongStorage *sizes) { + THCharTensor *result = THCharTensor_new(); + THCharTensor_expand(result, tensor, sizes); + return result; +} + +void THCharTensor_expand(THCharTensor *r, THCharTensor *tensor, THLongStorage *sizes) { + THArgCheck(THCharTensor_nDimension(tensor) > 0, 0, "can't expand an empty tensor"); + THArgCheck(THLongStorage_size(sizes) >= THCharTensor_nDimension(tensor), 1, + "the number of sizes provided must be greater or equal to the " + "number of dimensions in the tensor"); + + long *expandedSizes; + long *expandedStrides; + char error_buffer[1024]; + int ret = + THLongStorage_inferExpandGeometry(tensor->size, tensor->stride, THCharTensor_nDimension(tensor), + sizes, &expandedSizes, &expandedStrides, error_buffer, 1024); + + if (ret != 0) { + THError(error_buffer); + return; + } + + THCharTensor_setStorageNd(r, THCharTensor_storage(tensor), THCharTensor_storageOffset(tensor), + THLongStorage_size(sizes), expandedSizes, expandedStrides); + THFree(expandedSizes); + THFree(expandedStrides); +} + + +void THCharTensor_expandNd(THCharTensor **rets, THCharTensor **ops, int count) { + for (int i = 0; i < count; ++i) { + THArgCheck(THCharTensor_nDimension(ops[i]) > 0, i, "can't expand empty tensor %d", i); + } + + long *op_sizes[count]; + long op_dims[count]; + + for (int i = 0; i < count; ++i) { + op_sizes[i] = ops[i]->size; + op_dims[i] = ops[i]->nDimension; + } + + THLongStorage *sizes = THLongStorage_new(); + char error_buffer[1024]; + int ret = THLongStorage_inferSizeN(sizes, + count, + op_sizes, + op_dims, + error_buffer, + 1024); + + if(ret != 0) { + THLongStorage_free(sizes); + THError(error_buffer); + return; + } + + for (int i = 0; i < count; ++i) { + THCharTensor_expand(rets[i], ops[i], sizes); + } + + THLongStorage_free(sizes); +} + + + +// Polyfilling expand functions for Char: + + + +THShortTensor* THShortTensor_newExpand(THShortTensor *tensor, THLongStorage *sizes) { + THShortTensor *result = THShortTensor_new(); + THShortTensor_expand(result, tensor, sizes); + return result; +} + +void THShortTensor_expand(THShortTensor *r, THShortTensor *tensor, THLongStorage *sizes) { + THArgCheck(THShortTensor_nDimension(tensor) > 0, 0, "can't expand an empty tensor"); + THArgCheck(THLongStorage_size(sizes) >= THShortTensor_nDimension(tensor), 1, + "the number of sizes provided must be greater or equal to the " + "number of dimensions in the tensor"); + + long *expandedSizes; + long *expandedStrides; + char error_buffer[1024]; + int ret = + THLongStorage_inferExpandGeometry(tensor->size, tensor->stride, THShortTensor_nDimension(tensor), + sizes, &expandedSizes, &expandedStrides, error_buffer, 1024); + + if (ret != 0) { + THError(error_buffer); + return; + } + + THShortTensor_setStorageNd(r, THShortTensor_storage(tensor), THShortTensor_storageOffset(tensor), + THLongStorage_size(sizes), expandedSizes, expandedStrides); + THFree(expandedSizes); + THFree(expandedStrides); +} + + +void THShortTensor_expandNd(THShortTensor **rets, THShortTensor **ops, int count) { + for (int i = 0; i < count; ++i) { + THArgCheck(THShortTensor_nDimension(ops[i]) > 0, i, "can't expand empty tensor %d", i); + } + + long *op_sizes[count]; + long op_dims[count]; + + for (int i = 0; i < count; ++i) { + op_sizes[i] = ops[i]->size; + op_dims[i] = ops[i]->nDimension; + } + + THLongStorage *sizes = THLongStorage_new(); + char error_buffer[1024]; + int ret = THLongStorage_inferSizeN(sizes, + count, + op_sizes, + op_dims, + error_buffer, + 1024); + + if(ret != 0) { + THLongStorage_free(sizes); + THError(error_buffer); + return; + } + + for (int i = 0; i < count; ++i) { + THShortTensor_expand(rets[i], ops[i], sizes); + } + + THLongStorage_free(sizes); +} + + + +// Polyfilling expand functions for Short: + + + +THIntTensor* THIntTensor_newExpand(THIntTensor *tensor, THLongStorage *sizes) { + THIntTensor *result = THIntTensor_new(); + THIntTensor_expand(result, tensor, sizes); + return result; +} + +void THIntTensor_expand(THIntTensor *r, THIntTensor *tensor, THLongStorage *sizes) { + THArgCheck(THIntTensor_nDimension(tensor) > 0, 0, "can't expand an empty tensor"); + THArgCheck(THLongStorage_size(sizes) >= THIntTensor_nDimension(tensor), 1, + "the number of sizes provided must be greater or equal to the " + "number of dimensions in the tensor"); + + long *expandedSizes; + long *expandedStrides; + char error_buffer[1024]; + int ret = + THLongStorage_inferExpandGeometry(tensor->size, tensor->stride, THIntTensor_nDimension(tensor), + sizes, &expandedSizes, &expandedStrides, error_buffer, 1024); + + if (ret != 0) { + THError(error_buffer); + return; + } + + THIntTensor_setStorageNd(r, THIntTensor_storage(tensor), THIntTensor_storageOffset(tensor), + THLongStorage_size(sizes), expandedSizes, expandedStrides); + THFree(expandedSizes); + THFree(expandedStrides); +} + + +void THIntTensor_expandNd(THIntTensor **rets, THIntTensor **ops, int count) { + for (int i = 0; i < count; ++i) { + THArgCheck(THIntTensor_nDimension(ops[i]) > 0, i, "can't expand empty tensor %d", i); + } + + long *op_sizes[count]; + long op_dims[count]; + + for (int i = 0; i < count; ++i) { + op_sizes[i] = ops[i]->size; + op_dims[i] = ops[i]->nDimension; + } + + THLongStorage *sizes = THLongStorage_new(); + char error_buffer[1024]; + int ret = THLongStorage_inferSizeN(sizes, + count, + op_sizes, + op_dims, + error_buffer, + 1024); + + if(ret != 0) { + THLongStorage_free(sizes); + THError(error_buffer); + return; + } + + for (int i = 0; i < count; ++i) { + THIntTensor_expand(rets[i], ops[i], sizes); + } + + THLongStorage_free(sizes); +} + + + +// Polyfilling expand functions for Int: + + + +THLongTensor* THLongTensor_newExpand(THLongTensor *tensor, THLongStorage *sizes) { + THLongTensor *result = THLongTensor_new(); + THLongTensor_expand(result, tensor, sizes); + return result; +} + +void THLongTensor_expand(THLongTensor *r, THLongTensor *tensor, THLongStorage *sizes) { + THArgCheck(THLongTensor_nDimension(tensor) > 0, 0, "can't expand an empty tensor"); + THArgCheck(THLongStorage_size(sizes) >= THLongTensor_nDimension(tensor), 1, + "the number of sizes provided must be greater or equal to the " + "number of dimensions in the tensor"); + + long *expandedSizes; + long *expandedStrides; + char error_buffer[1024]; + int ret = + THLongStorage_inferExpandGeometry(tensor->size, tensor->stride, THLongTensor_nDimension(tensor), + sizes, &expandedSizes, &expandedStrides, error_buffer, 1024); + + if (ret != 0) { + THError(error_buffer); + return; + } + + THLongTensor_setStorageNd(r, THLongTensor_storage(tensor), THLongTensor_storageOffset(tensor), + THLongStorage_size(sizes), expandedSizes, expandedStrides); + THFree(expandedSizes); + THFree(expandedStrides); +} + + +void THLongTensor_expandNd(THLongTensor **rets, THLongTensor **ops, int count) { + for (int i = 0; i < count; ++i) { + THArgCheck(THLongTensor_nDimension(ops[i]) > 0, i, "can't expand empty tensor %d", i); + } + + long *op_sizes[count]; + long op_dims[count]; + + for (int i = 0; i < count; ++i) { + op_sizes[i] = ops[i]->size; + op_dims[i] = ops[i]->nDimension; + } + + THLongStorage *sizes = THLongStorage_new(); + char error_buffer[1024]; + int ret = THLongStorage_inferSizeN(sizes, + count, + op_sizes, + op_dims, + error_buffer, + 1024); + + if(ret != 0) { + THLongStorage_free(sizes); + THError(error_buffer); + return; + } + + for (int i = 0; i < count; ++i) { + THLongTensor_expand(rets[i], ops[i], sizes); + } + + THLongStorage_free(sizes); +} + + + +// Polyfilling expand functions for Long: + + + +THHalfTensor* THHalfTensor_newExpand(THHalfTensor *tensor, THLongStorage *sizes) { + THHalfTensor *result = THHalfTensor_new(); + THHalfTensor_expand(result, tensor, sizes); + return result; +} + +void THHalfTensor_expand(THHalfTensor *r, THHalfTensor *tensor, THLongStorage *sizes) { + THArgCheck(THHalfTensor_nDimension(tensor) > 0, 0, "can't expand an empty tensor"); + THArgCheck(THLongStorage_size(sizes) >= THHalfTensor_nDimension(tensor), 1, + "the number of sizes provided must be greater or equal to the " + "number of dimensions in the tensor"); + + long *expandedSizes; + long *expandedStrides; + char error_buffer[1024]; + int ret = + THLongStorage_inferExpandGeometry(tensor->size, tensor->stride, THHalfTensor_nDimension(tensor), + sizes, &expandedSizes, &expandedStrides, error_buffer, 1024); + + if (ret != 0) { + THError(error_buffer); + return; + } + + THHalfTensor_setStorageNd(r, THHalfTensor_storage(tensor), THHalfTensor_storageOffset(tensor), + THLongStorage_size(sizes), expandedSizes, expandedStrides); + THFree(expandedSizes); + THFree(expandedStrides); +} + + +void THHalfTensor_expandNd(THHalfTensor **rets, THHalfTensor **ops, int count) { + for (int i = 0; i < count; ++i) { + THArgCheck(THHalfTensor_nDimension(ops[i]) > 0, i, "can't expand empty tensor %d", i); + } + + long *op_sizes[count]; + long op_dims[count]; + + for (int i = 0; i < count; ++i) { + op_sizes[i] = ops[i]->size; + op_dims[i] = ops[i]->nDimension; + } + + THLongStorage *sizes = THLongStorage_new(); + char error_buffer[1024]; + int ret = THLongStorage_inferSizeN(sizes, + count, + op_sizes, + op_dims, + error_buffer, + 1024); + + if(ret != 0) { + THLongStorage_free(sizes); + THError(error_buffer); + return; + } + + for (int i = 0; i < count; ++i) { + THHalfTensor_expand(rets[i], ops[i], sizes); + } + + THLongStorage_free(sizes); +} + + + +// Polyfilling expand functions for Half: + + + +THFloatTensor* THFloatTensor_newExpand(THFloatTensor *tensor, THLongStorage *sizes) { + THFloatTensor *result = THFloatTensor_new(); + THFloatTensor_expand(result, tensor, sizes); + return result; +} + +void THFloatTensor_expand(THFloatTensor *r, THFloatTensor *tensor, THLongStorage *sizes) { + THArgCheck(THFloatTensor_nDimension(tensor) > 0, 0, "can't expand an empty tensor"); + THArgCheck(THLongStorage_size(sizes) >= THFloatTensor_nDimension(tensor), 1, + "the number of sizes provided must be greater or equal to the " + "number of dimensions in the tensor"); + + long *expandedSizes; + long *expandedStrides; + char error_buffer[1024]; + int ret = + THLongStorage_inferExpandGeometry(tensor->size, tensor->stride, THFloatTensor_nDimension(tensor), + sizes, &expandedSizes, &expandedStrides, error_buffer, 1024); + + if (ret != 0) { + THError(error_buffer); + return; + } + + THFloatTensor_setStorageNd(r, THFloatTensor_storage(tensor), THFloatTensor_storageOffset(tensor), + THLongStorage_size(sizes), expandedSizes, expandedStrides); + THFree(expandedSizes); + THFree(expandedStrides); +} + + +void THFloatTensor_expandNd(THFloatTensor **rets, THFloatTensor **ops, int count) { + for (int i = 0; i < count; ++i) { + THArgCheck(THFloatTensor_nDimension(ops[i]) > 0, i, "can't expand empty tensor %d", i); + } + + long *op_sizes[count]; + long op_dims[count]; + + for (int i = 0; i < count; ++i) { + op_sizes[i] = ops[i]->size; + op_dims[i] = ops[i]->nDimension; + } + + THLongStorage *sizes = THLongStorage_new(); + char error_buffer[1024]; + int ret = THLongStorage_inferSizeN(sizes, + count, + op_sizes, + op_dims, + error_buffer, + 1024); + + if(ret != 0) { + THLongStorage_free(sizes); + THError(error_buffer); + return; + } + + for (int i = 0; i < count; ++i) { + THFloatTensor_expand(rets[i], ops[i], sizes); + } + + THLongStorage_free(sizes); +} + + + +// Polyfilling expand functions for Float: + + + +THDoubleTensor* THDoubleTensor_newExpand(THDoubleTensor *tensor, THLongStorage *sizes) { + THDoubleTensor *result = THDoubleTensor_new(); + THDoubleTensor_expand(result, tensor, sizes); + return result; +} + +void THDoubleTensor_expand(THDoubleTensor *r, THDoubleTensor *tensor, THLongStorage *sizes) { + THArgCheck(THDoubleTensor_nDimension(tensor) > 0, 0, "can't expand an empty tensor"); + THArgCheck(THLongStorage_size(sizes) >= THDoubleTensor_nDimension(tensor), 1, + "the number of sizes provided must be greater or equal to the " + "number of dimensions in the tensor"); + + long *expandedSizes; + long *expandedStrides; + char error_buffer[1024]; + int ret = + THLongStorage_inferExpandGeometry(tensor->size, tensor->stride, THDoubleTensor_nDimension(tensor), + sizes, &expandedSizes, &expandedStrides, error_buffer, 1024); + + if (ret != 0) { + THError(error_buffer); + return; + } + + THDoubleTensor_setStorageNd(r, THDoubleTensor_storage(tensor), THDoubleTensor_storageOffset(tensor), + THLongStorage_size(sizes), expandedSizes, expandedStrides); + THFree(expandedSizes); + THFree(expandedStrides); +} + + +void THDoubleTensor_expandNd(THDoubleTensor **rets, THDoubleTensor **ops, int count) { + for (int i = 0; i < count; ++i) { + THArgCheck(THDoubleTensor_nDimension(ops[i]) > 0, i, "can't expand empty tensor %d", i); + } + + long *op_sizes[count]; + long op_dims[count]; + + for (int i = 0; i < count; ++i) { + op_sizes[i] = ops[i]->size; + op_dims[i] = ops[i]->nDimension; + } + + THLongStorage *sizes = THLongStorage_new(); + char error_buffer[1024]; + int ret = THLongStorage_inferSizeN(sizes, + count, + op_sizes, + op_dims, + error_buffer, + 1024); + + if(ret != 0) { + THLongStorage_free(sizes); + THError(error_buffer); + return; + } + + for (int i = 0; i < count; ++i) { + THDoubleTensor_expand(rets[i], ops[i], sizes); + } + + THLongStorage_free(sizes); +} + + + +// Polyfilling expand functions for Double: + + diff --git a/cbits/finalizers.c b/cbits/finalizers.c new file mode 100644 --- /dev/null +++ b/cbits/finalizers.c @@ -0,0 +1,84 @@ +#include "TH/THStorage.h" +#include "TH/THTensor.h" + +// Byte types +//================================================ +void free_ByteStorage(void* s, THByteStorage * x) { + THByteStorage_free(x); +}; + +void free_ByteTensor(void* s, THByteTensor * x) { + THByteTensor_free(x); +}; + +// Char types +//================================================ +void free_CharStorage(void* s, THCharStorage * x) { + THCharStorage_free(x); +}; + +void free_CharTensor(void* s, THCharTensor * x) { + THCharTensor_free(x); +}; + +// Int types +//================================================ +void free_IntStorage(void* s, THIntStorage * x) { + THIntStorage_free(x); +}; + +void free_IntTensor(void* s, THIntTensor * x) { + THIntTensor_free(x); +}; + +// Short types +//================================================ +void free_ShortStorage(void* s, THShortStorage * x) { + THShortStorage_free(x); +}; + +void free_ShortTensor(void* s, THShortTensor * x) { + THShortTensor_free(x); +}; + +// Long types +//================================================ +void free_LongStorage(void* s, THLongStorage * x) { + THLongStorage_free(x); +}; + +void free_LongTensor(void* s, THLongTensor * x) { + THLongTensor_free(x); +}; + +// Half types +//================================================ +void free_HalfStorage(void* s, THHalfStorage * x) { + THHalfStorage_free(x); +}; + +void free_HalfTensor(void* s, THHalfTensor * x) { + THHalfTensor_free(x); +}; + +// Float types +//================================================ +void free_FloatStorage(void* s, THFloatStorage * x) { + THFloatStorage_free(x); +}; + +void free_FloatTensor(void* s, THFloatTensor * x) { + THFloatTensor_free(x); +}; + +// Double types +//================================================ +void free_DoubleStorage(void* s, THDoubleStorage * x) { + THDoubleStorage_free(x); +}; + +void free_DoubleTensor(void* s, THDoubleTensor * x) { + THDoubleTensor_free(x); +}; + + diff --git a/hasktorch-ffi-th.cabal b/hasktorch-ffi-th.cabal new file mode 100644 --- /dev/null +++ b/hasktorch-ffi-th.cabal @@ -0,0 +1,173 @@ +cabal-version: 2.2 +-- * * * * * * * * * * * * WARNING * * * * * * * * * * * * +-- This file has been AUTO-GENERATED by dhall-to-cabal. +-- +-- Do not edit it by hand, because your changes will be over-written! +-- +-- Instead, edit the source Dhall file, namely +-- 'ffi/ffi/th/hasktorch-ffi-th.dhall', and re-generate this file by running +-- 'dhall-to-cabal -- ffi/ffi/th/hasktorch-ffi-th.dhall > hasktorch-ffi-th.cabal'. +-- * * * * * * * * * * * * WARNING * * * * * * * * * * * * +name: hasktorch-ffi-th +version: 0.0.1.0 +license: BSD-3-Clause +maintainer: Sam Stites , Austin Huang - cipher:ROT13 +author: Hasktorch dev team +homepage: https://github.com/hasktorch/hasktorch#readme +bug-reports: https://github.com/hasktorch/hasktorch/issues +synopsis: Bindings to Torch +description: + Torch (and THNN) FFI bindings for CPU-based tensors and neural networks in Haskell +category: Tensors, Machine Learning, AI, FFI +build-type: Simple + +source-repository head + type: git + location: https://github.com/hasktorch/hasktorch + +flag half + description: + build with half support + default: False + +flag lite + description: + only build with Double and Long support + default: False + +library + exposed-modules: + Torch.FFI.TH.DiskFile + Torch.FFI.TH.File + Torch.FFI.TH.LogAdd + Torch.FFI.TH.MemoryFile + Torch.FFI.TH.Random + Torch.FFI.TH.Size + Torch.FFI.TH.Storage + Torch.FFI.TH.Double.Blas + Torch.FFI.TH.Double.Storage + Torch.FFI.TH.Double.StorageCopy + Torch.FFI.TH.Double.Tensor + Torch.FFI.TH.Double.TensorConv + Torch.FFI.TH.Double.TensorCopy + Torch.FFI.TH.Double.TensorMath + Torch.FFI.TH.Double.TensorRandom + Torch.FFI.TH.Double.Vector + Torch.FFI.TH.Double.FreeTensor + Torch.FFI.TH.Double.FreeStorage + Torch.FFI.TH.Double.Lapack + Torch.FFI.TH.Double.TensorLapack + Torch.FFI.TH.Long.Blas + Torch.FFI.TH.Long.Storage + Torch.FFI.TH.Long.StorageCopy + Torch.FFI.TH.Long.Tensor + Torch.FFI.TH.Long.TensorConv + Torch.FFI.TH.Long.TensorCopy + Torch.FFI.TH.Long.TensorMath + Torch.FFI.TH.Long.TensorRandom + Torch.FFI.TH.Long.Vector + Torch.FFI.TH.Long.FreeTensor + Torch.FFI.TH.Long.FreeStorage + Torch.FFI.TH.NN.Double + build-tools: c2hs -any + c-sources: + cbits/finalizers.c + cbits/expand_polyfill.c + hs-source-dirs: src nn polyfill + other-modules: + Paths_hasktorch_ffi_th + autogen-modules: + Paths_hasktorch_ffi_th + default-language: Haskell2010 + extra-libraries: + ATen + build-depends: + base (==4.7 || >4.7) && <5, + hasktorch-types-th (==0.0.1 || >0.0.1) && <0.0.2, + inline-c ==0.5 || >0.5, + text ==1.2.2 || >1.2.2 + + if flag(half) + cc-options: -DHALF + else + + if flag(lite) + else + exposed-modules: + Torch.FFI.TH.Byte.Blas + Torch.FFI.TH.Byte.Storage + Torch.FFI.TH.Byte.StorageCopy + Torch.FFI.TH.Byte.Tensor + Torch.FFI.TH.Byte.TensorConv + Torch.FFI.TH.Byte.TensorCopy + Torch.FFI.TH.Byte.TensorMath + Torch.FFI.TH.Byte.TensorRandom + Torch.FFI.TH.Byte.Vector + Torch.FFI.TH.Byte.FreeTensor + Torch.FFI.TH.Byte.FreeStorage + Torch.FFI.TH.Char.Blas + Torch.FFI.TH.Char.Storage + Torch.FFI.TH.Char.StorageCopy + Torch.FFI.TH.Char.Tensor + Torch.FFI.TH.Char.TensorConv + Torch.FFI.TH.Char.TensorCopy + Torch.FFI.TH.Char.TensorMath + Torch.FFI.TH.Char.TensorRandom + Torch.FFI.TH.Char.Vector + Torch.FFI.TH.Char.FreeTensor + Torch.FFI.TH.Char.FreeStorage + Torch.FFI.TH.Int.Blas + Torch.FFI.TH.Int.Storage + Torch.FFI.TH.Int.StorageCopy + Torch.FFI.TH.Int.Tensor + Torch.FFI.TH.Int.TensorConv + Torch.FFI.TH.Int.TensorCopy + Torch.FFI.TH.Int.TensorMath + Torch.FFI.TH.Int.TensorRandom + Torch.FFI.TH.Int.Vector + Torch.FFI.TH.Int.FreeTensor + Torch.FFI.TH.Int.FreeStorage + Torch.FFI.TH.Short.Blas + Torch.FFI.TH.Short.Storage + Torch.FFI.TH.Short.StorageCopy + Torch.FFI.TH.Short.Tensor + Torch.FFI.TH.Short.TensorConv + Torch.FFI.TH.Short.TensorCopy + Torch.FFI.TH.Short.TensorMath + Torch.FFI.TH.Short.TensorRandom + Torch.FFI.TH.Short.Vector + Torch.FFI.TH.Short.FreeTensor + Torch.FFI.TH.Short.FreeStorage + Torch.FFI.TH.Float.Blas + Torch.FFI.TH.Float.Storage + Torch.FFI.TH.Float.StorageCopy + Torch.FFI.TH.Float.Tensor + Torch.FFI.TH.Float.TensorConv + Torch.FFI.TH.Float.TensorCopy + Torch.FFI.TH.Float.TensorMath + Torch.FFI.TH.Float.TensorRandom + Torch.FFI.TH.Float.Vector + Torch.FFI.TH.Float.FreeTensor + Torch.FFI.TH.Float.FreeStorage + Torch.FFI.TH.Float.Lapack + Torch.FFI.TH.Float.TensorLapack + Torch.FFI.TH.NN.Float + +test-suite spec + type: exitcode-stdio-1.0 + main-is: Spec.hs + hs-source-dirs: tests + other-modules: + MathSpec + TensorSpec + NNSpec + default-language: Haskell2010 + build-depends: + base (==4.7 || >4.7) && <5, + QuickCheck ==2.11 || >2.11, + hasktorch-ffi-tests (==0.0.1 || >0.0.1) && <0.0.2, + hasktorch-ffi-th -any, + hasktorch-types-th (==0.0.1 || >0.0.1) && <0.0.2, + hspec ==2.4.4 || >2.4.4, + text ==1.2.2 || >1.2.2 + diff --git a/nn/Torch/FFI/TH/NN/Double.hs b/nn/Torch/FFI/TH/NN/Double.hs new file mode 100644 --- /dev/null +++ b/nn/Torch/FFI/TH/NN/Double.hs @@ -0,0 +1,1576 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.NN.Double where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_Abs_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_DoubleAbs_updateOutput" + c_Abs_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_Abs_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_DoubleAbs_updateGradInput" + c_Abs_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_AbsCriterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleAbsCriterion_updateOutput" + c_AbsCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_AbsCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleAbsCriterion_updateGradInput" + c_AbsCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_BCECriterion_updateOutput : state input target output sizeAverage weights reduce -> void +foreign import ccall "THNN.h THNN_DoubleBCECriterion_updateOutput" + c_BCECriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> CBool -> IO () + +-- | c_BCECriterion_updateGradInput : state input target gradOutput gradInput sizeAverage weights reduce -> void +foreign import ccall "THNN.h THNN_DoubleBCECriterion_updateGradInput" + c_BCECriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> CBool -> IO () + +-- | c_ClassNLLCriterion_updateOutput : state input target output sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h THNN_DoubleClassNLLCriterion_updateOutput" + c_ClassNLLCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CBool -> IO () + +-- | c_ClassNLLCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h THNN_DoubleClassNLLCriterion_updateGradInput" + c_ClassNLLCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CBool -> IO () + +-- | c_SpatialClassNLLCriterion_updateOutput : state input target output sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h THNN_DoubleSpatialClassNLLCriterion_updateOutput" + c_SpatialClassNLLCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CBool -> IO () + +-- | c_SpatialClassNLLCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h THNN_DoubleSpatialClassNLLCriterion_updateGradInput" + c_SpatialClassNLLCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CBool -> IO () + +-- | c_ELU_updateOutput : state input output alpha scale inplace -> void +foreign import ccall "THNN.h THNN_DoubleELU_updateOutput" + c_ELU_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_ELU_updateGradInput : state gradOutput gradInput output alpha scale -> void +foreign import ccall "THNN.h THNN_DoubleELU_updateGradInput" + c_ELU_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | c_DistKLDivCriterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleDistKLDivCriterion_updateOutput" + c_DistKLDivCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_DistKLDivCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleDistKLDivCriterion_updateGradInput" + c_DistKLDivCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_GatedLinear_updateOutput : state input output dim -> void +foreign import ccall "THNN.h THNN_DoubleGatedLinear_updateOutput" + c_GatedLinear_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_GatedLinear_updateGradInput : state input gradOutput gradInput dim -> void +foreign import ccall "THNN.h THNN_DoubleGatedLinear_updateGradInput" + c_GatedLinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_HardShrink_updateOutput : state input output lambda -> void +foreign import ccall "THNN.h THNN_DoubleHardShrink_updateOutput" + c_HardShrink_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | c_HardShrink_updateGradInput : state input gradOutput gradInput lambda -> void +foreign import ccall "THNN.h THNN_DoubleHardShrink_updateGradInput" + c_HardShrink_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | c_HardTanh_updateOutput : state input output min_val max_val inplace -> void +foreign import ccall "THNN.h THNN_DoubleHardTanh_updateOutput" + c_HardTanh_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_HardTanh_updateGradInput : state input gradOutput gradInput min_val max_val inplace -> void +foreign import ccall "THNN.h THNN_DoubleHardTanh_updateGradInput" + c_HardTanh_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_Im2Col_updateOutput : state input output kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h THNN_DoubleIm2Col_updateOutput" + c_Im2Col_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_Im2Col_updateGradInput : state gradOutput gradInput inputHeight inputWidth kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h THNN_DoubleIm2Col_updateGradInput" + c_Im2Col_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_Col2Im_updateOutput : state input output outputHeight outputWidth kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h THNN_DoubleCol2Im_updateOutput" + c_Col2Im_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_Col2Im_updateGradInput : state gradOutput gradInput kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h THNN_DoubleCol2Im_updateGradInput" + c_Col2Im_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_L1Cost_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_DoubleL1Cost_updateOutput" + c_L1Cost_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_L1Cost_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_DoubleL1Cost_updateGradInput" + c_L1Cost_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_LeakyReLU_updateOutput : state input output negval inplace -> void +foreign import ccall "THNN.h THNN_DoubleLeakyReLU_updateOutput" + c_LeakyReLU_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CBool -> IO () + +-- | c_LeakyReLU_updateGradInput : state input gradOutput gradInput negval inplace -> void +foreign import ccall "THNN.h THNN_DoubleLeakyReLU_updateGradInput" + c_LeakyReLU_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CBool -> IO () + +-- | c_GRUFused_updateOutput : state input hidden bias1 bias2 hx output storage -> void +foreign import ccall "THNN.h THNN_DoubleGRUFused_updateOutput" + c_GRUFused_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_GRUFused_updateGradInput : state gradInInput gradInHidden gradOutput gradInputHx storage -> void +foreign import ccall "THNN.h THNN_DoubleGRUFused_updateGradInput" + c_GRUFused_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_LSTMFused_updateOutput : state input hidden bias1 bias2 cell output outputCell -> void +foreign import ccall "THNN.h THNN_DoubleLSTMFused_updateOutput" + c_LSTMFused_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_LSTMFused_updateGradInput : state storage gradInGates cx cy gradOutput gradOutputCell gradInputCx -> void +foreign import ccall "THNN.h THNN_DoubleLSTMFused_updateGradInput" + c_LSTMFused_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_LogSigmoid_updateOutput : state input output buffer -> void +foreign import ccall "THNN.h THNN_DoubleLogSigmoid_updateOutput" + c_LogSigmoid_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_LogSigmoid_updateGradInput : state input gradOutput gradInput buffer -> void +foreign import ccall "THNN.h THNN_DoubleLogSigmoid_updateGradInput" + c_LogSigmoid_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_LogSoftMax_updateOutput : state input output dim -> void +foreign import ccall "THNN.h THNN_DoubleLogSoftMax_updateOutput" + c_LogSoftMax_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO () + +-- | c_LogSoftMax_updateGradInput : state input gradOutput gradInput output dim -> void +foreign import ccall "THNN.h THNN_DoubleLogSoftMax_updateGradInput" + c_LogSoftMax_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO () + +-- | c_LookupTable_accGradParameters : state input gradOutput gradWeight count sorted indices scaleGradByFreq paddingValue scale -> void +foreign import ccall "THNN.h THNN_DoubleLookupTable_accGradParameters" + c_LookupTable_accGradParameters :: Ptr C'THNNState -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIntegerTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CBool -> CInt -> CDouble -> IO () + +-- | c_LookupTable_renorm : state idx weight maxNorm normType -> void +foreign import ccall "THNN.h THNN_DoubleLookupTable_renorm" + c_LookupTable_renorm :: Ptr C'THNNState -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | c_MarginCriterion_updateOutput : state input target output sizeAverage margin -> void +foreign import ccall "THNN.h THNN_DoubleMarginCriterion_updateOutput" + c_MarginCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CDouble -> IO () + +-- | c_MarginCriterion_updateGradInput : state input target gradInput sizeAverage margin -> void +foreign import ccall "THNN.h THNN_DoubleMarginCriterion_updateGradInput" + c_MarginCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CDouble -> IO () + +-- | c_SoftMarginCriterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleSoftMarginCriterion_updateOutput" + c_SoftMarginCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_SoftMarginCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleSoftMarginCriterion_updateGradInput" + c_SoftMarginCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_MSECriterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleMSECriterion_updateOutput" + c_MSECriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_MSECriterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleMSECriterion_updateGradInput" + c_MSECriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_MultiLabelMarginCriterion_updateOutput : state input target output isTarget sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleMultiLabelMarginCriterion_updateOutput" + c_MultiLabelMarginCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_MultiLabelMarginCriterion_updateGradInput : state input target gradOutput gradInput isTarget sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleMultiLabelMarginCriterion_updateGradInput" + c_MultiLabelMarginCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_MultiMarginCriterion_updateOutput : state input target output sizeAverage p weights margin reduce -> void +foreign import ccall "THNN.h THNN_DoubleMultiMarginCriterion_updateOutput" + c_MultiMarginCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> CBool -> CInt -> Ptr C'THDoubleTensor -> CDouble -> CBool -> IO () + +-- | c_MultiMarginCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage p weights margin reduce -> void +foreign import ccall "THNN.h THNN_DoubleMultiMarginCriterion_updateGradInput" + c_MultiMarginCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CInt -> Ptr C'THDoubleTensor -> CDouble -> CBool -> IO () + +-- | c_PReLU_updateOutput : state input output weight -> void +foreign import ccall "THNN.h THNN_DoublePReLU_updateOutput" + c_PReLU_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_PReLU_updateGradInput : state input gradOutput gradInput weight -> void +foreign import ccall "THNN.h THNN_DoublePReLU_updateGradInput" + c_PReLU_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_PReLU_accGradParameters : state input gradOutput gradInput weight gradWeight scale -> void +foreign import ccall "THNN.h THNN_DoublePReLU_accGradParameters" + c_PReLU_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | c_Linear_updateOutput : state input output weight bias addBuffer -> void +foreign import ccall "THNN.h THNN_DoubleLinear_updateOutput" + c_Linear_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_Linear_updateGradInput : state input gradOutput gradInput weight -> void +foreign import ccall "THNN.h THNN_DoubleLinear_updateGradInput" + c_Linear_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_Linear_accGradParameters : state input gradOutput gradInput weight bias gradWeight gradBias addBuffer scale -> void +foreign import ccall "THNN.h THNN_DoubleLinear_accGradParameters" + c_Linear_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | c_RReLU_updateOutput : state input output noise lower upper train inplace generator -> void +foreign import ccall "THNN.h THNN_DoubleRReLU_updateOutput" + c_RReLU_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> CBool -> Ptr C'THGenerator -> IO () + +-- | c_RReLU_updateGradInput : state input gradOutput gradInput noise lower upper train inplace -> void +foreign import ccall "THNN.h THNN_DoubleRReLU_updateGradInput" + c_RReLU_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> CBool -> IO () + +-- | c_Sigmoid_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_DoubleSigmoid_updateOutput" + c_Sigmoid_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_Sigmoid_updateGradInput : state gradOutput gradInput output -> void +foreign import ccall "THNN.h THNN_DoubleSigmoid_updateGradInput" + c_Sigmoid_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_SmoothL1Criterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleSmoothL1Criterion_updateOutput" + c_SmoothL1Criterion_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_SmoothL1Criterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_DoubleSmoothL1Criterion_updateGradInput" + c_SmoothL1Criterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO () + +-- | c_SoftMax_updateOutput : state input output dim -> void +foreign import ccall "THNN.h THNN_DoubleSoftMax_updateOutput" + c_SoftMax_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO () + +-- | c_SoftMax_updateGradInput : state input gradOutput gradInput output dim -> void +foreign import ccall "THNN.h THNN_DoubleSoftMax_updateGradInput" + c_SoftMax_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO () + +-- | c_SoftPlus_updateOutput : state input output beta threshold -> void +foreign import ccall "THNN.h THNN_DoubleSoftPlus_updateOutput" + c_SoftPlus_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | c_SoftPlus_updateGradInput : state input gradOutput gradInput output beta threshold -> void +foreign import ccall "THNN.h THNN_DoubleSoftPlus_updateGradInput" + c_SoftPlus_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | c_SoftShrink_updateOutput : state input output lambda -> void +foreign import ccall "THNN.h THNN_DoubleSoftShrink_updateOutput" + c_SoftShrink_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | c_SoftShrink_updateGradInput : state input gradOutput gradInput lambda -> void +foreign import ccall "THNN.h THNN_DoubleSoftShrink_updateGradInput" + c_SoftShrink_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | c_IndexLinear_updateOutput : state keys keysOffset values sizes cumSumSizes output weight bias normalizedValues train -> void +foreign import ccall "THNN.h THNN_DoubleIndexLinear_updateOutput" + c_IndexLinear_updateOutput :: Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_IndexLinear_accGradParameters : state keys keysOffset values sizes cumSumSizes gradOutput gradWeight gradBias weight bias valuesBuffer weightDecay scale -> void +foreign import ccall "THNN.h THNN_DoubleIndexLinear_accGradParameters" + c_IndexLinear_accGradParameters :: Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | c_IndexLinear_accUpdateGradParameters : state keys keysOffset values sizes cumSumSizes gradOutput weight bias weightDecay scale -> void +foreign import ccall "THNN.h THNN_DoubleIndexLinear_accUpdateGradParameters" + c_IndexLinear_accUpdateGradParameters :: Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | c_IndexLinear_updateParameters : state gradWeight gradBias weight bias runningKeys cumSumSizes keysOffset weightDecay learningRate -> void +foreign import ccall "THNN.h THNN_DoubleIndexLinear_updateParameters" + c_IndexLinear_updateParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> CLLong -> CDouble -> CDouble -> IO () + +-- | c_SparseLinear_updateOutput : state input output weight bias -> void +foreign import ccall "THNN.h THNN_DoubleSparseLinear_updateOutput" + c_SparseLinear_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_SparseLinear_accGradParameters : state input gradOutput gradWeight gradBias weight bias weightDecay scale -> void +foreign import ccall "THNN.h THNN_DoubleSparseLinear_accGradParameters" + c_SparseLinear_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | c_SparseLinear_zeroGradParameters : state gradWeight gradBias lastInput -> void +foreign import ccall "THNN.h THNN_DoubleSparseLinear_zeroGradParameters" + c_SparseLinear_zeroGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_SparseLinear_updateParameters : state weight bias gradWeight gradBias lastInput learningRate -> void +foreign import ccall "THNN.h THNN_DoubleSparseLinear_updateParameters" + c_SparseLinear_updateParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | c_SparseLinear_legacyUpdateOutput : state input output weight bias -> void +foreign import ccall "THNN.h THNN_DoubleSparseLinear_legacyUpdateOutput" + c_SparseLinear_legacyUpdateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_SparseLinear_legacyAccGradParameters : state input gradOutput gradWeight gradBias weight bias weightDecay scale -> void +foreign import ccall "THNN.h THNN_DoubleSparseLinear_legacyAccGradParameters" + c_SparseLinear_legacyAccGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | c_SparseLinear_legacyZeroGradParameters : state gradWeight gradBias lastInput -> void +foreign import ccall "THNN.h THNN_DoubleSparseLinear_legacyZeroGradParameters" + c_SparseLinear_legacyZeroGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_SparseLinear_legacyUpdateParameters : state weight bias gradWeight gradBias lastInput learningRate -> void +foreign import ccall "THNN.h THNN_DoubleSparseLinear_legacyUpdateParameters" + c_SparseLinear_legacyUpdateParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | c_Sqrt_updateOutput : state input output eps -> void +foreign import ccall "THNN.h THNN_DoubleSqrt_updateOutput" + c_Sqrt_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | c_Sqrt_updateGradInput : state input gradOutput gradInput output -> void +foreign import ccall "THNN.h THNN_DoubleSqrt_updateGradInput" + c_Sqrt_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_Square_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_DoubleSquare_updateOutput" + c_Square_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_Square_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_DoubleSquare_updateGradInput" + c_Square_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_Tanh_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_DoubleTanh_updateOutput" + c_Tanh_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_Tanh_updateGradInput : state gradOutput gradInput output -> void +foreign import ccall "THNN.h THNN_DoubleTanh_updateGradInput" + c_Tanh_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_Threshold_updateOutput : state input output threshold val inplace -> void +foreign import ccall "THNN.h THNN_DoubleThreshold_updateOutput" + c_Threshold_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_Threshold_updateGradInput : state input gradOutput gradInput threshold val inplace -> void +foreign import ccall "THNN.h THNN_DoubleThreshold_updateGradInput" + c_Threshold_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_TemporalConvolution_updateOutput : state input output weight bias kW dW inputFrameSize outputFrameSize -> void +foreign import ccall "THNN.h THNN_DoubleTemporalConvolution_updateOutput" + c_TemporalConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_TemporalConvolution_updateGradInput : state input gradOutput gradInput weight kW dW -> void +foreign import ccall "THNN.h THNN_DoubleTemporalConvolution_updateGradInput" + c_TemporalConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | c_TemporalConvolution_accGradParameters : state input gradOutput gradWeight gradBias kW dW scale -> void +foreign import ccall "THNN.h THNN_DoubleTemporalConvolution_accGradParameters" + c_TemporalConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CDouble -> IO () + +-- | c_TemporalMaxPooling_updateOutput : state input output indices kW dW -> void +foreign import ccall "THNN.h THNN_DoubleTemporalMaxPooling_updateOutput" + c_TemporalMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_TemporalMaxPooling_updateGradInput : state input gradOutput gradInput indices kW dW -> void +foreign import ccall "THNN.h THNN_DoubleTemporalMaxPooling_updateGradInput" + c_TemporalMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_TemporalSubSampling_updateOutput : state input output weight bias kW dW inputFrameSize -> void +foreign import ccall "THNN.h THNN_DoubleTemporalSubSampling_updateOutput" + c_TemporalSubSampling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO () + +-- | c_TemporalSubSampling_updateGradInput : state input gradOutput gradInput weight kW dW -> void +foreign import ccall "THNN.h THNN_DoubleTemporalSubSampling_updateGradInput" + c_TemporalSubSampling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | c_TemporalSubSampling_accGradParameters : state input gradOutput gradWeight gradBias kW dW scale -> void +foreign import ccall "THNN.h THNN_DoubleTemporalSubSampling_accGradParameters" + c_TemporalSubSampling_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CDouble -> IO () + +-- | c_TemporalRowConvolution_updateOutput : state input output weight bias finput fgradInput kW dW padW featFirst -> void +foreign import ccall "THNN.h THNN_DoubleTemporalRowConvolution_updateOutput" + c_TemporalRowConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_TemporalRowConvolution_updateGradInput : state input gradOutput gradInput weight finput fgradInput kW dW padW featFirst -> void +foreign import ccall "THNN.h THNN_DoubleTemporalRowConvolution_updateGradInput" + c_TemporalRowConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_TemporalRowConvolution_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kW dW padW featFirst scale -> void +foreign import ccall "THNN.h THNN_DoubleTemporalRowConvolution_accGradParameters" + c_TemporalRowConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CBool -> CDouble -> IO () + +-- | c_TemporalUpSamplingNearest_updateOutput : state input output scale_factor -> void +foreign import ccall "THNN.h THNN_DoubleTemporalUpSamplingNearest_updateOutput" + c_TemporalUpSamplingNearest_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_TemporalUpSamplingNearest_updateGradInput : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h THNN_DoubleTemporalUpSamplingNearest_updateGradInput" + c_TemporalUpSamplingNearest_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_TemporalUpSamplingLinear_updateOutput : state input output osizeW -> void +foreign import ccall "THNN.h THNN_DoubleTemporalUpSamplingLinear_updateOutput" + c_TemporalUpSamplingLinear_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_TemporalUpSamplingLinear_updateGradInput : state gradOutput gradInput isizeB isizeC isizeW osizeW -> void +foreign import ccall "THNN.h THNN_DoubleTemporalUpSamplingLinear_updateGradInput" + c_TemporalUpSamplingLinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_BatchNormalization_updateOutput : state input output weight bias running_mean running_var save_mean save_std train momentum eps -> void +foreign import ccall "THNN.h THNN_DoubleBatchNormalization_updateOutput" + c_BatchNormalization_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CDouble -> CDouble -> IO () + +-- | c_BatchNormalization_backward : state input gradOutput gradInput gradWeight gradBias weight running_mean running_var save_mean save_std train scale eps -> void +foreign import ccall "THNN.h THNN_DoubleBatchNormalization_backward" + c_BatchNormalization_backward :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CDouble -> CDouble -> IO () + +-- | c_SpatialConvolutionMap_updateOutput : state input output weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialConvolutionMap_updateOutput" + c_SpatialConvolutionMap_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialConvolutionMap_updateGradInput : state input gradOutput gradInput weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialConvolutionMap_updateGradInput" + c_SpatialConvolutionMap_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialConvolutionMap_accGradParameters : state input gradOutput gradWeight gradBias connTable nInputPlane nOutputPlane dW dH scale -> void +foreign import ccall "THNN.h THNN_DoubleSpatialConvolutionMap_accGradParameters" + c_SpatialConvolutionMap_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialConvolutionMM_updateOutput : state input output weight bias finput fgradInput kW kH dW dH padW padH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialConvolutionMM_updateOutput" + c_SpatialConvolutionMM_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialConvolutionMM_updateGradInput : state input gradOutput gradInput weight finput fgradInput kW kH dW dH padW padH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialConvolutionMM_updateGradInput" + c_SpatialConvolutionMM_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialConvolutionMM_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kW kH dW dH padW padH scale -> void +foreign import ccall "THNN.h THNN_DoubleSpatialConvolutionMM_accGradParameters" + c_SpatialConvolutionMM_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialConvolutionLocal_updateOutput : state input output weight bias finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h THNN_DoubleSpatialConvolutionLocal_updateOutput" + c_SpatialConvolutionLocal_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | c_SpatialConvolutionLocal_updateGradInput : state input gradOutput gradInput weight finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h THNN_DoubleSpatialConvolutionLocal_updateGradInput" + c_SpatialConvolutionLocal_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | c_SpatialConvolutionLocal_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight scale -> void +foreign import ccall "THNN.h THNN_DoubleSpatialConvolutionLocal_accGradParameters" + c_SpatialConvolutionLocal_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CDouble -> IO () + +-- | c_SpatialAdaptiveMaxPooling_updateOutput : state input output indices osizeW osizeH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialAdaptiveMaxPooling_updateOutput" + c_SpatialAdaptiveMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_SpatialAdaptiveMaxPooling_updateGradInput : state input gradOutput gradInput indices -> void +foreign import ccall "THNN.h THNN_DoubleSpatialAdaptiveMaxPooling_updateGradInput" + c_SpatialAdaptiveMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> IO () + +-- | c_SpatialAdaptiveAveragePooling_updateOutput : state input output osizeW osizeH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialAdaptiveAveragePooling_updateOutput" + c_SpatialAdaptiveAveragePooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | c_SpatialAdaptiveAveragePooling_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_DoubleSpatialAdaptiveAveragePooling_updateGradInput" + c_SpatialAdaptiveAveragePooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_SpatialAveragePooling_updateOutput : state input output kW kH dW dH padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h THNN_DoubleSpatialAveragePooling_updateOutput" + c_SpatialAveragePooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO () + +-- | c_SpatialAveragePooling_updateGradInput : state input gradOutput gradInput kW kH dW dH padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h THNN_DoubleSpatialAveragePooling_updateGradInput" + c_SpatialAveragePooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO () + +-- | c_SpatialFractionalMaxPooling_updateOutput : state input output outputW outputH kW kH indices randomSamples -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFractionalMaxPooling_updateOutput" + c_SpatialFractionalMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_SpatialFractionalMaxPooling_updateGradInput : state input gradOutput gradInput outputW outputH kW kH indices -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFractionalMaxPooling_updateGradInput" + c_SpatialFractionalMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> IO () + +-- | c_SpatialFullConvolution_updateOutput : state input output weight bias columns ones kW kH dW dH padW padH adjW adjH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFullConvolution_updateOutput" + c_SpatialFullConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullConvolution_updateGradInput : state input gradOutput gradInput weight columns kW kH dW dH padW padH adjW adjH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFullConvolution_updateGradInput" + c_SpatialFullConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullConvolution_accGradParameters : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH adjW adjH scale -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFullConvolution_accGradParameters" + c_SpatialFullConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialFullConvolutionMap_updateOutput : state input output weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFullConvolutionMap_updateOutput" + c_SpatialFullConvolutionMap_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullConvolutionMap_updateGradInput : state input gradOutput gradInput weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFullConvolutionMap_updateGradInput" + c_SpatialFullConvolutionMap_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullConvolutionMap_accGradParameters : state input gradOutput gradWeight gradBias connTable nInputPlane nOutputPlane dW dH scale -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFullConvolutionMap_accGradParameters" + c_SpatialFullConvolutionMap_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialDilatedConvolution_updateOutput : state input output weight bias columns ones kW kH dW dH padW padH dilationW dilationH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialDilatedConvolution_updateOutput" + c_SpatialDilatedConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialDilatedConvolution_updateGradInput : state input gradOutput gradInput weight columns kW kH dW dH padW padH dilationW dilationH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialDilatedConvolution_updateGradInput" + c_SpatialDilatedConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialDilatedConvolution_accGradParameters : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH dilationW dilationH scale -> void +foreign import ccall "THNN.h THNN_DoubleSpatialDilatedConvolution_accGradParameters" + c_SpatialDilatedConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialFullDilatedConvolution_updateOutput : state input output weight bias columns ones kW kH dW dH padW padH dilationW dilationH adjW adjH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFullDilatedConvolution_updateOutput" + c_SpatialFullDilatedConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullDilatedConvolution_updateGradInput : state input gradOutput gradInput weight columns kW kH dW dH padW padH dilationW dilationH adjW adjH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFullDilatedConvolution_updateGradInput" + c_SpatialFullDilatedConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullDilatedConvolution_accGradParameters : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH dilationW dilationH adjW adjH scale -> void +foreign import ccall "THNN.h THNN_DoubleSpatialFullDilatedConvolution_accGradParameters" + c_SpatialFullDilatedConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialMaxPooling_updateOutput : state input output indices kW kH dW dH padW padH ceil_mode -> void +foreign import ccall "THNN.h THNN_DoubleSpatialMaxPooling_updateOutput" + c_SpatialMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_SpatialMaxPooling_updateGradInput : state input gradOutput gradInput indices kW kH dW dH padW padH ceil_mode -> void +foreign import ccall "THNN.h THNN_DoubleSpatialMaxPooling_updateGradInput" + c_SpatialMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_SpatialDilatedMaxPooling_updateOutput : state input output indices kW kH dW dH padW padH dilationW dilationH ceil_mode -> void +foreign import ccall "THNN.h THNN_DoubleSpatialDilatedMaxPooling_updateOutput" + c_SpatialDilatedMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_SpatialDilatedMaxPooling_updateGradInput : state input gradOutput gradInput indices kW kH dW dH padW padH dilationW dilationH ceil_mode -> void +foreign import ccall "THNN.h THNN_DoubleSpatialDilatedMaxPooling_updateGradInput" + c_SpatialDilatedMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_SpatialMaxUnpooling_updateOutput : state input output indices owidth oheight -> void +foreign import ccall "THNN.h THNN_DoubleSpatialMaxUnpooling_updateOutput" + c_SpatialMaxUnpooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_SpatialMaxUnpooling_updateGradInput : state input gradOutput gradInput indices owidth oheight -> void +foreign import ccall "THNN.h THNN_DoubleSpatialMaxUnpooling_updateGradInput" + c_SpatialMaxUnpooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_SpatialSubSampling_updateOutput : state input output weight bias kW kH dW dH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialSubSampling_updateOutput" + c_SpatialSubSampling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialSubSampling_updateGradInput : state input gradOutput gradInput weight kW kH dW dH -> void +foreign import ccall "THNN.h THNN_DoubleSpatialSubSampling_updateGradInput" + c_SpatialSubSampling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialSubSampling_accGradParameters : state input gradOutput gradWeight gradBias kW kH dW dH scale -> void +foreign import ccall "THNN.h THNN_DoubleSpatialSubSampling_accGradParameters" + c_SpatialSubSampling_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialUpSamplingNearest_updateOutput : state input output scale_factor -> void +foreign import ccall "THNN.h THNN_DoubleSpatialUpSamplingNearest_updateOutput" + c_SpatialUpSamplingNearest_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_SpatialUpSamplingNearest_updateGradInput : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h THNN_DoubleSpatialUpSamplingNearest_updateGradInput" + c_SpatialUpSamplingNearest_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_SpatialUpSamplingBilinear_updateOutput : state input output osizeH osizeW -> void +foreign import ccall "THNN.h THNN_DoubleSpatialUpSamplingBilinear_updateOutput" + c_SpatialUpSamplingBilinear_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | c_SpatialUpSamplingBilinear_updateGradInput : state gradOutput gradInput isizeB isizeC isizeH isizeW osizeH osizeW -> void +foreign import ccall "THNN.h THNN_DoubleSpatialUpSamplingBilinear_updateGradInput" + c_SpatialUpSamplingBilinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialGridSamplerBilinear_updateOutput : state input grid output padding_mode -> void +foreign import ccall "THNN.h THNN_DoubleSpatialGridSamplerBilinear_updateOutput" + c_SpatialGridSamplerBilinear_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_SpatialGridSamplerBilinear_updateGradInput : state input gradInput grid gradGrid gradOutput padding_mode -> void +foreign import ccall "THNN.h THNN_DoubleSpatialGridSamplerBilinear_updateGradInput" + c_SpatialGridSamplerBilinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_VolumetricGridSamplerBilinear_updateOutput : state input grid output padding_mode -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricGridSamplerBilinear_updateOutput" + c_VolumetricGridSamplerBilinear_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_VolumetricGridSamplerBilinear_updateGradInput : state input gradInput grid gradGrid gradOutput padding_mode -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricGridSamplerBilinear_updateGradInput" + c_VolumetricGridSamplerBilinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_unfolded_acc : finput input kW kH dW dH padW padH nInputPlane inputWidth inputHeight osizeW outputHeight -> void +foreign import ccall "THNN.h THNN_Doubleunfolded_acc" + c_unfolded_acc :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_unfolded_copy : finput input kW kH dW dH padW padH nInputPlane inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h THNN_Doubleunfolded_copy" + c_unfolded_copy :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricAveragePooling_updateOutput : state input output kT kW kH dT dW dH padT padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricAveragePooling_updateOutput" + c_VolumetricAveragePooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO () + +-- | c_VolumetricAveragePooling_updateGradInput : state input gradOutput gradInput kT kW kH dT dW dH padT padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricAveragePooling_updateGradInput" + c_VolumetricAveragePooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO () + +-- | c_VolumetricConvolution_updateOutput : state input output weight bias finput fgradInput dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricConvolution_updateOutput" + c_VolumetricConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricConvolution_updateGradInput : state input gradOutput gradInput weight finput dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricConvolution_updateGradInput" + c_VolumetricConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricConvolution_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput dT dW dH pT pW pH scale -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricConvolution_accGradParameters" + c_VolumetricConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricConvolutionMM_updateOutput : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricConvolutionMM_updateOutput" + c_VolumetricConvolutionMM_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricConvolutionMM_updateGradInput : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricConvolutionMM_updateGradInput" + c_VolumetricConvolutionMM_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricConvolutionMM_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH scale -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricConvolutionMM_accGradParameters" + c_VolumetricConvolutionMM_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricFractionalMaxPooling_updateOutput : state input output outputT outputW outputH poolSizeT poolSizeW poolSizeH indices randomSamples -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricFractionalMaxPooling_updateOutput" + c_VolumetricFractionalMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_VolumetricFractionalMaxPooling_updateGradInput : state input gradOutput gradInput outputT outputW outputH poolSizeT poolSizeW poolSizeH indices -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricFractionalMaxPooling_updateGradInput" + c_VolumetricFractionalMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> IO () + +-- | c_VolumetricFullConvolution_updateOutput : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricFullConvolution_updateOutput" + c_VolumetricFullConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricFullConvolution_updateGradInput : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricFullConvolution_updateGradInput" + c_VolumetricFullConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricFullConvolution_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH scale -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricFullConvolution_accGradParameters" + c_VolumetricFullConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricDilatedConvolution_updateOutput : state input output weight bias columns ones kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricDilatedConvolution_updateOutput" + c_VolumetricDilatedConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricDilatedConvolution_updateGradInput : state input gradOutput gradInput weight columns kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricDilatedConvolution_updateGradInput" + c_VolumetricDilatedConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricDilatedConvolution_accGradParameters : state input gradOutput gradWeight gradBias columns ones kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH scale -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricDilatedConvolution_accGradParameters" + c_VolumetricDilatedConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricFullDilatedConvolution_updateOutput : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricFullDilatedConvolution_updateOutput" + c_VolumetricFullDilatedConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricFullDilatedConvolution_updateGradInput : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricFullDilatedConvolution_updateGradInput" + c_VolumetricFullDilatedConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricFullDilatedConvolution_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH scale -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricFullDilatedConvolution_accGradParameters" + c_VolumetricFullDilatedConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricMaxPooling_updateOutput : state input output indices kT kW kH dT dW dH pT pW pH ceilMode -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricMaxPooling_updateOutput" + c_VolumetricMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricMaxPooling_updateGradInput : state input gradOutput gradInput indices kT kW kH dT dW dH pT pW pH ceilMode -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricMaxPooling_updateGradInput" + c_VolumetricMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricDilatedMaxPooling_updateOutput : state input output indices kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH ceilMode -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricDilatedMaxPooling_updateOutput" + c_VolumetricDilatedMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricDilatedMaxPooling_updateGradInput : state input gradOutput gradInput indices kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH ceilMode -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricDilatedMaxPooling_updateGradInput" + c_VolumetricDilatedMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricMaxUnpooling_updateOutput : state input output indices oT oW oH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricMaxUnpooling_updateOutput" + c_VolumetricMaxUnpooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricMaxUnpooling_updateGradInput : state input gradOutput gradInput indices oT oW oH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricMaxUnpooling_updateGradInput" + c_VolumetricMaxUnpooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricAdaptiveAveragePooling_updateOutput : state input output osizeT osizeW osizeH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricAdaptiveAveragePooling_updateOutput" + c_VolumetricAdaptiveAveragePooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricAdaptiveAveragePooling_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricAdaptiveAveragePooling_updateGradInput" + c_VolumetricAdaptiveAveragePooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | c_VolumetricAdaptiveMaxPooling_updateOutput : state input output indices osizeT osizeW osizeH -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricAdaptiveMaxPooling_updateOutput" + c_VolumetricAdaptiveMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricAdaptiveMaxPooling_updateGradInput : state input gradOutput gradInput indices -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricAdaptiveMaxPooling_updateGradInput" + c_VolumetricAdaptiveMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> IO () + +-- | c_SpatialReflectionPadding_updateOutput : state input output pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h THNN_DoubleSpatialReflectionPadding_updateOutput" + c_SpatialReflectionPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialReflectionPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h THNN_DoubleSpatialReflectionPadding_updateGradInput" + c_SpatialReflectionPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialReplicationPadding_updateOutput : state input output pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h THNN_DoubleSpatialReplicationPadding_updateOutput" + c_SpatialReplicationPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialReplicationPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h THNN_DoubleSpatialReplicationPadding_updateGradInput" + c_SpatialReplicationPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_FeatureLPPooling_updateOutput : state input output power width stride batchMode -> void +foreign import ccall "THNN.h THNN_DoubleFeatureLPPooling_updateOutput" + c_FeatureLPPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CInt -> CBool -> IO () + +-- | c_FeatureLPPooling_updateGradInput : state gradOutput input output gradInput power width stride batchMode -> void +foreign import ccall "THNN.h THNN_DoubleFeatureLPPooling_updateGradInput" + c_FeatureLPPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricReplicationPadding_updateOutput : state input output pad_left pad_right pad_top pad_bottom pad_front pad_back -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricReplicationPadding_updateOutput" + c_VolumetricReplicationPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricReplicationPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom pad_front pad_back -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricReplicationPadding_updateGradInput" + c_VolumetricReplicationPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricUpSamplingNearest_updateOutput : state input output scale_factor -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricUpSamplingNearest_updateOutput" + c_VolumetricUpSamplingNearest_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_VolumetricUpSamplingNearest_updateGradInput : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricUpSamplingNearest_updateGradInput" + c_VolumetricUpSamplingNearest_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | c_VolumetricUpSamplingTrilinear_updateOutput : state input output osizeT osizeH osizeW -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricUpSamplingTrilinear_updateOutput" + c_VolumetricUpSamplingTrilinear_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricUpSamplingTrilinear_updateGradInput : state gradOutput gradInput isizeB isizeC isizeT isizeH isizeW osizeT osizeH osizeW -> void +foreign import ccall "THNN.h THNN_DoubleVolumetricUpSamplingTrilinear_updateGradInput" + c_VolumetricUpSamplingTrilinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_TemporalReflectionPadding_updateOutput : state input output pad_left pad_right -> void +foreign import ccall "THNN.h THNN_DoubleTemporalReflectionPadding_updateOutput" + c_TemporalReflectionPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | c_TemporalReflectionPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right -> void +foreign import ccall "THNN.h THNN_DoubleTemporalReflectionPadding_updateGradInput" + c_TemporalReflectionPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | c_TemporalReplicationPadding_updateOutput : state input output pad_left pad_right -> void +foreign import ccall "THNN.h THNN_DoubleTemporalReplicationPadding_updateOutput" + c_TemporalReplicationPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | c_TemporalReplicationPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right -> void +foreign import ccall "THNN.h THNN_DoubleTemporalReplicationPadding_updateGradInput" + c_TemporalReplicationPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | p_Abs_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_DoubleAbs_updateOutput" + p_Abs_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_Abs_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_DoubleAbs_updateGradInput" + p_Abs_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_AbsCriterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleAbsCriterion_updateOutput" + p_AbsCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_AbsCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleAbsCriterion_updateGradInput" + p_AbsCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_BCECriterion_updateOutput : Pointer to function : state input target output sizeAverage weights reduce -> void +foreign import ccall "THNN.h &THNN_DoubleBCECriterion_updateOutput" + p_BCECriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> CBool -> IO ()) + +-- | p_BCECriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage weights reduce -> void +foreign import ccall "THNN.h &THNN_DoubleBCECriterion_updateGradInput" + p_BCECriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> CBool -> IO ()) + +-- | p_ClassNLLCriterion_updateOutput : Pointer to function : state input target output sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h &THNN_DoubleClassNLLCriterion_updateOutput" + p_ClassNLLCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CBool -> IO ()) + +-- | p_ClassNLLCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h &THNN_DoubleClassNLLCriterion_updateGradInput" + p_ClassNLLCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CBool -> IO ()) + +-- | p_SpatialClassNLLCriterion_updateOutput : Pointer to function : state input target output sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialClassNLLCriterion_updateOutput" + p_SpatialClassNLLCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CBool -> IO ()) + +-- | p_SpatialClassNLLCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialClassNLLCriterion_updateGradInput" + p_SpatialClassNLLCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CBool -> IO ()) + +-- | p_ELU_updateOutput : Pointer to function : state input output alpha scale inplace -> void +foreign import ccall "THNN.h &THNN_DoubleELU_updateOutput" + p_ELU_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_ELU_updateGradInput : Pointer to function : state gradOutput gradInput output alpha scale -> void +foreign import ccall "THNN.h &THNN_DoubleELU_updateGradInput" + p_ELU_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_DistKLDivCriterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleDistKLDivCriterion_updateOutput" + p_DistKLDivCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_DistKLDivCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleDistKLDivCriterion_updateGradInput" + p_DistKLDivCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_GatedLinear_updateOutput : Pointer to function : state input output dim -> void +foreign import ccall "THNN.h &THNN_DoubleGatedLinear_updateOutput" + p_GatedLinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_GatedLinear_updateGradInput : Pointer to function : state input gradOutput gradInput dim -> void +foreign import ccall "THNN.h &THNN_DoubleGatedLinear_updateGradInput" + p_GatedLinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_HardShrink_updateOutput : Pointer to function : state input output lambda -> void +foreign import ccall "THNN.h &THNN_DoubleHardShrink_updateOutput" + p_HardShrink_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_HardShrink_updateGradInput : Pointer to function : state input gradOutput gradInput lambda -> void +foreign import ccall "THNN.h &THNN_DoubleHardShrink_updateGradInput" + p_HardShrink_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_HardTanh_updateOutput : Pointer to function : state input output min_val max_val inplace -> void +foreign import ccall "THNN.h &THNN_DoubleHardTanh_updateOutput" + p_HardTanh_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_HardTanh_updateGradInput : Pointer to function : state input gradOutput gradInput min_val max_val inplace -> void +foreign import ccall "THNN.h &THNN_DoubleHardTanh_updateGradInput" + p_HardTanh_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_Im2Col_updateOutput : Pointer to function : state input output kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h &THNN_DoubleIm2Col_updateOutput" + p_Im2Col_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_Im2Col_updateGradInput : Pointer to function : state gradOutput gradInput inputHeight inputWidth kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h &THNN_DoubleIm2Col_updateGradInput" + p_Im2Col_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_Col2Im_updateOutput : Pointer to function : state input output outputHeight outputWidth kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h &THNN_DoubleCol2Im_updateOutput" + p_Col2Im_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_Col2Im_updateGradInput : Pointer to function : state gradOutput gradInput kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h &THNN_DoubleCol2Im_updateGradInput" + p_Col2Im_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_L1Cost_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_DoubleL1Cost_updateOutput" + p_L1Cost_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_L1Cost_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_DoubleL1Cost_updateGradInput" + p_L1Cost_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_LeakyReLU_updateOutput : Pointer to function : state input output negval inplace -> void +foreign import ccall "THNN.h &THNN_DoubleLeakyReLU_updateOutput" + p_LeakyReLU_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CBool -> IO ()) + +-- | p_LeakyReLU_updateGradInput : Pointer to function : state input gradOutput gradInput negval inplace -> void +foreign import ccall "THNN.h &THNN_DoubleLeakyReLU_updateGradInput" + p_LeakyReLU_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CBool -> IO ()) + +-- | p_GRUFused_updateOutput : Pointer to function : state input hidden bias1 bias2 hx output storage -> void +foreign import ccall "THNN.h &THNN_DoubleGRUFused_updateOutput" + p_GRUFused_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_GRUFused_updateGradInput : Pointer to function : state gradInInput gradInHidden gradOutput gradInputHx storage -> void +foreign import ccall "THNN.h &THNN_DoubleGRUFused_updateGradInput" + p_GRUFused_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_LSTMFused_updateOutput : Pointer to function : state input hidden bias1 bias2 cell output outputCell -> void +foreign import ccall "THNN.h &THNN_DoubleLSTMFused_updateOutput" + p_LSTMFused_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_LSTMFused_updateGradInput : Pointer to function : state storage gradInGates cx cy gradOutput gradOutputCell gradInputCx -> void +foreign import ccall "THNN.h &THNN_DoubleLSTMFused_updateGradInput" + p_LSTMFused_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_LogSigmoid_updateOutput : Pointer to function : state input output buffer -> void +foreign import ccall "THNN.h &THNN_DoubleLogSigmoid_updateOutput" + p_LogSigmoid_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_LogSigmoid_updateGradInput : Pointer to function : state input gradOutput gradInput buffer -> void +foreign import ccall "THNN.h &THNN_DoubleLogSigmoid_updateGradInput" + p_LogSigmoid_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_LogSoftMax_updateOutput : Pointer to function : state input output dim -> void +foreign import ccall "THNN.h &THNN_DoubleLogSoftMax_updateOutput" + p_LogSoftMax_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO ()) + +-- | p_LogSoftMax_updateGradInput : Pointer to function : state input gradOutput gradInput output dim -> void +foreign import ccall "THNN.h &THNN_DoubleLogSoftMax_updateGradInput" + p_LogSoftMax_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO ()) + +-- | p_LookupTable_accGradParameters : Pointer to function : state input gradOutput gradWeight count sorted indices scaleGradByFreq paddingValue scale -> void +foreign import ccall "THNN.h &THNN_DoubleLookupTable_accGradParameters" + p_LookupTable_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIntegerTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CBool -> CInt -> CDouble -> IO ()) + +-- | p_LookupTable_renorm : Pointer to function : state idx weight maxNorm normType -> void +foreign import ccall "THNN.h &THNN_DoubleLookupTable_renorm" + p_LookupTable_renorm :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_MarginCriterion_updateOutput : Pointer to function : state input target output sizeAverage margin -> void +foreign import ccall "THNN.h &THNN_DoubleMarginCriterion_updateOutput" + p_MarginCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CDouble -> IO ()) + +-- | p_MarginCriterion_updateGradInput : Pointer to function : state input target gradInput sizeAverage margin -> void +foreign import ccall "THNN.h &THNN_DoubleMarginCriterion_updateGradInput" + p_MarginCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CDouble -> IO ()) + +-- | p_SoftMarginCriterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleSoftMarginCriterion_updateOutput" + p_SoftMarginCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_SoftMarginCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleSoftMarginCriterion_updateGradInput" + p_SoftMarginCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_MSECriterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleMSECriterion_updateOutput" + p_MSECriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_MSECriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleMSECriterion_updateGradInput" + p_MSECriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_MultiLabelMarginCriterion_updateOutput : Pointer to function : state input target output isTarget sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleMultiLabelMarginCriterion_updateOutput" + p_MultiLabelMarginCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_MultiLabelMarginCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput isTarget sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleMultiLabelMarginCriterion_updateGradInput" + p_MultiLabelMarginCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_MultiMarginCriterion_updateOutput : Pointer to function : state input target output sizeAverage p weights margin reduce -> void +foreign import ccall "THNN.h &THNN_DoubleMultiMarginCriterion_updateOutput" + p_MultiMarginCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> CBool -> CInt -> Ptr C'THDoubleTensor -> CDouble -> CBool -> IO ()) + +-- | p_MultiMarginCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage p weights margin reduce -> void +foreign import ccall "THNN.h &THNN_DoubleMultiMarginCriterion_updateGradInput" + p_MultiMarginCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CInt -> Ptr C'THDoubleTensor -> CDouble -> CBool -> IO ()) + +-- | p_PReLU_updateOutput : Pointer to function : state input output weight -> void +foreign import ccall "THNN.h &THNN_DoublePReLU_updateOutput" + p_PReLU_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_PReLU_updateGradInput : Pointer to function : state input gradOutput gradInput weight -> void +foreign import ccall "THNN.h &THNN_DoublePReLU_updateGradInput" + p_PReLU_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_PReLU_accGradParameters : Pointer to function : state input gradOutput gradInput weight gradWeight scale -> void +foreign import ccall "THNN.h &THNN_DoublePReLU_accGradParameters" + p_PReLU_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_Linear_updateOutput : Pointer to function : state input output weight bias addBuffer -> void +foreign import ccall "THNN.h &THNN_DoubleLinear_updateOutput" + p_Linear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_Linear_updateGradInput : Pointer to function : state input gradOutput gradInput weight -> void +foreign import ccall "THNN.h &THNN_DoubleLinear_updateGradInput" + p_Linear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_Linear_accGradParameters : Pointer to function : state input gradOutput gradInput weight bias gradWeight gradBias addBuffer scale -> void +foreign import ccall "THNN.h &THNN_DoubleLinear_accGradParameters" + p_Linear_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_RReLU_updateOutput : Pointer to function : state input output noise lower upper train inplace generator -> void +foreign import ccall "THNN.h &THNN_DoubleRReLU_updateOutput" + p_RReLU_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> CBool -> Ptr C'THGenerator -> IO ()) + +-- | p_RReLU_updateGradInput : Pointer to function : state input gradOutput gradInput noise lower upper train inplace -> void +foreign import ccall "THNN.h &THNN_DoubleRReLU_updateGradInput" + p_RReLU_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> CBool -> IO ()) + +-- | p_Sigmoid_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_DoubleSigmoid_updateOutput" + p_Sigmoid_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_Sigmoid_updateGradInput : Pointer to function : state gradOutput gradInput output -> void +foreign import ccall "THNN.h &THNN_DoubleSigmoid_updateGradInput" + p_Sigmoid_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_SmoothL1Criterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleSmoothL1Criterion_updateOutput" + p_SmoothL1Criterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_SmoothL1Criterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_DoubleSmoothL1Criterion_updateGradInput" + p_SmoothL1Criterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CBool -> IO ()) + +-- | p_SoftMax_updateOutput : Pointer to function : state input output dim -> void +foreign import ccall "THNN.h &THNN_DoubleSoftMax_updateOutput" + p_SoftMax_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO ()) + +-- | p_SoftMax_updateGradInput : Pointer to function : state input gradOutput gradInput output dim -> void +foreign import ccall "THNN.h &THNN_DoubleSoftMax_updateGradInput" + p_SoftMax_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO ()) + +-- | p_SoftPlus_updateOutput : Pointer to function : state input output beta threshold -> void +foreign import ccall "THNN.h &THNN_DoubleSoftPlus_updateOutput" + p_SoftPlus_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_SoftPlus_updateGradInput : Pointer to function : state input gradOutput gradInput output beta threshold -> void +foreign import ccall "THNN.h &THNN_DoubleSoftPlus_updateGradInput" + p_SoftPlus_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_SoftShrink_updateOutput : Pointer to function : state input output lambda -> void +foreign import ccall "THNN.h &THNN_DoubleSoftShrink_updateOutput" + p_SoftShrink_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_SoftShrink_updateGradInput : Pointer to function : state input gradOutput gradInput lambda -> void +foreign import ccall "THNN.h &THNN_DoubleSoftShrink_updateGradInput" + p_SoftShrink_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_IndexLinear_updateOutput : Pointer to function : state keys keysOffset values sizes cumSumSizes output weight bias normalizedValues train -> void +foreign import ccall "THNN.h &THNN_DoubleIndexLinear_updateOutput" + p_IndexLinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_IndexLinear_accGradParameters : Pointer to function : state keys keysOffset values sizes cumSumSizes gradOutput gradWeight gradBias weight bias valuesBuffer weightDecay scale -> void +foreign import ccall "THNN.h &THNN_DoubleIndexLinear_accGradParameters" + p_IndexLinear_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_IndexLinear_accUpdateGradParameters : Pointer to function : state keys keysOffset values sizes cumSumSizes gradOutput weight bias weightDecay scale -> void +foreign import ccall "THNN.h &THNN_DoubleIndexLinear_accUpdateGradParameters" + p_IndexLinear_accUpdateGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_IndexLinear_updateParameters : Pointer to function : state gradWeight gradBias weight bias runningKeys cumSumSizes keysOffset weightDecay learningRate -> void +foreign import ccall "THNN.h &THNN_DoubleIndexLinear_updateParameters" + p_IndexLinear_updateParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> CLLong -> CDouble -> CDouble -> IO ()) + +-- | p_SparseLinear_updateOutput : Pointer to function : state input output weight bias -> void +foreign import ccall "THNN.h &THNN_DoubleSparseLinear_updateOutput" + p_SparseLinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_SparseLinear_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias weight bias weightDecay scale -> void +foreign import ccall "THNN.h &THNN_DoubleSparseLinear_accGradParameters" + p_SparseLinear_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_SparseLinear_zeroGradParameters : Pointer to function : state gradWeight gradBias lastInput -> void +foreign import ccall "THNN.h &THNN_DoubleSparseLinear_zeroGradParameters" + p_SparseLinear_zeroGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_SparseLinear_updateParameters : Pointer to function : state weight bias gradWeight gradBias lastInput learningRate -> void +foreign import ccall "THNN.h &THNN_DoubleSparseLinear_updateParameters" + p_SparseLinear_updateParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_SparseLinear_legacyUpdateOutput : Pointer to function : state input output weight bias -> void +foreign import ccall "THNN.h &THNN_DoubleSparseLinear_legacyUpdateOutput" + p_SparseLinear_legacyUpdateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_SparseLinear_legacyAccGradParameters : Pointer to function : state input gradOutput gradWeight gradBias weight bias weightDecay scale -> void +foreign import ccall "THNN.h &THNN_DoubleSparseLinear_legacyAccGradParameters" + p_SparseLinear_legacyAccGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_SparseLinear_legacyZeroGradParameters : Pointer to function : state gradWeight gradBias lastInput -> void +foreign import ccall "THNN.h &THNN_DoubleSparseLinear_legacyZeroGradParameters" + p_SparseLinear_legacyZeroGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_SparseLinear_legacyUpdateParameters : Pointer to function : state weight bias gradWeight gradBias lastInput learningRate -> void +foreign import ccall "THNN.h &THNN_DoubleSparseLinear_legacyUpdateParameters" + p_SparseLinear_legacyUpdateParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_Sqrt_updateOutput : Pointer to function : state input output eps -> void +foreign import ccall "THNN.h &THNN_DoubleSqrt_updateOutput" + p_Sqrt_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_Sqrt_updateGradInput : Pointer to function : state input gradOutput gradInput output -> void +foreign import ccall "THNN.h &THNN_DoubleSqrt_updateGradInput" + p_Sqrt_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_Square_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_DoubleSquare_updateOutput" + p_Square_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_Square_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_DoubleSquare_updateGradInput" + p_Square_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_Tanh_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_DoubleTanh_updateOutput" + p_Tanh_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_Tanh_updateGradInput : Pointer to function : state gradOutput gradInput output -> void +foreign import ccall "THNN.h &THNN_DoubleTanh_updateGradInput" + p_Tanh_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_Threshold_updateOutput : Pointer to function : state input output threshold val inplace -> void +foreign import ccall "THNN.h &THNN_DoubleThreshold_updateOutput" + p_Threshold_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_Threshold_updateGradInput : Pointer to function : state input gradOutput gradInput threshold val inplace -> void +foreign import ccall "THNN.h &THNN_DoubleThreshold_updateGradInput" + p_Threshold_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_TemporalConvolution_updateOutput : Pointer to function : state input output weight bias kW dW inputFrameSize outputFrameSize -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalConvolution_updateOutput" + p_TemporalConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_TemporalConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight kW dW -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalConvolution_updateGradInput" + p_TemporalConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias kW dW scale -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalConvolution_accGradParameters" + p_TemporalConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_TemporalMaxPooling_updateOutput : Pointer to function : state input output indices kW dW -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalMaxPooling_updateOutput" + p_TemporalMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kW dW -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalMaxPooling_updateGradInput" + p_TemporalMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalSubSampling_updateOutput : Pointer to function : state input output weight bias kW dW inputFrameSize -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalSubSampling_updateOutput" + p_TemporalSubSampling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_TemporalSubSampling_updateGradInput : Pointer to function : state input gradOutput gradInput weight kW dW -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalSubSampling_updateGradInput" + p_TemporalSubSampling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalSubSampling_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias kW dW scale -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalSubSampling_accGradParameters" + p_TemporalSubSampling_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_TemporalRowConvolution_updateOutput : Pointer to function : state input output weight bias finput fgradInput kW dW padW featFirst -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalRowConvolution_updateOutput" + p_TemporalRowConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_TemporalRowConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kW dW padW featFirst -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalRowConvolution_updateGradInput" + p_TemporalRowConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_TemporalRowConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kW dW padW featFirst scale -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalRowConvolution_accGradParameters" + p_TemporalRowConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CBool -> CDouble -> IO ()) + +-- | p_TemporalUpSamplingNearest_updateOutput : Pointer to function : state input output scale_factor -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalUpSamplingNearest_updateOutput" + p_TemporalUpSamplingNearest_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_TemporalUpSamplingNearest_updateGradInput : Pointer to function : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalUpSamplingNearest_updateGradInput" + p_TemporalUpSamplingNearest_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_TemporalUpSamplingLinear_updateOutput : Pointer to function : state input output osizeW -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalUpSamplingLinear_updateOutput" + p_TemporalUpSamplingLinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_TemporalUpSamplingLinear_updateGradInput : Pointer to function : state gradOutput gradInput isizeB isizeC isizeW osizeW -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalUpSamplingLinear_updateGradInput" + p_TemporalUpSamplingLinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_BatchNormalization_updateOutput : Pointer to function : state input output weight bias running_mean running_var save_mean save_std train momentum eps -> void +foreign import ccall "THNN.h &THNN_DoubleBatchNormalization_updateOutput" + p_BatchNormalization_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CDouble -> CDouble -> IO ()) + +-- | p_BatchNormalization_backward : Pointer to function : state input gradOutput gradInput gradWeight gradBias weight running_mean running_var save_mean save_std train scale eps -> void +foreign import ccall "THNN.h &THNN_DoubleBatchNormalization_backward" + p_BatchNormalization_backward :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CBool -> CDouble -> CDouble -> IO ()) + +-- | p_SpatialConvolutionMap_updateOutput : Pointer to function : state input output weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialConvolutionMap_updateOutput" + p_SpatialConvolutionMap_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialConvolutionMap_updateGradInput : Pointer to function : state input gradOutput gradInput weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialConvolutionMap_updateGradInput" + p_SpatialConvolutionMap_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialConvolutionMap_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias connTable nInputPlane nOutputPlane dW dH scale -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialConvolutionMap_accGradParameters" + p_SpatialConvolutionMap_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialConvolutionMM_updateOutput : Pointer to function : state input output weight bias finput fgradInput kW kH dW dH padW padH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialConvolutionMM_updateOutput" + p_SpatialConvolutionMM_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialConvolutionMM_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kW kH dW dH padW padH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialConvolutionMM_updateGradInput" + p_SpatialConvolutionMM_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialConvolutionMM_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kW kH dW dH padW padH scale -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialConvolutionMM_accGradParameters" + p_SpatialConvolutionMM_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialConvolutionLocal_updateOutput : Pointer to function : state input output weight bias finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialConvolutionLocal_updateOutput" + p_SpatialConvolutionLocal_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_SpatialConvolutionLocal_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialConvolutionLocal_updateGradInput" + p_SpatialConvolutionLocal_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_SpatialConvolutionLocal_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight scale -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialConvolutionLocal_accGradParameters" + p_SpatialConvolutionLocal_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CDouble -> IO ()) + +-- | p_SpatialAdaptiveMaxPooling_updateOutput : Pointer to function : state input output indices osizeW osizeH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialAdaptiveMaxPooling_updateOutput" + p_SpatialAdaptiveMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialAdaptiveMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialAdaptiveMaxPooling_updateGradInput" + p_SpatialAdaptiveMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> IO ()) + +-- | p_SpatialAdaptiveAveragePooling_updateOutput : Pointer to function : state input output osizeW osizeH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialAdaptiveAveragePooling_updateOutput" + p_SpatialAdaptiveAveragePooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialAdaptiveAveragePooling_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialAdaptiveAveragePooling_updateGradInput" + p_SpatialAdaptiveAveragePooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_SpatialAveragePooling_updateOutput : Pointer to function : state input output kW kH dW dH padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialAveragePooling_updateOutput" + p_SpatialAveragePooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO ()) + +-- | p_SpatialAveragePooling_updateGradInput : Pointer to function : state input gradOutput gradInput kW kH dW dH padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialAveragePooling_updateGradInput" + p_SpatialAveragePooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO ()) + +-- | p_SpatialFractionalMaxPooling_updateOutput : Pointer to function : state input output outputW outputH kW kH indices randomSamples -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFractionalMaxPooling_updateOutput" + p_SpatialFractionalMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_SpatialFractionalMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput outputW outputH kW kH indices -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFractionalMaxPooling_updateGradInput" + p_SpatialFractionalMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> IO ()) + +-- | p_SpatialFullConvolution_updateOutput : Pointer to function : state input output weight bias columns ones kW kH dW dH padW padH adjW adjH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFullConvolution_updateOutput" + p_SpatialFullConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight columns kW kH dW dH padW padH adjW adjH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFullConvolution_updateGradInput" + p_SpatialFullConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH adjW adjH scale -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFullConvolution_accGradParameters" + p_SpatialFullConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialFullConvolutionMap_updateOutput : Pointer to function : state input output weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFullConvolutionMap_updateOutput" + p_SpatialFullConvolutionMap_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullConvolutionMap_updateGradInput : Pointer to function : state input gradOutput gradInput weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFullConvolutionMap_updateGradInput" + p_SpatialFullConvolutionMap_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullConvolutionMap_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias connTable nInputPlane nOutputPlane dW dH scale -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFullConvolutionMap_accGradParameters" + p_SpatialFullConvolutionMap_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialDilatedConvolution_updateOutput : Pointer to function : state input output weight bias columns ones kW kH dW dH padW padH dilationW dilationH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialDilatedConvolution_updateOutput" + p_SpatialDilatedConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialDilatedConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight columns kW kH dW dH padW padH dilationW dilationH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialDilatedConvolution_updateGradInput" + p_SpatialDilatedConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialDilatedConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH dilationW dilationH scale -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialDilatedConvolution_accGradParameters" + p_SpatialDilatedConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialFullDilatedConvolution_updateOutput : Pointer to function : state input output weight bias columns ones kW kH dW dH padW padH dilationW dilationH adjW adjH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFullDilatedConvolution_updateOutput" + p_SpatialFullDilatedConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullDilatedConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight columns kW kH dW dH padW padH dilationW dilationH adjW adjH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFullDilatedConvolution_updateGradInput" + p_SpatialFullDilatedConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullDilatedConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH dilationW dilationH adjW adjH scale -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialFullDilatedConvolution_accGradParameters" + p_SpatialFullDilatedConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialMaxPooling_updateOutput : Pointer to function : state input output indices kW kH dW dH padW padH ceil_mode -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialMaxPooling_updateOutput" + p_SpatialMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_SpatialMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kW kH dW dH padW padH ceil_mode -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialMaxPooling_updateGradInput" + p_SpatialMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_SpatialDilatedMaxPooling_updateOutput : Pointer to function : state input output indices kW kH dW dH padW padH dilationW dilationH ceil_mode -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialDilatedMaxPooling_updateOutput" + p_SpatialDilatedMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_SpatialDilatedMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kW kH dW dH padW padH dilationW dilationH ceil_mode -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialDilatedMaxPooling_updateGradInput" + p_SpatialDilatedMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_SpatialMaxUnpooling_updateOutput : Pointer to function : state input output indices owidth oheight -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialMaxUnpooling_updateOutput" + p_SpatialMaxUnpooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialMaxUnpooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices owidth oheight -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialMaxUnpooling_updateGradInput" + p_SpatialMaxUnpooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialSubSampling_updateOutput : Pointer to function : state input output weight bias kW kH dW dH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialSubSampling_updateOutput" + p_SpatialSubSampling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialSubSampling_updateGradInput : Pointer to function : state input gradOutput gradInput weight kW kH dW dH -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialSubSampling_updateGradInput" + p_SpatialSubSampling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialSubSampling_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias kW kH dW dH scale -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialSubSampling_accGradParameters" + p_SpatialSubSampling_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialUpSamplingNearest_updateOutput : Pointer to function : state input output scale_factor -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialUpSamplingNearest_updateOutput" + p_SpatialUpSamplingNearest_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_SpatialUpSamplingNearest_updateGradInput : Pointer to function : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialUpSamplingNearest_updateGradInput" + p_SpatialUpSamplingNearest_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_SpatialUpSamplingBilinear_updateOutput : Pointer to function : state input output osizeH osizeW -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialUpSamplingBilinear_updateOutput" + p_SpatialUpSamplingBilinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialUpSamplingBilinear_updateGradInput : Pointer to function : state gradOutput gradInput isizeB isizeC isizeH isizeW osizeH osizeW -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialUpSamplingBilinear_updateGradInput" + p_SpatialUpSamplingBilinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialGridSamplerBilinear_updateOutput : Pointer to function : state input grid output padding_mode -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialGridSamplerBilinear_updateOutput" + p_SpatialGridSamplerBilinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_SpatialGridSamplerBilinear_updateGradInput : Pointer to function : state input gradInput grid gradGrid gradOutput padding_mode -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialGridSamplerBilinear_updateGradInput" + p_SpatialGridSamplerBilinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_VolumetricGridSamplerBilinear_updateOutput : Pointer to function : state input grid output padding_mode -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricGridSamplerBilinear_updateOutput" + p_VolumetricGridSamplerBilinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_VolumetricGridSamplerBilinear_updateGradInput : Pointer to function : state input gradInput grid gradGrid gradOutput padding_mode -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricGridSamplerBilinear_updateGradInput" + p_VolumetricGridSamplerBilinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_unfolded_acc : Pointer to function : finput input kW kH dW dH padW padH nInputPlane inputWidth inputHeight osizeW outputHeight -> void +foreign import ccall "THNN.h &THNN_Doubleunfolded_acc" + p_unfolded_acc :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_unfolded_copy : Pointer to function : finput input kW kH dW dH padW padH nInputPlane inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h &THNN_Doubleunfolded_copy" + p_unfolded_copy :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricAveragePooling_updateOutput : Pointer to function : state input output kT kW kH dT dW dH padT padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricAveragePooling_updateOutput" + p_VolumetricAveragePooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO ()) + +-- | p_VolumetricAveragePooling_updateGradInput : Pointer to function : state input gradOutput gradInput kT kW kH dT dW dH padT padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricAveragePooling_updateGradInput" + p_VolumetricAveragePooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO ()) + +-- | p_VolumetricConvolution_updateOutput : Pointer to function : state input output weight bias finput fgradInput dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricConvolution_updateOutput" + p_VolumetricConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricConvolution_updateGradInput" + p_VolumetricConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput dT dW dH pT pW pH scale -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricConvolution_accGradParameters" + p_VolumetricConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricConvolutionMM_updateOutput : Pointer to function : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricConvolutionMM_updateOutput" + p_VolumetricConvolutionMM_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricConvolutionMM_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricConvolutionMM_updateGradInput" + p_VolumetricConvolutionMM_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricConvolutionMM_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH scale -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricConvolutionMM_accGradParameters" + p_VolumetricConvolutionMM_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricFractionalMaxPooling_updateOutput : Pointer to function : state input output outputT outputW outputH poolSizeT poolSizeW poolSizeH indices randomSamples -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricFractionalMaxPooling_updateOutput" + p_VolumetricFractionalMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_VolumetricFractionalMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput outputT outputW outputH poolSizeT poolSizeW poolSizeH indices -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricFractionalMaxPooling_updateGradInput" + p_VolumetricFractionalMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> IO ()) + +-- | p_VolumetricFullConvolution_updateOutput : Pointer to function : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricFullConvolution_updateOutput" + p_VolumetricFullConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricFullConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricFullConvolution_updateGradInput" + p_VolumetricFullConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricFullConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH scale -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricFullConvolution_accGradParameters" + p_VolumetricFullConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricDilatedConvolution_updateOutput : Pointer to function : state input output weight bias columns ones kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricDilatedConvolution_updateOutput" + p_VolumetricDilatedConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricDilatedConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight columns kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricDilatedConvolution_updateGradInput" + p_VolumetricDilatedConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricDilatedConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias columns ones kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH scale -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricDilatedConvolution_accGradParameters" + p_VolumetricDilatedConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricFullDilatedConvolution_updateOutput : Pointer to function : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricFullDilatedConvolution_updateOutput" + p_VolumetricFullDilatedConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricFullDilatedConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricFullDilatedConvolution_updateGradInput" + p_VolumetricFullDilatedConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricFullDilatedConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH scale -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricFullDilatedConvolution_accGradParameters" + p_VolumetricFullDilatedConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricMaxPooling_updateOutput : Pointer to function : state input output indices kT kW kH dT dW dH pT pW pH ceilMode -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricMaxPooling_updateOutput" + p_VolumetricMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kT kW kH dT dW dH pT pW pH ceilMode -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricMaxPooling_updateGradInput" + p_VolumetricMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricDilatedMaxPooling_updateOutput : Pointer to function : state input output indices kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH ceilMode -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricDilatedMaxPooling_updateOutput" + p_VolumetricDilatedMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricDilatedMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH ceilMode -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricDilatedMaxPooling_updateGradInput" + p_VolumetricDilatedMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricMaxUnpooling_updateOutput : Pointer to function : state input output indices oT oW oH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricMaxUnpooling_updateOutput" + p_VolumetricMaxUnpooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricMaxUnpooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices oT oW oH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricMaxUnpooling_updateGradInput" + p_VolumetricMaxUnpooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricAdaptiveAveragePooling_updateOutput : Pointer to function : state input output osizeT osizeW osizeH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricAdaptiveAveragePooling_updateOutput" + p_VolumetricAdaptiveAveragePooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricAdaptiveAveragePooling_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricAdaptiveAveragePooling_updateGradInput" + p_VolumetricAdaptiveAveragePooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_VolumetricAdaptiveMaxPooling_updateOutput : Pointer to function : state input output indices osizeT osizeW osizeH -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricAdaptiveMaxPooling_updateOutput" + p_VolumetricAdaptiveMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricAdaptiveMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricAdaptiveMaxPooling_updateGradInput" + p_VolumetricAdaptiveMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIndexTensor -> IO ()) + +-- | p_SpatialReflectionPadding_updateOutput : Pointer to function : state input output pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialReflectionPadding_updateOutput" + p_SpatialReflectionPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialReflectionPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialReflectionPadding_updateGradInput" + p_SpatialReflectionPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialReplicationPadding_updateOutput : Pointer to function : state input output pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialReplicationPadding_updateOutput" + p_SpatialReplicationPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialReplicationPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h &THNN_DoubleSpatialReplicationPadding_updateGradInput" + p_SpatialReplicationPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_FeatureLPPooling_updateOutput : Pointer to function : state input output power width stride batchMode -> void +foreign import ccall "THNN.h &THNN_DoubleFeatureLPPooling_updateOutput" + p_FeatureLPPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CInt -> CBool -> IO ()) + +-- | p_FeatureLPPooling_updateGradInput : Pointer to function : state gradOutput input output gradInput power width stride batchMode -> void +foreign import ccall "THNN.h &THNN_DoubleFeatureLPPooling_updateGradInput" + p_FeatureLPPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricReplicationPadding_updateOutput : Pointer to function : state input output pad_left pad_right pad_top pad_bottom pad_front pad_back -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricReplicationPadding_updateOutput" + p_VolumetricReplicationPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricReplicationPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom pad_front pad_back -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricReplicationPadding_updateGradInput" + p_VolumetricReplicationPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricUpSamplingNearest_updateOutput : Pointer to function : state input output scale_factor -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricUpSamplingNearest_updateOutput" + p_VolumetricUpSamplingNearest_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_VolumetricUpSamplingNearest_updateGradInput : Pointer to function : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricUpSamplingNearest_updateGradInput" + p_VolumetricUpSamplingNearest_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_VolumetricUpSamplingTrilinear_updateOutput : Pointer to function : state input output osizeT osizeH osizeW -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricUpSamplingTrilinear_updateOutput" + p_VolumetricUpSamplingTrilinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricUpSamplingTrilinear_updateGradInput : Pointer to function : state gradOutput gradInput isizeB isizeC isizeT isizeH isizeW osizeT osizeH osizeW -> void +foreign import ccall "THNN.h &THNN_DoubleVolumetricUpSamplingTrilinear_updateGradInput" + p_VolumetricUpSamplingTrilinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_TemporalReflectionPadding_updateOutput : Pointer to function : state input output pad_left pad_right -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalReflectionPadding_updateOutput" + p_TemporalReflectionPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalReflectionPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalReflectionPadding_updateGradInput" + p_TemporalReflectionPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalReplicationPadding_updateOutput : Pointer to function : state input output pad_left pad_right -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalReplicationPadding_updateOutput" + p_TemporalReplicationPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalReplicationPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right -> void +foreign import ccall "THNN.h &THNN_DoubleTemporalReplicationPadding_updateGradInput" + p_TemporalReplicationPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) diff --git a/nn/Torch/FFI/TH/NN/Float.hs b/nn/Torch/FFI/TH/NN/Float.hs new file mode 100644 --- /dev/null +++ b/nn/Torch/FFI/TH/NN/Float.hs @@ -0,0 +1,1576 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.NN.Float where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_Abs_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_FloatAbs_updateOutput" + c_Abs_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_Abs_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_FloatAbs_updateGradInput" + c_Abs_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_AbsCriterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatAbsCriterion_updateOutput" + c_AbsCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_AbsCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatAbsCriterion_updateGradInput" + c_AbsCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_BCECriterion_updateOutput : state input target output sizeAverage weights reduce -> void +foreign import ccall "THNN.h THNN_FloatBCECriterion_updateOutput" + c_BCECriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> CBool -> IO () + +-- | c_BCECriterion_updateGradInput : state input target gradOutput gradInput sizeAverage weights reduce -> void +foreign import ccall "THNN.h THNN_FloatBCECriterion_updateGradInput" + c_BCECriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> CBool -> IO () + +-- | c_ClassNLLCriterion_updateOutput : state input target output sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h THNN_FloatClassNLLCriterion_updateOutput" + c_ClassNLLCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CBool -> IO () + +-- | c_ClassNLLCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h THNN_FloatClassNLLCriterion_updateGradInput" + c_ClassNLLCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CBool -> IO () + +-- | c_SpatialClassNLLCriterion_updateOutput : state input target output sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h THNN_FloatSpatialClassNLLCriterion_updateOutput" + c_SpatialClassNLLCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CBool -> IO () + +-- | c_SpatialClassNLLCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h THNN_FloatSpatialClassNLLCriterion_updateGradInput" + c_SpatialClassNLLCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CBool -> IO () + +-- | c_ELU_updateOutput : state input output alpha scale inplace -> void +foreign import ccall "THNN.h THNN_FloatELU_updateOutput" + c_ELU_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_ELU_updateGradInput : state gradOutput gradInput output alpha scale -> void +foreign import ccall "THNN.h THNN_FloatELU_updateGradInput" + c_ELU_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO () + +-- | c_DistKLDivCriterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatDistKLDivCriterion_updateOutput" + c_DistKLDivCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_DistKLDivCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatDistKLDivCriterion_updateGradInput" + c_DistKLDivCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_GatedLinear_updateOutput : state input output dim -> void +foreign import ccall "THNN.h THNN_FloatGatedLinear_updateOutput" + c_GatedLinear_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_GatedLinear_updateGradInput : state input gradOutput gradInput dim -> void +foreign import ccall "THNN.h THNN_FloatGatedLinear_updateGradInput" + c_GatedLinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_HardShrink_updateOutput : state input output lambda -> void +foreign import ccall "THNN.h THNN_FloatHardShrink_updateOutput" + c_HardShrink_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | c_HardShrink_updateGradInput : state input gradOutput gradInput lambda -> void +foreign import ccall "THNN.h THNN_FloatHardShrink_updateGradInput" + c_HardShrink_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | c_HardTanh_updateOutput : state input output min_val max_val inplace -> void +foreign import ccall "THNN.h THNN_FloatHardTanh_updateOutput" + c_HardTanh_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_HardTanh_updateGradInput : state input gradOutput gradInput min_val max_val inplace -> void +foreign import ccall "THNN.h THNN_FloatHardTanh_updateGradInput" + c_HardTanh_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_Im2Col_updateOutput : state input output kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h THNN_FloatIm2Col_updateOutput" + c_Im2Col_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_Im2Col_updateGradInput : state gradOutput gradInput inputHeight inputWidth kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h THNN_FloatIm2Col_updateGradInput" + c_Im2Col_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_Col2Im_updateOutput : state input output outputHeight outputWidth kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h THNN_FloatCol2Im_updateOutput" + c_Col2Im_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_Col2Im_updateGradInput : state gradOutput gradInput kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h THNN_FloatCol2Im_updateGradInput" + c_Col2Im_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_L1Cost_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_FloatL1Cost_updateOutput" + c_L1Cost_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_L1Cost_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_FloatL1Cost_updateGradInput" + c_L1Cost_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_LeakyReLU_updateOutput : state input output negval inplace -> void +foreign import ccall "THNN.h THNN_FloatLeakyReLU_updateOutput" + c_LeakyReLU_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CBool -> IO () + +-- | c_LeakyReLU_updateGradInput : state input gradOutput gradInput negval inplace -> void +foreign import ccall "THNN.h THNN_FloatLeakyReLU_updateGradInput" + c_LeakyReLU_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CBool -> IO () + +-- | c_GRUFused_updateOutput : state input hidden bias1 bias2 hx output storage -> void +foreign import ccall "THNN.h THNN_FloatGRUFused_updateOutput" + c_GRUFused_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_GRUFused_updateGradInput : state gradInInput gradInHidden gradOutput gradInputHx storage -> void +foreign import ccall "THNN.h THNN_FloatGRUFused_updateGradInput" + c_GRUFused_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_LSTMFused_updateOutput : state input hidden bias1 bias2 cell output outputCell -> void +foreign import ccall "THNN.h THNN_FloatLSTMFused_updateOutput" + c_LSTMFused_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_LSTMFused_updateGradInput : state storage gradInGates cx cy gradOutput gradOutputCell gradInputCx -> void +foreign import ccall "THNN.h THNN_FloatLSTMFused_updateGradInput" + c_LSTMFused_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_LogSigmoid_updateOutput : state input output buffer -> void +foreign import ccall "THNN.h THNN_FloatLogSigmoid_updateOutput" + c_LogSigmoid_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_LogSigmoid_updateGradInput : state input gradOutput gradInput buffer -> void +foreign import ccall "THNN.h THNN_FloatLogSigmoid_updateGradInput" + c_LogSigmoid_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_LogSoftMax_updateOutput : state input output dim -> void +foreign import ccall "THNN.h THNN_FloatLogSoftMax_updateOutput" + c_LogSoftMax_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO () + +-- | c_LogSoftMax_updateGradInput : state input gradOutput gradInput output dim -> void +foreign import ccall "THNN.h THNN_FloatLogSoftMax_updateGradInput" + c_LogSoftMax_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO () + +-- | c_LookupTable_accGradParameters : state input gradOutput gradWeight count sorted indices scaleGradByFreq paddingValue scale -> void +foreign import ccall "THNN.h THNN_FloatLookupTable_accGradParameters" + c_LookupTable_accGradParameters :: Ptr C'THNNState -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIntegerTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CBool -> CInt -> CDouble -> IO () + +-- | c_LookupTable_renorm : state idx weight maxNorm normType -> void +foreign import ccall "THNN.h THNN_FloatLookupTable_renorm" + c_LookupTable_renorm :: Ptr C'THNNState -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO () + +-- | c_MarginCriterion_updateOutput : state input target output sizeAverage margin -> void +foreign import ccall "THNN.h THNN_FloatMarginCriterion_updateOutput" + c_MarginCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CDouble -> IO () + +-- | c_MarginCriterion_updateGradInput : state input target gradInput sizeAverage margin -> void +foreign import ccall "THNN.h THNN_FloatMarginCriterion_updateGradInput" + c_MarginCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CDouble -> IO () + +-- | c_SoftMarginCriterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatSoftMarginCriterion_updateOutput" + c_SoftMarginCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_SoftMarginCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatSoftMarginCriterion_updateGradInput" + c_SoftMarginCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_MSECriterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatMSECriterion_updateOutput" + c_MSECriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_MSECriterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatMSECriterion_updateGradInput" + c_MSECriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_MultiLabelMarginCriterion_updateOutput : state input target output isTarget sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatMultiLabelMarginCriterion_updateOutput" + c_MultiLabelMarginCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_MultiLabelMarginCriterion_updateGradInput : state input target gradOutput gradInput isTarget sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatMultiLabelMarginCriterion_updateGradInput" + c_MultiLabelMarginCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_MultiMarginCriterion_updateOutput : state input target output sizeAverage p weights margin reduce -> void +foreign import ccall "THNN.h THNN_FloatMultiMarginCriterion_updateOutput" + c_MultiMarginCriterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> CBool -> CInt -> Ptr C'THFloatTensor -> CDouble -> CBool -> IO () + +-- | c_MultiMarginCriterion_updateGradInput : state input target gradOutput gradInput sizeAverage p weights margin reduce -> void +foreign import ccall "THNN.h THNN_FloatMultiMarginCriterion_updateGradInput" + c_MultiMarginCriterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CInt -> Ptr C'THFloatTensor -> CDouble -> CBool -> IO () + +-- | c_PReLU_updateOutput : state input output weight -> void +foreign import ccall "THNN.h THNN_FloatPReLU_updateOutput" + c_PReLU_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_PReLU_updateGradInput : state input gradOutput gradInput weight -> void +foreign import ccall "THNN.h THNN_FloatPReLU_updateGradInput" + c_PReLU_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_PReLU_accGradParameters : state input gradOutput gradInput weight gradWeight scale -> void +foreign import ccall "THNN.h THNN_FloatPReLU_accGradParameters" + c_PReLU_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | c_Linear_updateOutput : state input output weight bias addBuffer -> void +foreign import ccall "THNN.h THNN_FloatLinear_updateOutput" + c_Linear_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_Linear_updateGradInput : state input gradOutput gradInput weight -> void +foreign import ccall "THNN.h THNN_FloatLinear_updateGradInput" + c_Linear_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_Linear_accGradParameters : state input gradOutput gradInput weight bias gradWeight gradBias addBuffer scale -> void +foreign import ccall "THNN.h THNN_FloatLinear_accGradParameters" + c_Linear_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | c_RReLU_updateOutput : state input output noise lower upper train inplace generator -> void +foreign import ccall "THNN.h THNN_FloatRReLU_updateOutput" + c_RReLU_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> CBool -> Ptr C'THGenerator -> IO () + +-- | c_RReLU_updateGradInput : state input gradOutput gradInput noise lower upper train inplace -> void +foreign import ccall "THNN.h THNN_FloatRReLU_updateGradInput" + c_RReLU_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> CBool -> IO () + +-- | c_Sigmoid_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_FloatSigmoid_updateOutput" + c_Sigmoid_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_Sigmoid_updateGradInput : state gradOutput gradInput output -> void +foreign import ccall "THNN.h THNN_FloatSigmoid_updateGradInput" + c_Sigmoid_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_SmoothL1Criterion_updateOutput : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatSmoothL1Criterion_updateOutput" + c_SmoothL1Criterion_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_SmoothL1Criterion_updateGradInput : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h THNN_FloatSmoothL1Criterion_updateGradInput" + c_SmoothL1Criterion_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO () + +-- | c_SoftMax_updateOutput : state input output dim -> void +foreign import ccall "THNN.h THNN_FloatSoftMax_updateOutput" + c_SoftMax_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO () + +-- | c_SoftMax_updateGradInput : state input gradOutput gradInput output dim -> void +foreign import ccall "THNN.h THNN_FloatSoftMax_updateGradInput" + c_SoftMax_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO () + +-- | c_SoftPlus_updateOutput : state input output beta threshold -> void +foreign import ccall "THNN.h THNN_FloatSoftPlus_updateOutput" + c_SoftPlus_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO () + +-- | c_SoftPlus_updateGradInput : state input gradOutput gradInput output beta threshold -> void +foreign import ccall "THNN.h THNN_FloatSoftPlus_updateGradInput" + c_SoftPlus_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO () + +-- | c_SoftShrink_updateOutput : state input output lambda -> void +foreign import ccall "THNN.h THNN_FloatSoftShrink_updateOutput" + c_SoftShrink_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | c_SoftShrink_updateGradInput : state input gradOutput gradInput lambda -> void +foreign import ccall "THNN.h THNN_FloatSoftShrink_updateGradInput" + c_SoftShrink_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | c_IndexLinear_updateOutput : state keys keysOffset values sizes cumSumSizes output weight bias normalizedValues train -> void +foreign import ccall "THNN.h THNN_FloatIndexLinear_updateOutput" + c_IndexLinear_updateOutput :: Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_IndexLinear_accGradParameters : state keys keysOffset values sizes cumSumSizes gradOutput gradWeight gradBias weight bias valuesBuffer weightDecay scale -> void +foreign import ccall "THNN.h THNN_FloatIndexLinear_accGradParameters" + c_IndexLinear_accGradParameters :: Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO () + +-- | c_IndexLinear_accUpdateGradParameters : state keys keysOffset values sizes cumSumSizes gradOutput weight bias weightDecay scale -> void +foreign import ccall "THNN.h THNN_FloatIndexLinear_accUpdateGradParameters" + c_IndexLinear_accUpdateGradParameters :: Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO () + +-- | c_IndexLinear_updateParameters : state gradWeight gradBias weight bias runningKeys cumSumSizes keysOffset weightDecay learningRate -> void +foreign import ccall "THNN.h THNN_FloatIndexLinear_updateParameters" + c_IndexLinear_updateParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> CLLong -> CDouble -> CDouble -> IO () + +-- | c_SparseLinear_updateOutput : state input output weight bias -> void +foreign import ccall "THNN.h THNN_FloatSparseLinear_updateOutput" + c_SparseLinear_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_SparseLinear_accGradParameters : state input gradOutput gradWeight gradBias weight bias weightDecay scale -> void +foreign import ccall "THNN.h THNN_FloatSparseLinear_accGradParameters" + c_SparseLinear_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO () + +-- | c_SparseLinear_zeroGradParameters : state gradWeight gradBias lastInput -> void +foreign import ccall "THNN.h THNN_FloatSparseLinear_zeroGradParameters" + c_SparseLinear_zeroGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_SparseLinear_updateParameters : state weight bias gradWeight gradBias lastInput learningRate -> void +foreign import ccall "THNN.h THNN_FloatSparseLinear_updateParameters" + c_SparseLinear_updateParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | c_SparseLinear_legacyUpdateOutput : state input output weight bias -> void +foreign import ccall "THNN.h THNN_FloatSparseLinear_legacyUpdateOutput" + c_SparseLinear_legacyUpdateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_SparseLinear_legacyAccGradParameters : state input gradOutput gradWeight gradBias weight bias weightDecay scale -> void +foreign import ccall "THNN.h THNN_FloatSparseLinear_legacyAccGradParameters" + c_SparseLinear_legacyAccGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO () + +-- | c_SparseLinear_legacyZeroGradParameters : state gradWeight gradBias lastInput -> void +foreign import ccall "THNN.h THNN_FloatSparseLinear_legacyZeroGradParameters" + c_SparseLinear_legacyZeroGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_SparseLinear_legacyUpdateParameters : state weight bias gradWeight gradBias lastInput learningRate -> void +foreign import ccall "THNN.h THNN_FloatSparseLinear_legacyUpdateParameters" + c_SparseLinear_legacyUpdateParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | c_Sqrt_updateOutput : state input output eps -> void +foreign import ccall "THNN.h THNN_FloatSqrt_updateOutput" + c_Sqrt_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | c_Sqrt_updateGradInput : state input gradOutput gradInput output -> void +foreign import ccall "THNN.h THNN_FloatSqrt_updateGradInput" + c_Sqrt_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_Square_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_FloatSquare_updateOutput" + c_Square_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_Square_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_FloatSquare_updateGradInput" + c_Square_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_Tanh_updateOutput : state input output -> void +foreign import ccall "THNN.h THNN_FloatTanh_updateOutput" + c_Tanh_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_Tanh_updateGradInput : state gradOutput gradInput output -> void +foreign import ccall "THNN.h THNN_FloatTanh_updateGradInput" + c_Tanh_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_Threshold_updateOutput : state input output threshold val inplace -> void +foreign import ccall "THNN.h THNN_FloatThreshold_updateOutput" + c_Threshold_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_Threshold_updateGradInput : state input gradOutput gradInput threshold val inplace -> void +foreign import ccall "THNN.h THNN_FloatThreshold_updateGradInput" + c_Threshold_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO () + +-- | c_TemporalConvolution_updateOutput : state input output weight bias kW dW inputFrameSize outputFrameSize -> void +foreign import ccall "THNN.h THNN_FloatTemporalConvolution_updateOutput" + c_TemporalConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_TemporalConvolution_updateGradInput : state input gradOutput gradInput weight kW dW -> void +foreign import ccall "THNN.h THNN_FloatTemporalConvolution_updateGradInput" + c_TemporalConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | c_TemporalConvolution_accGradParameters : state input gradOutput gradWeight gradBias kW dW scale -> void +foreign import ccall "THNN.h THNN_FloatTemporalConvolution_accGradParameters" + c_TemporalConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CDouble -> IO () + +-- | c_TemporalMaxPooling_updateOutput : state input output indices kW dW -> void +foreign import ccall "THNN.h THNN_FloatTemporalMaxPooling_updateOutput" + c_TemporalMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_TemporalMaxPooling_updateGradInput : state input gradOutput gradInput indices kW dW -> void +foreign import ccall "THNN.h THNN_FloatTemporalMaxPooling_updateGradInput" + c_TemporalMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_TemporalSubSampling_updateOutput : state input output weight bias kW dW inputFrameSize -> void +foreign import ccall "THNN.h THNN_FloatTemporalSubSampling_updateOutput" + c_TemporalSubSampling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO () + +-- | c_TemporalSubSampling_updateGradInput : state input gradOutput gradInput weight kW dW -> void +foreign import ccall "THNN.h THNN_FloatTemporalSubSampling_updateGradInput" + c_TemporalSubSampling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | c_TemporalSubSampling_accGradParameters : state input gradOutput gradWeight gradBias kW dW scale -> void +foreign import ccall "THNN.h THNN_FloatTemporalSubSampling_accGradParameters" + c_TemporalSubSampling_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CDouble -> IO () + +-- | c_TemporalRowConvolution_updateOutput : state input output weight bias finput fgradInput kW dW padW featFirst -> void +foreign import ccall "THNN.h THNN_FloatTemporalRowConvolution_updateOutput" + c_TemporalRowConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_TemporalRowConvolution_updateGradInput : state input gradOutput gradInput weight finput fgradInput kW dW padW featFirst -> void +foreign import ccall "THNN.h THNN_FloatTemporalRowConvolution_updateGradInput" + c_TemporalRowConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_TemporalRowConvolution_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kW dW padW featFirst scale -> void +foreign import ccall "THNN.h THNN_FloatTemporalRowConvolution_accGradParameters" + c_TemporalRowConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CBool -> CDouble -> IO () + +-- | c_TemporalUpSamplingNearest_updateOutput : state input output scale_factor -> void +foreign import ccall "THNN.h THNN_FloatTemporalUpSamplingNearest_updateOutput" + c_TemporalUpSamplingNearest_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_TemporalUpSamplingNearest_updateGradInput : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h THNN_FloatTemporalUpSamplingNearest_updateGradInput" + c_TemporalUpSamplingNearest_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_TemporalUpSamplingLinear_updateOutput : state input output osizeW -> void +foreign import ccall "THNN.h THNN_FloatTemporalUpSamplingLinear_updateOutput" + c_TemporalUpSamplingLinear_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_TemporalUpSamplingLinear_updateGradInput : state gradOutput gradInput isizeB isizeC isizeW osizeW -> void +foreign import ccall "THNN.h THNN_FloatTemporalUpSamplingLinear_updateGradInput" + c_TemporalUpSamplingLinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_BatchNormalization_updateOutput : state input output weight bias running_mean running_var save_mean save_std train momentum eps -> void +foreign import ccall "THNN.h THNN_FloatBatchNormalization_updateOutput" + c_BatchNormalization_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CDouble -> CDouble -> IO () + +-- | c_BatchNormalization_backward : state input gradOutput gradInput gradWeight gradBias weight running_mean running_var save_mean save_std train scale eps -> void +foreign import ccall "THNN.h THNN_FloatBatchNormalization_backward" + c_BatchNormalization_backward :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CDouble -> CDouble -> IO () + +-- | c_SpatialConvolutionMap_updateOutput : state input output weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h THNN_FloatSpatialConvolutionMap_updateOutput" + c_SpatialConvolutionMap_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialConvolutionMap_updateGradInput : state input gradOutput gradInput weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h THNN_FloatSpatialConvolutionMap_updateGradInput" + c_SpatialConvolutionMap_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialConvolutionMap_accGradParameters : state input gradOutput gradWeight gradBias connTable nInputPlane nOutputPlane dW dH scale -> void +foreign import ccall "THNN.h THNN_FloatSpatialConvolutionMap_accGradParameters" + c_SpatialConvolutionMap_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialConvolutionMM_updateOutput : state input output weight bias finput fgradInput kW kH dW dH padW padH -> void +foreign import ccall "THNN.h THNN_FloatSpatialConvolutionMM_updateOutput" + c_SpatialConvolutionMM_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialConvolutionMM_updateGradInput : state input gradOutput gradInput weight finput fgradInput kW kH dW dH padW padH -> void +foreign import ccall "THNN.h THNN_FloatSpatialConvolutionMM_updateGradInput" + c_SpatialConvolutionMM_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialConvolutionMM_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kW kH dW dH padW padH scale -> void +foreign import ccall "THNN.h THNN_FloatSpatialConvolutionMM_accGradParameters" + c_SpatialConvolutionMM_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialConvolutionLocal_updateOutput : state input output weight bias finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h THNN_FloatSpatialConvolutionLocal_updateOutput" + c_SpatialConvolutionLocal_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | c_SpatialConvolutionLocal_updateGradInput : state input gradOutput gradInput weight finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h THNN_FloatSpatialConvolutionLocal_updateGradInput" + c_SpatialConvolutionLocal_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | c_SpatialConvolutionLocal_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight scale -> void +foreign import ccall "THNN.h THNN_FloatSpatialConvolutionLocal_accGradParameters" + c_SpatialConvolutionLocal_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CDouble -> IO () + +-- | c_SpatialAdaptiveMaxPooling_updateOutput : state input output indices osizeW osizeH -> void +foreign import ccall "THNN.h THNN_FloatSpatialAdaptiveMaxPooling_updateOutput" + c_SpatialAdaptiveMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_SpatialAdaptiveMaxPooling_updateGradInput : state input gradOutput gradInput indices -> void +foreign import ccall "THNN.h THNN_FloatSpatialAdaptiveMaxPooling_updateGradInput" + c_SpatialAdaptiveMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> IO () + +-- | c_SpatialAdaptiveAveragePooling_updateOutput : state input output osizeW osizeH -> void +foreign import ccall "THNN.h THNN_FloatSpatialAdaptiveAveragePooling_updateOutput" + c_SpatialAdaptiveAveragePooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | c_SpatialAdaptiveAveragePooling_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_FloatSpatialAdaptiveAveragePooling_updateGradInput" + c_SpatialAdaptiveAveragePooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_SpatialAveragePooling_updateOutput : state input output kW kH dW dH padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h THNN_FloatSpatialAveragePooling_updateOutput" + c_SpatialAveragePooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO () + +-- | c_SpatialAveragePooling_updateGradInput : state input gradOutput gradInput kW kH dW dH padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h THNN_FloatSpatialAveragePooling_updateGradInput" + c_SpatialAveragePooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO () + +-- | c_SpatialFractionalMaxPooling_updateOutput : state input output outputW outputH kW kH indices randomSamples -> void +foreign import ccall "THNN.h THNN_FloatSpatialFractionalMaxPooling_updateOutput" + c_SpatialFractionalMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_SpatialFractionalMaxPooling_updateGradInput : state input gradOutput gradInput outputW outputH kW kH indices -> void +foreign import ccall "THNN.h THNN_FloatSpatialFractionalMaxPooling_updateGradInput" + c_SpatialFractionalMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> IO () + +-- | c_SpatialFullConvolution_updateOutput : state input output weight bias columns ones kW kH dW dH padW padH adjW adjH -> void +foreign import ccall "THNN.h THNN_FloatSpatialFullConvolution_updateOutput" + c_SpatialFullConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullConvolution_updateGradInput : state input gradOutput gradInput weight columns kW kH dW dH padW padH adjW adjH -> void +foreign import ccall "THNN.h THNN_FloatSpatialFullConvolution_updateGradInput" + c_SpatialFullConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullConvolution_accGradParameters : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH adjW adjH scale -> void +foreign import ccall "THNN.h THNN_FloatSpatialFullConvolution_accGradParameters" + c_SpatialFullConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialFullConvolutionMap_updateOutput : state input output weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h THNN_FloatSpatialFullConvolutionMap_updateOutput" + c_SpatialFullConvolutionMap_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullConvolutionMap_updateGradInput : state input gradOutput gradInput weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h THNN_FloatSpatialFullConvolutionMap_updateGradInput" + c_SpatialFullConvolutionMap_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullConvolutionMap_accGradParameters : state input gradOutput gradWeight gradBias connTable nInputPlane nOutputPlane dW dH scale -> void +foreign import ccall "THNN.h THNN_FloatSpatialFullConvolutionMap_accGradParameters" + c_SpatialFullConvolutionMap_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialDilatedConvolution_updateOutput : state input output weight bias columns ones kW kH dW dH padW padH dilationW dilationH -> void +foreign import ccall "THNN.h THNN_FloatSpatialDilatedConvolution_updateOutput" + c_SpatialDilatedConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialDilatedConvolution_updateGradInput : state input gradOutput gradInput weight columns kW kH dW dH padW padH dilationW dilationH -> void +foreign import ccall "THNN.h THNN_FloatSpatialDilatedConvolution_updateGradInput" + c_SpatialDilatedConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialDilatedConvolution_accGradParameters : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH dilationW dilationH scale -> void +foreign import ccall "THNN.h THNN_FloatSpatialDilatedConvolution_accGradParameters" + c_SpatialDilatedConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialFullDilatedConvolution_updateOutput : state input output weight bias columns ones kW kH dW dH padW padH dilationW dilationH adjW adjH -> void +foreign import ccall "THNN.h THNN_FloatSpatialFullDilatedConvolution_updateOutput" + c_SpatialFullDilatedConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullDilatedConvolution_updateGradInput : state input gradOutput gradInput weight columns kW kH dW dH padW padH dilationW dilationH adjW adjH -> void +foreign import ccall "THNN.h THNN_FloatSpatialFullDilatedConvolution_updateGradInput" + c_SpatialFullDilatedConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialFullDilatedConvolution_accGradParameters : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH dilationW dilationH adjW adjH scale -> void +foreign import ccall "THNN.h THNN_FloatSpatialFullDilatedConvolution_accGradParameters" + c_SpatialFullDilatedConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialMaxPooling_updateOutput : state input output indices kW kH dW dH padW padH ceil_mode -> void +foreign import ccall "THNN.h THNN_FloatSpatialMaxPooling_updateOutput" + c_SpatialMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_SpatialMaxPooling_updateGradInput : state input gradOutput gradInput indices kW kH dW dH padW padH ceil_mode -> void +foreign import ccall "THNN.h THNN_FloatSpatialMaxPooling_updateGradInput" + c_SpatialMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_SpatialDilatedMaxPooling_updateOutput : state input output indices kW kH dW dH padW padH dilationW dilationH ceil_mode -> void +foreign import ccall "THNN.h THNN_FloatSpatialDilatedMaxPooling_updateOutput" + c_SpatialDilatedMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_SpatialDilatedMaxPooling_updateGradInput : state input gradOutput gradInput indices kW kH dW dH padW padH dilationW dilationH ceil_mode -> void +foreign import ccall "THNN.h THNN_FloatSpatialDilatedMaxPooling_updateGradInput" + c_SpatialDilatedMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_SpatialMaxUnpooling_updateOutput : state input output indices owidth oheight -> void +foreign import ccall "THNN.h THNN_FloatSpatialMaxUnpooling_updateOutput" + c_SpatialMaxUnpooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_SpatialMaxUnpooling_updateGradInput : state input gradOutput gradInput indices owidth oheight -> void +foreign import ccall "THNN.h THNN_FloatSpatialMaxUnpooling_updateGradInput" + c_SpatialMaxUnpooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO () + +-- | c_SpatialSubSampling_updateOutput : state input output weight bias kW kH dW dH -> void +foreign import ccall "THNN.h THNN_FloatSpatialSubSampling_updateOutput" + c_SpatialSubSampling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialSubSampling_updateGradInput : state input gradOutput gradInput weight kW kH dW dH -> void +foreign import ccall "THNN.h THNN_FloatSpatialSubSampling_updateGradInput" + c_SpatialSubSampling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialSubSampling_accGradParameters : state input gradOutput gradWeight gradBias kW kH dW dH scale -> void +foreign import ccall "THNN.h THNN_FloatSpatialSubSampling_accGradParameters" + c_SpatialSubSampling_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_SpatialUpSamplingNearest_updateOutput : state input output scale_factor -> void +foreign import ccall "THNN.h THNN_FloatSpatialUpSamplingNearest_updateOutput" + c_SpatialUpSamplingNearest_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_SpatialUpSamplingNearest_updateGradInput : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h THNN_FloatSpatialUpSamplingNearest_updateGradInput" + c_SpatialUpSamplingNearest_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_SpatialUpSamplingBilinear_updateOutput : state input output osizeH osizeW -> void +foreign import ccall "THNN.h THNN_FloatSpatialUpSamplingBilinear_updateOutput" + c_SpatialUpSamplingBilinear_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | c_SpatialUpSamplingBilinear_updateGradInput : state gradOutput gradInput isizeB isizeC isizeH isizeW osizeH osizeW -> void +foreign import ccall "THNN.h THNN_FloatSpatialUpSamplingBilinear_updateGradInput" + c_SpatialUpSamplingBilinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialGridSamplerBilinear_updateOutput : state input grid output padding_mode -> void +foreign import ccall "THNN.h THNN_FloatSpatialGridSamplerBilinear_updateOutput" + c_SpatialGridSamplerBilinear_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_SpatialGridSamplerBilinear_updateGradInput : state input gradInput grid gradGrid gradOutput padding_mode -> void +foreign import ccall "THNN.h THNN_FloatSpatialGridSamplerBilinear_updateGradInput" + c_SpatialGridSamplerBilinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_VolumetricGridSamplerBilinear_updateOutput : state input grid output padding_mode -> void +foreign import ccall "THNN.h THNN_FloatVolumetricGridSamplerBilinear_updateOutput" + c_VolumetricGridSamplerBilinear_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_VolumetricGridSamplerBilinear_updateGradInput : state input gradInput grid gradGrid gradOutput padding_mode -> void +foreign import ccall "THNN.h THNN_FloatVolumetricGridSamplerBilinear_updateGradInput" + c_VolumetricGridSamplerBilinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_unfolded_acc : finput input kW kH dW dH padW padH nInputPlane inputWidth inputHeight osizeW outputHeight -> void +foreign import ccall "THNN.h THNN_Floatunfolded_acc" + c_unfolded_acc :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_unfolded_copy : finput input kW kH dW dH padW padH nInputPlane inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h THNN_Floatunfolded_copy" + c_unfolded_copy :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricAveragePooling_updateOutput : state input output kT kW kH dT dW dH padT padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h THNN_FloatVolumetricAveragePooling_updateOutput" + c_VolumetricAveragePooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO () + +-- | c_VolumetricAveragePooling_updateGradInput : state input gradOutput gradInput kT kW kH dT dW dH padT padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h THNN_FloatVolumetricAveragePooling_updateGradInput" + c_VolumetricAveragePooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO () + +-- | c_VolumetricConvolution_updateOutput : state input output weight bias finput fgradInput dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricConvolution_updateOutput" + c_VolumetricConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricConvolution_updateGradInput : state input gradOutput gradInput weight finput dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricConvolution_updateGradInput" + c_VolumetricConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricConvolution_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput dT dW dH pT pW pH scale -> void +foreign import ccall "THNN.h THNN_FloatVolumetricConvolution_accGradParameters" + c_VolumetricConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricConvolutionMM_updateOutput : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricConvolutionMM_updateOutput" + c_VolumetricConvolutionMM_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricConvolutionMM_updateGradInput : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricConvolutionMM_updateGradInput" + c_VolumetricConvolutionMM_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricConvolutionMM_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH scale -> void +foreign import ccall "THNN.h THNN_FloatVolumetricConvolutionMM_accGradParameters" + c_VolumetricConvolutionMM_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricFractionalMaxPooling_updateOutput : state input output outputT outputW outputH poolSizeT poolSizeW poolSizeH indices randomSamples -> void +foreign import ccall "THNN.h THNN_FloatVolumetricFractionalMaxPooling_updateOutput" + c_VolumetricFractionalMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_VolumetricFractionalMaxPooling_updateGradInput : state input gradOutput gradInput outputT outputW outputH poolSizeT poolSizeW poolSizeH indices -> void +foreign import ccall "THNN.h THNN_FloatVolumetricFractionalMaxPooling_updateGradInput" + c_VolumetricFractionalMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> IO () + +-- | c_VolumetricFullConvolution_updateOutput : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricFullConvolution_updateOutput" + c_VolumetricFullConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricFullConvolution_updateGradInput : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricFullConvolution_updateGradInput" + c_VolumetricFullConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricFullConvolution_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH scale -> void +foreign import ccall "THNN.h THNN_FloatVolumetricFullConvolution_accGradParameters" + c_VolumetricFullConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricDilatedConvolution_updateOutput : state input output weight bias columns ones kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricDilatedConvolution_updateOutput" + c_VolumetricDilatedConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricDilatedConvolution_updateGradInput : state input gradOutput gradInput weight columns kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricDilatedConvolution_updateGradInput" + c_VolumetricDilatedConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricDilatedConvolution_accGradParameters : state input gradOutput gradWeight gradBias columns ones kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH scale -> void +foreign import ccall "THNN.h THNN_FloatVolumetricDilatedConvolution_accGradParameters" + c_VolumetricDilatedConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricFullDilatedConvolution_updateOutput : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricFullDilatedConvolution_updateOutput" + c_VolumetricFullDilatedConvolution_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricFullDilatedConvolution_updateGradInput : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricFullDilatedConvolution_updateGradInput" + c_VolumetricFullDilatedConvolution_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricFullDilatedConvolution_accGradParameters : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH scale -> void +foreign import ccall "THNN.h THNN_FloatVolumetricFullDilatedConvolution_accGradParameters" + c_VolumetricFullDilatedConvolution_accGradParameters :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO () + +-- | c_VolumetricMaxPooling_updateOutput : state input output indices kT kW kH dT dW dH pT pW pH ceilMode -> void +foreign import ccall "THNN.h THNN_FloatVolumetricMaxPooling_updateOutput" + c_VolumetricMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricMaxPooling_updateGradInput : state input gradOutput gradInput indices kT kW kH dT dW dH pT pW pH ceilMode -> void +foreign import ccall "THNN.h THNN_FloatVolumetricMaxPooling_updateGradInput" + c_VolumetricMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricDilatedMaxPooling_updateOutput : state input output indices kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH ceilMode -> void +foreign import ccall "THNN.h THNN_FloatVolumetricDilatedMaxPooling_updateOutput" + c_VolumetricDilatedMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricDilatedMaxPooling_updateGradInput : state input gradOutput gradInput indices kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH ceilMode -> void +foreign import ccall "THNN.h THNN_FloatVolumetricDilatedMaxPooling_updateGradInput" + c_VolumetricDilatedMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricMaxUnpooling_updateOutput : state input output indices oT oW oH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricMaxUnpooling_updateOutput" + c_VolumetricMaxUnpooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricMaxUnpooling_updateGradInput : state input gradOutput gradInput indices oT oW oH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricMaxUnpooling_updateGradInput" + c_VolumetricMaxUnpooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricAdaptiveAveragePooling_updateOutput : state input output osizeT osizeW osizeH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricAdaptiveAveragePooling_updateOutput" + c_VolumetricAdaptiveAveragePooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricAdaptiveAveragePooling_updateGradInput : state input gradOutput gradInput -> void +foreign import ccall "THNN.h THNN_FloatVolumetricAdaptiveAveragePooling_updateGradInput" + c_VolumetricAdaptiveAveragePooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | c_VolumetricAdaptiveMaxPooling_updateOutput : state input output indices osizeT osizeW osizeH -> void +foreign import ccall "THNN.h THNN_FloatVolumetricAdaptiveMaxPooling_updateOutput" + c_VolumetricAdaptiveMaxPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricAdaptiveMaxPooling_updateGradInput : state input gradOutput gradInput indices -> void +foreign import ccall "THNN.h THNN_FloatVolumetricAdaptiveMaxPooling_updateGradInput" + c_VolumetricAdaptiveMaxPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> IO () + +-- | c_SpatialReflectionPadding_updateOutput : state input output pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h THNN_FloatSpatialReflectionPadding_updateOutput" + c_SpatialReflectionPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialReflectionPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h THNN_FloatSpatialReflectionPadding_updateGradInput" + c_SpatialReflectionPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialReplicationPadding_updateOutput : state input output pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h THNN_FloatSpatialReplicationPadding_updateOutput" + c_SpatialReplicationPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_SpatialReplicationPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h THNN_FloatSpatialReplicationPadding_updateGradInput" + c_SpatialReplicationPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_FeatureLPPooling_updateOutput : state input output power width stride batchMode -> void +foreign import ccall "THNN.h THNN_FloatFeatureLPPooling_updateOutput" + c_FeatureLPPooling_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CInt -> CInt -> CBool -> IO () + +-- | c_FeatureLPPooling_updateGradInput : state gradOutput input output gradInput power width stride batchMode -> void +foreign import ccall "THNN.h THNN_FloatFeatureLPPooling_updateGradInput" + c_FeatureLPPooling_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CInt -> CInt -> CBool -> IO () + +-- | c_VolumetricReplicationPadding_updateOutput : state input output pad_left pad_right pad_top pad_bottom pad_front pad_back -> void +foreign import ccall "THNN.h THNN_FloatVolumetricReplicationPadding_updateOutput" + c_VolumetricReplicationPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricReplicationPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom pad_front pad_back -> void +foreign import ccall "THNN.h THNN_FloatVolumetricReplicationPadding_updateGradInput" + c_VolumetricReplicationPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricUpSamplingNearest_updateOutput : state input output scale_factor -> void +foreign import ccall "THNN.h THNN_FloatVolumetricUpSamplingNearest_updateOutput" + c_VolumetricUpSamplingNearest_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_VolumetricUpSamplingNearest_updateGradInput : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h THNN_FloatVolumetricUpSamplingNearest_updateGradInput" + c_VolumetricUpSamplingNearest_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | c_VolumetricUpSamplingTrilinear_updateOutput : state input output osizeT osizeH osizeW -> void +foreign import ccall "THNN.h THNN_FloatVolumetricUpSamplingTrilinear_updateOutput" + c_VolumetricUpSamplingTrilinear_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO () + +-- | c_VolumetricUpSamplingTrilinear_updateGradInput : state gradOutput gradInput isizeB isizeC isizeT isizeH isizeW osizeT osizeH osizeW -> void +foreign import ccall "THNN.h THNN_FloatVolumetricUpSamplingTrilinear_updateGradInput" + c_VolumetricUpSamplingTrilinear_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () + +-- | c_TemporalReflectionPadding_updateOutput : state input output pad_left pad_right -> void +foreign import ccall "THNN.h THNN_FloatTemporalReflectionPadding_updateOutput" + c_TemporalReflectionPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | c_TemporalReflectionPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right -> void +foreign import ccall "THNN.h THNN_FloatTemporalReflectionPadding_updateGradInput" + c_TemporalReflectionPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | c_TemporalReplicationPadding_updateOutput : state input output pad_left pad_right -> void +foreign import ccall "THNN.h THNN_FloatTemporalReplicationPadding_updateOutput" + c_TemporalReplicationPadding_updateOutput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | c_TemporalReplicationPadding_updateGradInput : state input gradOutput gradInput pad_left pad_right -> void +foreign import ccall "THNN.h THNN_FloatTemporalReplicationPadding_updateGradInput" + c_TemporalReplicationPadding_updateGradInput :: Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | p_Abs_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_FloatAbs_updateOutput" + p_Abs_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_Abs_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_FloatAbs_updateGradInput" + p_Abs_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_AbsCriterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatAbsCriterion_updateOutput" + p_AbsCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_AbsCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatAbsCriterion_updateGradInput" + p_AbsCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_BCECriterion_updateOutput : Pointer to function : state input target output sizeAverage weights reduce -> void +foreign import ccall "THNN.h &THNN_FloatBCECriterion_updateOutput" + p_BCECriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> CBool -> IO ()) + +-- | p_BCECriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage weights reduce -> void +foreign import ccall "THNN.h &THNN_FloatBCECriterion_updateGradInput" + p_BCECriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> CBool -> IO ()) + +-- | p_ClassNLLCriterion_updateOutput : Pointer to function : state input target output sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h &THNN_FloatClassNLLCriterion_updateOutput" + p_ClassNLLCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CBool -> IO ()) + +-- | p_ClassNLLCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h &THNN_FloatClassNLLCriterion_updateGradInput" + p_ClassNLLCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CBool -> IO ()) + +-- | p_SpatialClassNLLCriterion_updateOutput : Pointer to function : state input target output sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h &THNN_FloatSpatialClassNLLCriterion_updateOutput" + p_SpatialClassNLLCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CBool -> IO ()) + +-- | p_SpatialClassNLLCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage weights total_weight ignore_index reduce -> void +foreign import ccall "THNN.h &THNN_FloatSpatialClassNLLCriterion_updateGradInput" + p_SpatialClassNLLCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CBool -> IO ()) + +-- | p_ELU_updateOutput : Pointer to function : state input output alpha scale inplace -> void +foreign import ccall "THNN.h &THNN_FloatELU_updateOutput" + p_ELU_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_ELU_updateGradInput : Pointer to function : state gradOutput gradInput output alpha scale -> void +foreign import ccall "THNN.h &THNN_FloatELU_updateGradInput" + p_ELU_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO ()) + +-- | p_DistKLDivCriterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatDistKLDivCriterion_updateOutput" + p_DistKLDivCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_DistKLDivCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatDistKLDivCriterion_updateGradInput" + p_DistKLDivCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_GatedLinear_updateOutput : Pointer to function : state input output dim -> void +foreign import ccall "THNN.h &THNN_FloatGatedLinear_updateOutput" + p_GatedLinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_GatedLinear_updateGradInput : Pointer to function : state input gradOutput gradInput dim -> void +foreign import ccall "THNN.h &THNN_FloatGatedLinear_updateGradInput" + p_GatedLinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_HardShrink_updateOutput : Pointer to function : state input output lambda -> void +foreign import ccall "THNN.h &THNN_FloatHardShrink_updateOutput" + p_HardShrink_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_HardShrink_updateGradInput : Pointer to function : state input gradOutput gradInput lambda -> void +foreign import ccall "THNN.h &THNN_FloatHardShrink_updateGradInput" + p_HardShrink_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_HardTanh_updateOutput : Pointer to function : state input output min_val max_val inplace -> void +foreign import ccall "THNN.h &THNN_FloatHardTanh_updateOutput" + p_HardTanh_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_HardTanh_updateGradInput : Pointer to function : state input gradOutput gradInput min_val max_val inplace -> void +foreign import ccall "THNN.h &THNN_FloatHardTanh_updateGradInput" + p_HardTanh_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_Im2Col_updateOutput : Pointer to function : state input output kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h &THNN_FloatIm2Col_updateOutput" + p_Im2Col_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_Im2Col_updateGradInput : Pointer to function : state gradOutput gradInput inputHeight inputWidth kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h &THNN_FloatIm2Col_updateGradInput" + p_Im2Col_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_Col2Im_updateOutput : Pointer to function : state input output outputHeight outputWidth kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h &THNN_FloatCol2Im_updateOutput" + p_Col2Im_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_Col2Im_updateGradInput : Pointer to function : state gradOutput gradInput kH kW dH dW padH padW sH sW -> void +foreign import ccall "THNN.h &THNN_FloatCol2Im_updateGradInput" + p_Col2Im_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_L1Cost_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_FloatL1Cost_updateOutput" + p_L1Cost_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_L1Cost_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_FloatL1Cost_updateGradInput" + p_L1Cost_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_LeakyReLU_updateOutput : Pointer to function : state input output negval inplace -> void +foreign import ccall "THNN.h &THNN_FloatLeakyReLU_updateOutput" + p_LeakyReLU_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CBool -> IO ()) + +-- | p_LeakyReLU_updateGradInput : Pointer to function : state input gradOutput gradInput negval inplace -> void +foreign import ccall "THNN.h &THNN_FloatLeakyReLU_updateGradInput" + p_LeakyReLU_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CBool -> IO ()) + +-- | p_GRUFused_updateOutput : Pointer to function : state input hidden bias1 bias2 hx output storage -> void +foreign import ccall "THNN.h &THNN_FloatGRUFused_updateOutput" + p_GRUFused_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_GRUFused_updateGradInput : Pointer to function : state gradInInput gradInHidden gradOutput gradInputHx storage -> void +foreign import ccall "THNN.h &THNN_FloatGRUFused_updateGradInput" + p_GRUFused_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_LSTMFused_updateOutput : Pointer to function : state input hidden bias1 bias2 cell output outputCell -> void +foreign import ccall "THNN.h &THNN_FloatLSTMFused_updateOutput" + p_LSTMFused_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_LSTMFused_updateGradInput : Pointer to function : state storage gradInGates cx cy gradOutput gradOutputCell gradInputCx -> void +foreign import ccall "THNN.h &THNN_FloatLSTMFused_updateGradInput" + p_LSTMFused_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_LogSigmoid_updateOutput : Pointer to function : state input output buffer -> void +foreign import ccall "THNN.h &THNN_FloatLogSigmoid_updateOutput" + p_LogSigmoid_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_LogSigmoid_updateGradInput : Pointer to function : state input gradOutput gradInput buffer -> void +foreign import ccall "THNN.h &THNN_FloatLogSigmoid_updateGradInput" + p_LogSigmoid_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_LogSoftMax_updateOutput : Pointer to function : state input output dim -> void +foreign import ccall "THNN.h &THNN_FloatLogSoftMax_updateOutput" + p_LogSoftMax_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO ()) + +-- | p_LogSoftMax_updateGradInput : Pointer to function : state input gradOutput gradInput output dim -> void +foreign import ccall "THNN.h &THNN_FloatLogSoftMax_updateGradInput" + p_LogSoftMax_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO ()) + +-- | p_LookupTable_accGradParameters : Pointer to function : state input gradOutput gradWeight count sorted indices scaleGradByFreq paddingValue scale -> void +foreign import ccall "THNN.h &THNN_FloatLookupTable_accGradParameters" + p_LookupTable_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIntegerTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CBool -> CInt -> CDouble -> IO ()) + +-- | p_LookupTable_renorm : Pointer to function : state idx weight maxNorm normType -> void +foreign import ccall "THNN.h &THNN_FloatLookupTable_renorm" + p_LookupTable_renorm :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO ()) + +-- | p_MarginCriterion_updateOutput : Pointer to function : state input target output sizeAverage margin -> void +foreign import ccall "THNN.h &THNN_FloatMarginCriterion_updateOutput" + p_MarginCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CDouble -> IO ()) + +-- | p_MarginCriterion_updateGradInput : Pointer to function : state input target gradInput sizeAverage margin -> void +foreign import ccall "THNN.h &THNN_FloatMarginCriterion_updateGradInput" + p_MarginCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CDouble -> IO ()) + +-- | p_SoftMarginCriterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatSoftMarginCriterion_updateOutput" + p_SoftMarginCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_SoftMarginCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatSoftMarginCriterion_updateGradInput" + p_SoftMarginCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_MSECriterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatMSECriterion_updateOutput" + p_MSECriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_MSECriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatMSECriterion_updateGradInput" + p_MSECriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_MultiLabelMarginCriterion_updateOutput : Pointer to function : state input target output isTarget sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatMultiLabelMarginCriterion_updateOutput" + p_MultiLabelMarginCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_MultiLabelMarginCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput isTarget sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatMultiLabelMarginCriterion_updateGradInput" + p_MultiLabelMarginCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_MultiMarginCriterion_updateOutput : Pointer to function : state input target output sizeAverage p weights margin reduce -> void +foreign import ccall "THNN.h &THNN_FloatMultiMarginCriterion_updateOutput" + p_MultiMarginCriterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> CBool -> CInt -> Ptr C'THFloatTensor -> CDouble -> CBool -> IO ()) + +-- | p_MultiMarginCriterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage p weights margin reduce -> void +foreign import ccall "THNN.h &THNN_FloatMultiMarginCriterion_updateGradInput" + p_MultiMarginCriterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CInt -> Ptr C'THFloatTensor -> CDouble -> CBool -> IO ()) + +-- | p_PReLU_updateOutput : Pointer to function : state input output weight -> void +foreign import ccall "THNN.h &THNN_FloatPReLU_updateOutput" + p_PReLU_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_PReLU_updateGradInput : Pointer to function : state input gradOutput gradInput weight -> void +foreign import ccall "THNN.h &THNN_FloatPReLU_updateGradInput" + p_PReLU_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_PReLU_accGradParameters : Pointer to function : state input gradOutput gradInput weight gradWeight scale -> void +foreign import ccall "THNN.h &THNN_FloatPReLU_accGradParameters" + p_PReLU_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_Linear_updateOutput : Pointer to function : state input output weight bias addBuffer -> void +foreign import ccall "THNN.h &THNN_FloatLinear_updateOutput" + p_Linear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_Linear_updateGradInput : Pointer to function : state input gradOutput gradInput weight -> void +foreign import ccall "THNN.h &THNN_FloatLinear_updateGradInput" + p_Linear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_Linear_accGradParameters : Pointer to function : state input gradOutput gradInput weight bias gradWeight gradBias addBuffer scale -> void +foreign import ccall "THNN.h &THNN_FloatLinear_accGradParameters" + p_Linear_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_RReLU_updateOutput : Pointer to function : state input output noise lower upper train inplace generator -> void +foreign import ccall "THNN.h &THNN_FloatRReLU_updateOutput" + p_RReLU_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> CBool -> Ptr C'THGenerator -> IO ()) + +-- | p_RReLU_updateGradInput : Pointer to function : state input gradOutput gradInput noise lower upper train inplace -> void +foreign import ccall "THNN.h &THNN_FloatRReLU_updateGradInput" + p_RReLU_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> CBool -> IO ()) + +-- | p_Sigmoid_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_FloatSigmoid_updateOutput" + p_Sigmoid_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_Sigmoid_updateGradInput : Pointer to function : state gradOutput gradInput output -> void +foreign import ccall "THNN.h &THNN_FloatSigmoid_updateGradInput" + p_Sigmoid_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_SmoothL1Criterion_updateOutput : Pointer to function : state input target output sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatSmoothL1Criterion_updateOutput" + p_SmoothL1Criterion_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_SmoothL1Criterion_updateGradInput : Pointer to function : state input target gradOutput gradInput sizeAverage reduce -> void +foreign import ccall "THNN.h &THNN_FloatSmoothL1Criterion_updateGradInput" + p_SmoothL1Criterion_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CBool -> IO ()) + +-- | p_SoftMax_updateOutput : Pointer to function : state input output dim -> void +foreign import ccall "THNN.h &THNN_FloatSoftMax_updateOutput" + p_SoftMax_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO ()) + +-- | p_SoftMax_updateGradInput : Pointer to function : state input gradOutput gradInput output dim -> void +foreign import ccall "THNN.h &THNN_FloatSoftMax_updateGradInput" + p_SoftMax_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO ()) + +-- | p_SoftPlus_updateOutput : Pointer to function : state input output beta threshold -> void +foreign import ccall "THNN.h &THNN_FloatSoftPlus_updateOutput" + p_SoftPlus_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO ()) + +-- | p_SoftPlus_updateGradInput : Pointer to function : state input gradOutput gradInput output beta threshold -> void +foreign import ccall "THNN.h &THNN_FloatSoftPlus_updateGradInput" + p_SoftPlus_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO ()) + +-- | p_SoftShrink_updateOutput : Pointer to function : state input output lambda -> void +foreign import ccall "THNN.h &THNN_FloatSoftShrink_updateOutput" + p_SoftShrink_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_SoftShrink_updateGradInput : Pointer to function : state input gradOutput gradInput lambda -> void +foreign import ccall "THNN.h &THNN_FloatSoftShrink_updateGradInput" + p_SoftShrink_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_IndexLinear_updateOutput : Pointer to function : state keys keysOffset values sizes cumSumSizes output weight bias normalizedValues train -> void +foreign import ccall "THNN.h &THNN_FloatIndexLinear_updateOutput" + p_IndexLinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_IndexLinear_accGradParameters : Pointer to function : state keys keysOffset values sizes cumSumSizes gradOutput gradWeight gradBias weight bias valuesBuffer weightDecay scale -> void +foreign import ccall "THNN.h &THNN_FloatIndexLinear_accGradParameters" + p_IndexLinear_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO ()) + +-- | p_IndexLinear_accUpdateGradParameters : Pointer to function : state keys keysOffset values sizes cumSumSizes gradOutput weight bias weightDecay scale -> void +foreign import ccall "THNN.h &THNN_FloatIndexLinear_accUpdateGradParameters" + p_IndexLinear_accUpdateGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THIndexTensor -> CLLong -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO ()) + +-- | p_IndexLinear_updateParameters : Pointer to function : state gradWeight gradBias weight bias runningKeys cumSumSizes keysOffset weightDecay learningRate -> void +foreign import ccall "THNN.h &THNN_FloatIndexLinear_updateParameters" + p_IndexLinear_updateParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> Ptr C'THIndexTensor -> CLLong -> CDouble -> CDouble -> IO ()) + +-- | p_SparseLinear_updateOutput : Pointer to function : state input output weight bias -> void +foreign import ccall "THNN.h &THNN_FloatSparseLinear_updateOutput" + p_SparseLinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_SparseLinear_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias weight bias weightDecay scale -> void +foreign import ccall "THNN.h &THNN_FloatSparseLinear_accGradParameters" + p_SparseLinear_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO ()) + +-- | p_SparseLinear_zeroGradParameters : Pointer to function : state gradWeight gradBias lastInput -> void +foreign import ccall "THNN.h &THNN_FloatSparseLinear_zeroGradParameters" + p_SparseLinear_zeroGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_SparseLinear_updateParameters : Pointer to function : state weight bias gradWeight gradBias lastInput learningRate -> void +foreign import ccall "THNN.h &THNN_FloatSparseLinear_updateParameters" + p_SparseLinear_updateParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_SparseLinear_legacyUpdateOutput : Pointer to function : state input output weight bias -> void +foreign import ccall "THNN.h &THNN_FloatSparseLinear_legacyUpdateOutput" + p_SparseLinear_legacyUpdateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_SparseLinear_legacyAccGradParameters : Pointer to function : state input gradOutput gradWeight gradBias weight bias weightDecay scale -> void +foreign import ccall "THNN.h &THNN_FloatSparseLinear_legacyAccGradParameters" + p_SparseLinear_legacyAccGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> IO ()) + +-- | p_SparseLinear_legacyZeroGradParameters : Pointer to function : state gradWeight gradBias lastInput -> void +foreign import ccall "THNN.h &THNN_FloatSparseLinear_legacyZeroGradParameters" + p_SparseLinear_legacyZeroGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_SparseLinear_legacyUpdateParameters : Pointer to function : state weight bias gradWeight gradBias lastInput learningRate -> void +foreign import ccall "THNN.h &THNN_FloatSparseLinear_legacyUpdateParameters" + p_SparseLinear_legacyUpdateParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_Sqrt_updateOutput : Pointer to function : state input output eps -> void +foreign import ccall "THNN.h &THNN_FloatSqrt_updateOutput" + p_Sqrt_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_Sqrt_updateGradInput : Pointer to function : state input gradOutput gradInput output -> void +foreign import ccall "THNN.h &THNN_FloatSqrt_updateGradInput" + p_Sqrt_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_Square_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_FloatSquare_updateOutput" + p_Square_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_Square_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_FloatSquare_updateGradInput" + p_Square_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_Tanh_updateOutput : Pointer to function : state input output -> void +foreign import ccall "THNN.h &THNN_FloatTanh_updateOutput" + p_Tanh_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_Tanh_updateGradInput : Pointer to function : state gradOutput gradInput output -> void +foreign import ccall "THNN.h &THNN_FloatTanh_updateGradInput" + p_Tanh_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_Threshold_updateOutput : Pointer to function : state input output threshold val inplace -> void +foreign import ccall "THNN.h &THNN_FloatThreshold_updateOutput" + p_Threshold_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_Threshold_updateGradInput : Pointer to function : state input gradOutput gradInput threshold val inplace -> void +foreign import ccall "THNN.h &THNN_FloatThreshold_updateGradInput" + p_Threshold_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CBool -> IO ()) + +-- | p_TemporalConvolution_updateOutput : Pointer to function : state input output weight bias kW dW inputFrameSize outputFrameSize -> void +foreign import ccall "THNN.h &THNN_FloatTemporalConvolution_updateOutput" + p_TemporalConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_TemporalConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight kW dW -> void +foreign import ccall "THNN.h &THNN_FloatTemporalConvolution_updateGradInput" + p_TemporalConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias kW dW scale -> void +foreign import ccall "THNN.h &THNN_FloatTemporalConvolution_accGradParameters" + p_TemporalConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_TemporalMaxPooling_updateOutput : Pointer to function : state input output indices kW dW -> void +foreign import ccall "THNN.h &THNN_FloatTemporalMaxPooling_updateOutput" + p_TemporalMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kW dW -> void +foreign import ccall "THNN.h &THNN_FloatTemporalMaxPooling_updateGradInput" + p_TemporalMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalSubSampling_updateOutput : Pointer to function : state input output weight bias kW dW inputFrameSize -> void +foreign import ccall "THNN.h &THNN_FloatTemporalSubSampling_updateOutput" + p_TemporalSubSampling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_TemporalSubSampling_updateGradInput : Pointer to function : state input gradOutput gradInput weight kW dW -> void +foreign import ccall "THNN.h &THNN_FloatTemporalSubSampling_updateGradInput" + p_TemporalSubSampling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalSubSampling_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias kW dW scale -> void +foreign import ccall "THNN.h &THNN_FloatTemporalSubSampling_accGradParameters" + p_TemporalSubSampling_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_TemporalRowConvolution_updateOutput : Pointer to function : state input output weight bias finput fgradInput kW dW padW featFirst -> void +foreign import ccall "THNN.h &THNN_FloatTemporalRowConvolution_updateOutput" + p_TemporalRowConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_TemporalRowConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kW dW padW featFirst -> void +foreign import ccall "THNN.h &THNN_FloatTemporalRowConvolution_updateGradInput" + p_TemporalRowConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_TemporalRowConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kW dW padW featFirst scale -> void +foreign import ccall "THNN.h &THNN_FloatTemporalRowConvolution_accGradParameters" + p_TemporalRowConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CBool -> CDouble -> IO ()) + +-- | p_TemporalUpSamplingNearest_updateOutput : Pointer to function : state input output scale_factor -> void +foreign import ccall "THNN.h &THNN_FloatTemporalUpSamplingNearest_updateOutput" + p_TemporalUpSamplingNearest_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_TemporalUpSamplingNearest_updateGradInput : Pointer to function : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h &THNN_FloatTemporalUpSamplingNearest_updateGradInput" + p_TemporalUpSamplingNearest_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_TemporalUpSamplingLinear_updateOutput : Pointer to function : state input output osizeW -> void +foreign import ccall "THNN.h &THNN_FloatTemporalUpSamplingLinear_updateOutput" + p_TemporalUpSamplingLinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_TemporalUpSamplingLinear_updateGradInput : Pointer to function : state gradOutput gradInput isizeB isizeC isizeW osizeW -> void +foreign import ccall "THNN.h &THNN_FloatTemporalUpSamplingLinear_updateGradInput" + p_TemporalUpSamplingLinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_BatchNormalization_updateOutput : Pointer to function : state input output weight bias running_mean running_var save_mean save_std train momentum eps -> void +foreign import ccall "THNN.h &THNN_FloatBatchNormalization_updateOutput" + p_BatchNormalization_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CDouble -> CDouble -> IO ()) + +-- | p_BatchNormalization_backward : Pointer to function : state input gradOutput gradInput gradWeight gradBias weight running_mean running_var save_mean save_std train scale eps -> void +foreign import ccall "THNN.h &THNN_FloatBatchNormalization_backward" + p_BatchNormalization_backward :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CBool -> CDouble -> CDouble -> IO ()) + +-- | p_SpatialConvolutionMap_updateOutput : Pointer to function : state input output weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialConvolutionMap_updateOutput" + p_SpatialConvolutionMap_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialConvolutionMap_updateGradInput : Pointer to function : state input gradOutput gradInput weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialConvolutionMap_updateGradInput" + p_SpatialConvolutionMap_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialConvolutionMap_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias connTable nInputPlane nOutputPlane dW dH scale -> void +foreign import ccall "THNN.h &THNN_FloatSpatialConvolutionMap_accGradParameters" + p_SpatialConvolutionMap_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialConvolutionMM_updateOutput : Pointer to function : state input output weight bias finput fgradInput kW kH dW dH padW padH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialConvolutionMM_updateOutput" + p_SpatialConvolutionMM_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialConvolutionMM_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kW kH dW dH padW padH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialConvolutionMM_updateGradInput" + p_SpatialConvolutionMM_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialConvolutionMM_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kW kH dW dH padW padH scale -> void +foreign import ccall "THNN.h &THNN_FloatSpatialConvolutionMM_accGradParameters" + p_SpatialConvolutionMM_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialConvolutionLocal_updateOutput : Pointer to function : state input output weight bias finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h &THNN_FloatSpatialConvolutionLocal_updateOutput" + p_SpatialConvolutionLocal_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_SpatialConvolutionLocal_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h &THNN_FloatSpatialConvolutionLocal_updateGradInput" + p_SpatialConvolutionLocal_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_SpatialConvolutionLocal_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kW kH dW dH padW padH inputWidth inputHeight outputWidth outputHeight scale -> void +foreign import ccall "THNN.h &THNN_FloatSpatialConvolutionLocal_accGradParameters" + p_SpatialConvolutionLocal_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CDouble -> IO ()) + +-- | p_SpatialAdaptiveMaxPooling_updateOutput : Pointer to function : state input output indices osizeW osizeH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialAdaptiveMaxPooling_updateOutput" + p_SpatialAdaptiveMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialAdaptiveMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices -> void +foreign import ccall "THNN.h &THNN_FloatSpatialAdaptiveMaxPooling_updateGradInput" + p_SpatialAdaptiveMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> IO ()) + +-- | p_SpatialAdaptiveAveragePooling_updateOutput : Pointer to function : state input output osizeW osizeH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialAdaptiveAveragePooling_updateOutput" + p_SpatialAdaptiveAveragePooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialAdaptiveAveragePooling_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_FloatSpatialAdaptiveAveragePooling_updateGradInput" + p_SpatialAdaptiveAveragePooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_SpatialAveragePooling_updateOutput : Pointer to function : state input output kW kH dW dH padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h &THNN_FloatSpatialAveragePooling_updateOutput" + p_SpatialAveragePooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO ()) + +-- | p_SpatialAveragePooling_updateGradInput : Pointer to function : state input gradOutput gradInput kW kH dW dH padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h &THNN_FloatSpatialAveragePooling_updateGradInput" + p_SpatialAveragePooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO ()) + +-- | p_SpatialFractionalMaxPooling_updateOutput : Pointer to function : state input output outputW outputH kW kH indices randomSamples -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFractionalMaxPooling_updateOutput" + p_SpatialFractionalMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_SpatialFractionalMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput outputW outputH kW kH indices -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFractionalMaxPooling_updateGradInput" + p_SpatialFractionalMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> IO ()) + +-- | p_SpatialFullConvolution_updateOutput : Pointer to function : state input output weight bias columns ones kW kH dW dH padW padH adjW adjH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFullConvolution_updateOutput" + p_SpatialFullConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight columns kW kH dW dH padW padH adjW adjH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFullConvolution_updateGradInput" + p_SpatialFullConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH adjW adjH scale -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFullConvolution_accGradParameters" + p_SpatialFullConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialFullConvolutionMap_updateOutput : Pointer to function : state input output weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFullConvolutionMap_updateOutput" + p_SpatialFullConvolutionMap_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullConvolutionMap_updateGradInput : Pointer to function : state input gradOutput gradInput weight bias connTable nInputPlane nOutputPlane dW dH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFullConvolutionMap_updateGradInput" + p_SpatialFullConvolutionMap_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullConvolutionMap_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias connTable nInputPlane nOutputPlane dW dH scale -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFullConvolutionMap_accGradParameters" + p_SpatialFullConvolutionMap_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialDilatedConvolution_updateOutput : Pointer to function : state input output weight bias columns ones kW kH dW dH padW padH dilationW dilationH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialDilatedConvolution_updateOutput" + p_SpatialDilatedConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialDilatedConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight columns kW kH dW dH padW padH dilationW dilationH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialDilatedConvolution_updateGradInput" + p_SpatialDilatedConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialDilatedConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH dilationW dilationH scale -> void +foreign import ccall "THNN.h &THNN_FloatSpatialDilatedConvolution_accGradParameters" + p_SpatialDilatedConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialFullDilatedConvolution_updateOutput : Pointer to function : state input output weight bias columns ones kW kH dW dH padW padH dilationW dilationH adjW adjH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFullDilatedConvolution_updateOutput" + p_SpatialFullDilatedConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullDilatedConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight columns kW kH dW dH padW padH dilationW dilationH adjW adjH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFullDilatedConvolution_updateGradInput" + p_SpatialFullDilatedConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialFullDilatedConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias columns ones kW kH dW dH padW padH dilationW dilationH adjW adjH scale -> void +foreign import ccall "THNN.h &THNN_FloatSpatialFullDilatedConvolution_accGradParameters" + p_SpatialFullDilatedConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialMaxPooling_updateOutput : Pointer to function : state input output indices kW kH dW dH padW padH ceil_mode -> void +foreign import ccall "THNN.h &THNN_FloatSpatialMaxPooling_updateOutput" + p_SpatialMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_SpatialMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kW kH dW dH padW padH ceil_mode -> void +foreign import ccall "THNN.h &THNN_FloatSpatialMaxPooling_updateGradInput" + p_SpatialMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_SpatialDilatedMaxPooling_updateOutput : Pointer to function : state input output indices kW kH dW dH padW padH dilationW dilationH ceil_mode -> void +foreign import ccall "THNN.h &THNN_FloatSpatialDilatedMaxPooling_updateOutput" + p_SpatialDilatedMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_SpatialDilatedMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kW kH dW dH padW padH dilationW dilationH ceil_mode -> void +foreign import ccall "THNN.h &THNN_FloatSpatialDilatedMaxPooling_updateGradInput" + p_SpatialDilatedMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_SpatialMaxUnpooling_updateOutput : Pointer to function : state input output indices owidth oheight -> void +foreign import ccall "THNN.h &THNN_FloatSpatialMaxUnpooling_updateOutput" + p_SpatialMaxUnpooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialMaxUnpooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices owidth oheight -> void +foreign import ccall "THNN.h &THNN_FloatSpatialMaxUnpooling_updateGradInput" + p_SpatialMaxUnpooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialSubSampling_updateOutput : Pointer to function : state input output weight bias kW kH dW dH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialSubSampling_updateOutput" + p_SpatialSubSampling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialSubSampling_updateGradInput : Pointer to function : state input gradOutput gradInput weight kW kH dW dH -> void +foreign import ccall "THNN.h &THNN_FloatSpatialSubSampling_updateGradInput" + p_SpatialSubSampling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialSubSampling_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias kW kH dW dH scale -> void +foreign import ccall "THNN.h &THNN_FloatSpatialSubSampling_accGradParameters" + p_SpatialSubSampling_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_SpatialUpSamplingNearest_updateOutput : Pointer to function : state input output scale_factor -> void +foreign import ccall "THNN.h &THNN_FloatSpatialUpSamplingNearest_updateOutput" + p_SpatialUpSamplingNearest_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_SpatialUpSamplingNearest_updateGradInput : Pointer to function : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h &THNN_FloatSpatialUpSamplingNearest_updateGradInput" + p_SpatialUpSamplingNearest_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_SpatialUpSamplingBilinear_updateOutput : Pointer to function : state input output osizeH osizeW -> void +foreign import ccall "THNN.h &THNN_FloatSpatialUpSamplingBilinear_updateOutput" + p_SpatialUpSamplingBilinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_SpatialUpSamplingBilinear_updateGradInput : Pointer to function : state gradOutput gradInput isizeB isizeC isizeH isizeW osizeH osizeW -> void +foreign import ccall "THNN.h &THNN_FloatSpatialUpSamplingBilinear_updateGradInput" + p_SpatialUpSamplingBilinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialGridSamplerBilinear_updateOutput : Pointer to function : state input grid output padding_mode -> void +foreign import ccall "THNN.h &THNN_FloatSpatialGridSamplerBilinear_updateOutput" + p_SpatialGridSamplerBilinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_SpatialGridSamplerBilinear_updateGradInput : Pointer to function : state input gradInput grid gradGrid gradOutput padding_mode -> void +foreign import ccall "THNN.h &THNN_FloatSpatialGridSamplerBilinear_updateGradInput" + p_SpatialGridSamplerBilinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_VolumetricGridSamplerBilinear_updateOutput : Pointer to function : state input grid output padding_mode -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricGridSamplerBilinear_updateOutput" + p_VolumetricGridSamplerBilinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_VolumetricGridSamplerBilinear_updateGradInput : Pointer to function : state input gradInput grid gradGrid gradOutput padding_mode -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricGridSamplerBilinear_updateGradInput" + p_VolumetricGridSamplerBilinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_unfolded_acc : Pointer to function : finput input kW kH dW dH padW padH nInputPlane inputWidth inputHeight osizeW outputHeight -> void +foreign import ccall "THNN.h &THNN_Floatunfolded_acc" + p_unfolded_acc :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_unfolded_copy : Pointer to function : finput input kW kH dW dH padW padH nInputPlane inputWidth inputHeight outputWidth outputHeight -> void +foreign import ccall "THNN.h &THNN_Floatunfolded_copy" + p_unfolded_copy :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricAveragePooling_updateOutput : Pointer to function : state input output kT kW kH dT dW dH padT padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricAveragePooling_updateOutput" + p_VolumetricAveragePooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO ()) + +-- | p_VolumetricAveragePooling_updateGradInput : Pointer to function : state input gradOutput gradInput kT kW kH dT dW dH padT padW padH ceil_mode count_include_pad -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricAveragePooling_updateGradInput" + p_VolumetricAveragePooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> CBool -> IO ()) + +-- | p_VolumetricConvolution_updateOutput : Pointer to function : state input output weight bias finput fgradInput dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricConvolution_updateOutput" + p_VolumetricConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricConvolution_updateGradInput" + p_VolumetricConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput dT dW dH pT pW pH scale -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricConvolution_accGradParameters" + p_VolumetricConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricConvolutionMM_updateOutput : Pointer to function : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricConvolutionMM_updateOutput" + p_VolumetricConvolutionMM_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricConvolutionMM_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricConvolutionMM_updateGradInput" + p_VolumetricConvolutionMM_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricConvolutionMM_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH scale -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricConvolutionMM_accGradParameters" + p_VolumetricConvolutionMM_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricFractionalMaxPooling_updateOutput : Pointer to function : state input output outputT outputW outputH poolSizeT poolSizeW poolSizeH indices randomSamples -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricFractionalMaxPooling_updateOutput" + p_VolumetricFractionalMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_VolumetricFractionalMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput outputT outputW outputH poolSizeT poolSizeW poolSizeH indices -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricFractionalMaxPooling_updateGradInput" + p_VolumetricFractionalMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr C'THIndexTensor -> IO ()) + +-- | p_VolumetricFullConvolution_updateOutput : Pointer to function : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricFullConvolution_updateOutput" + p_VolumetricFullConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricFullConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricFullConvolution_updateGradInput" + p_VolumetricFullConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricFullConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH aT aW aH scale -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricFullConvolution_accGradParameters" + p_VolumetricFullConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricDilatedConvolution_updateOutput : Pointer to function : state input output weight bias columns ones kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricDilatedConvolution_updateOutput" + p_VolumetricDilatedConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricDilatedConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight columns kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricDilatedConvolution_updateGradInput" + p_VolumetricDilatedConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricDilatedConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias columns ones kT kW kH dT dW dH padT padW padH dilationT dilationW dilationH scale -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricDilatedConvolution_accGradParameters" + p_VolumetricDilatedConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricFullDilatedConvolution_updateOutput : Pointer to function : state input output weight bias finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricFullDilatedConvolution_updateOutput" + p_VolumetricFullDilatedConvolution_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricFullDilatedConvolution_updateGradInput : Pointer to function : state input gradOutput gradInput weight finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricFullDilatedConvolution_updateGradInput" + p_VolumetricFullDilatedConvolution_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricFullDilatedConvolution_accGradParameters : Pointer to function : state input gradOutput gradWeight gradBias finput fgradInput kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH aT aW aH scale -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricFullDilatedConvolution_accGradParameters" + p_VolumetricFullDilatedConvolution_accGradParameters :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CDouble -> IO ()) + +-- | p_VolumetricMaxPooling_updateOutput : Pointer to function : state input output indices kT kW kH dT dW dH pT pW pH ceilMode -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricMaxPooling_updateOutput" + p_VolumetricMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kT kW kH dT dW dH pT pW pH ceilMode -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricMaxPooling_updateGradInput" + p_VolumetricMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricDilatedMaxPooling_updateOutput : Pointer to function : state input output indices kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH ceilMode -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricDilatedMaxPooling_updateOutput" + p_VolumetricDilatedMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricDilatedMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices kT kW kH dT dW dH pT pW pH dilationT dilationW dilationH ceilMode -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricDilatedMaxPooling_updateGradInput" + p_VolumetricDilatedMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricMaxUnpooling_updateOutput : Pointer to function : state input output indices oT oW oH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricMaxUnpooling_updateOutput" + p_VolumetricMaxUnpooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricMaxUnpooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices oT oW oH dT dW dH pT pW pH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricMaxUnpooling_updateGradInput" + p_VolumetricMaxUnpooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricAdaptiveAveragePooling_updateOutput : Pointer to function : state input output osizeT osizeW osizeH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricAdaptiveAveragePooling_updateOutput" + p_VolumetricAdaptiveAveragePooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricAdaptiveAveragePooling_updateGradInput : Pointer to function : state input gradOutput gradInput -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricAdaptiveAveragePooling_updateGradInput" + p_VolumetricAdaptiveAveragePooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_VolumetricAdaptiveMaxPooling_updateOutput : Pointer to function : state input output indices osizeT osizeW osizeH -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricAdaptiveMaxPooling_updateOutput" + p_VolumetricAdaptiveMaxPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricAdaptiveMaxPooling_updateGradInput : Pointer to function : state input gradOutput gradInput indices -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricAdaptiveMaxPooling_updateGradInput" + p_VolumetricAdaptiveMaxPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIndexTensor -> IO ()) + +-- | p_SpatialReflectionPadding_updateOutput : Pointer to function : state input output pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h &THNN_FloatSpatialReflectionPadding_updateOutput" + p_SpatialReflectionPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialReflectionPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h &THNN_FloatSpatialReflectionPadding_updateGradInput" + p_SpatialReflectionPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialReplicationPadding_updateOutput : Pointer to function : state input output pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h &THNN_FloatSpatialReplicationPadding_updateOutput" + p_SpatialReplicationPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_SpatialReplicationPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom -> void +foreign import ccall "THNN.h &THNN_FloatSpatialReplicationPadding_updateGradInput" + p_SpatialReplicationPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_FeatureLPPooling_updateOutput : Pointer to function : state input output power width stride batchMode -> void +foreign import ccall "THNN.h &THNN_FloatFeatureLPPooling_updateOutput" + p_FeatureLPPooling_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CInt -> CInt -> CBool -> IO ()) + +-- | p_FeatureLPPooling_updateGradInput : Pointer to function : state gradOutput input output gradInput power width stride batchMode -> void +foreign import ccall "THNN.h &THNN_FloatFeatureLPPooling_updateGradInput" + p_FeatureLPPooling_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CDouble -> CInt -> CInt -> CBool -> IO ()) + +-- | p_VolumetricReplicationPadding_updateOutput : Pointer to function : state input output pad_left pad_right pad_top pad_bottom pad_front pad_back -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricReplicationPadding_updateOutput" + p_VolumetricReplicationPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricReplicationPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right pad_top pad_bottom pad_front pad_back -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricReplicationPadding_updateGradInput" + p_VolumetricReplicationPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricUpSamplingNearest_updateOutput : Pointer to function : state input output scale_factor -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricUpSamplingNearest_updateOutput" + p_VolumetricUpSamplingNearest_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_VolumetricUpSamplingNearest_updateGradInput : Pointer to function : state input gradOutput gradInput scale_factor -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricUpSamplingNearest_updateGradInput" + p_VolumetricUpSamplingNearest_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_VolumetricUpSamplingTrilinear_updateOutput : Pointer to function : state input output osizeT osizeH osizeW -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricUpSamplingTrilinear_updateOutput" + p_VolumetricUpSamplingTrilinear_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_VolumetricUpSamplingTrilinear_updateGradInput : Pointer to function : state gradOutput gradInput isizeB isizeC isizeT isizeH isizeW osizeT osizeH osizeW -> void +foreign import ccall "THNN.h &THNN_FloatVolumetricUpSamplingTrilinear_updateGradInput" + p_VolumetricUpSamplingTrilinear_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()) + +-- | p_TemporalReflectionPadding_updateOutput : Pointer to function : state input output pad_left pad_right -> void +foreign import ccall "THNN.h &THNN_FloatTemporalReflectionPadding_updateOutput" + p_TemporalReflectionPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalReflectionPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right -> void +foreign import ccall "THNN.h &THNN_FloatTemporalReflectionPadding_updateGradInput" + p_TemporalReflectionPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalReplicationPadding_updateOutput : Pointer to function : state input output pad_left pad_right -> void +foreign import ccall "THNN.h &THNN_FloatTemporalReplicationPadding_updateOutput" + p_TemporalReplicationPadding_updateOutput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_TemporalReplicationPadding_updateGradInput : Pointer to function : state input gradOutput gradInput pad_left pad_right -> void +foreign import ccall "THNN.h &THNN_FloatTemporalReplicationPadding_updateGradInput" + p_TemporalReplicationPadding_updateGradInput :: FunPtr (Ptr C'THNNState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) diff --git a/polyfill/Torch/FFI/TH/Byte/FreeStorage.hs b/polyfill/Torch/FFI/TH/Byte/FreeStorage.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Byte/FreeStorage.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.FreeStorage where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_ByteStorage" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THByteStorage -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Byte/FreeTensor.hs b/polyfill/Torch/FFI/TH/Byte/FreeTensor.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Byte/FreeTensor.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.FreeTensor where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_ByteTensor" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THByteTensor -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Char/FreeStorage.hs b/polyfill/Torch/FFI/TH/Char/FreeStorage.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Char/FreeStorage.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.FreeStorage where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_CharStorage" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THCharStorage -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Char/FreeTensor.hs b/polyfill/Torch/FFI/TH/Char/FreeTensor.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Char/FreeTensor.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.FreeTensor where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_CharTensor" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THCharTensor -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Double/FreeStorage.hs b/polyfill/Torch/FFI/TH/Double/FreeStorage.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Double/FreeStorage.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.FreeStorage where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_DoubleStorage" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THDoubleStorage -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Double/FreeTensor.hs b/polyfill/Torch/FFI/TH/Double/FreeTensor.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Double/FreeTensor.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.FreeTensor where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_DoubleTensor" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THDoubleTensor -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Float/FreeStorage.hs b/polyfill/Torch/FFI/TH/Float/FreeStorage.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Float/FreeStorage.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.FreeStorage where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_FloatStorage" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THFloatStorage -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Float/FreeTensor.hs b/polyfill/Torch/FFI/TH/Float/FreeTensor.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Float/FreeTensor.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.FreeTensor where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_FloatTensor" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THFloatTensor -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Int/FreeStorage.hs b/polyfill/Torch/FFI/TH/Int/FreeStorage.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Int/FreeStorage.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.FreeStorage where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_IntStorage" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THIntStorage -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Int/FreeTensor.hs b/polyfill/Torch/FFI/TH/Int/FreeTensor.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Int/FreeTensor.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.FreeTensor where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_IntTensor" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THIntTensor -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Long/FreeStorage.hs b/polyfill/Torch/FFI/TH/Long/FreeStorage.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Long/FreeStorage.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.FreeStorage where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_LongStorage" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THLongStorage -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Long/FreeTensor.hs b/polyfill/Torch/FFI/TH/Long/FreeTensor.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Long/FreeTensor.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.FreeTensor where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_LongTensor" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THLongTensor -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Short/FreeStorage.hs b/polyfill/Torch/FFI/TH/Short/FreeStorage.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Short/FreeStorage.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.FreeStorage where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_ShortStorage" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THShortStorage -> IO ()) + diff --git a/polyfill/Torch/FFI/TH/Short/FreeTensor.hs b/polyfill/Torch/FFI/TH/Short/FreeTensor.hs new file mode 100644 --- /dev/null +++ b/polyfill/Torch/FFI/TH/Short/FreeTensor.hs @@ -0,0 +1,10 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.FreeTensor where + +import Foreign +import Data.Word +import Torch.Types.TH + +foreign import ccall "&free_ShortTensor" + p_free :: FunPtr (Ptr C'THState -> Ptr C'THShortTensor -> IO ()) + diff --git a/src/Torch/FFI/TH/Byte/Blas.hs b/src/Torch/FFI/TH/Byte/Blas.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Byte/Blas.hs @@ -0,0 +1,104 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.Blas where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_swap : n x incx y incy -> void +foreign import ccall "THBlas.h THByteBlas_swap" + c_swap_ :: CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO () +c_swap = const c_swap_ + +-- | c_scal : n a x incx -> void +foreign import ccall "THBlas.h THByteBlas_scal" + c_scal_ :: CLLong -> CUChar -> Ptr CUChar -> CLLong -> IO () + +-- | alias of c_scal_ with unused argument (for CTHState) to unify backpack signatures. +c_scal :: Ptr C'THState -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> IO () +c_scal = const c_scal_ + +-- | c_copy : n x incx y incy -> void +foreign import ccall "THBlas.h THByteBlas_copy" + c_copy_ :: CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO () +c_copy = const c_copy_ + +-- | c_axpy : n a x incx y incy -> void +foreign import ccall "THBlas.h THByteBlas_axpy" + c_axpy_ :: CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO () + +-- | alias of c_axpy_ with unused argument (for CTHState) to unify backpack signatures. +c_axpy :: Ptr C'THState -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO () +c_axpy = const c_axpy_ + +-- | c_dot : n x incx y incy -> real +foreign import ccall "THBlas.h THByteBlas_dot" + c_dot_ :: CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO CUChar + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO CUChar +c_dot = const c_dot_ + +-- | c_gemv : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h THByteBlas_gemv" + c_gemv_ :: CChar -> CLLong -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> IO () + +-- | alias of c_gemv_ with unused argument (for CTHState) to unify backpack signatures. +c_gemv :: Ptr C'THState -> CChar -> CLLong -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> IO () +c_gemv = const c_gemv_ + +-- | c_ger : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h THByteBlas_ger" + c_ger_ :: CLLong -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO () + +-- | alias of c_ger_ with unused argument (for CTHState) to unify backpack signatures. +c_ger :: Ptr C'THState -> CLLong -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO () +c_ger = const c_ger_ + +-- | c_gemm : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h THByteBlas_gemm" + c_gemm_ :: CChar -> CChar -> CLLong -> CLLong -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> IO () + +-- | alias of c_gemm_ with unused argument (for CTHState) to unify backpack signatures. +c_gemm :: Ptr C'THState -> CChar -> CChar -> CLLong -> CLLong -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> IO () +c_gemm = const c_gemm_ + +-- | p_swap : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THByteBlas_swap" + p_swap :: FunPtr (CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO ()) + +-- | p_scal : Pointer to function : n a x incx -> void +foreign import ccall "THBlas.h &THByteBlas_scal" + p_scal :: FunPtr (CLLong -> CUChar -> Ptr CUChar -> CLLong -> IO ()) + +-- | p_copy : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THByteBlas_copy" + p_copy :: FunPtr (CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO ()) + +-- | p_axpy : Pointer to function : n a x incx y incy -> void +foreign import ccall "THBlas.h &THByteBlas_axpy" + p_axpy :: FunPtr (CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO ()) + +-- | p_dot : Pointer to function : n x incx y incy -> real +foreign import ccall "THBlas.h &THByteBlas_dot" + p_dot :: FunPtr (CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO CUChar) + +-- | p_gemv : Pointer to function : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h &THByteBlas_gemv" + p_gemv :: FunPtr (CChar -> CLLong -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> IO ()) + +-- | p_ger : Pointer to function : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h &THByteBlas_ger" + p_ger :: FunPtr (CLLong -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> IO ()) + +-- | p_gemm : Pointer to function : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h &THByteBlas_gemm" + p_gemm :: FunPtr (CChar -> CChar -> CLLong -> CLLong -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> Ptr CUChar -> CLLong -> CUChar -> Ptr CUChar -> CLLong -> IO ()) diff --git a/src/Torch/FFI/TH/Byte/Storage.hs b/src/Torch/FFI/TH/Byte/Storage.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Byte/Storage.hs @@ -0,0 +1,260 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.Storage where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_data : -> real * +foreign import ccall "THStorage.h THByteStorage_data" + c_data_ :: Ptr C'THByteStorage -> IO (Ptr CUChar) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THByteStorage -> IO (Ptr CUChar) +c_data = const c_data_ + +-- | c_size : -> ptrdiff_t +foreign import ccall "THStorage.h THByteStorage_size" + c_size_ :: Ptr C'THByteStorage -> IO CPtrdiff + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THByteStorage -> IO CPtrdiff +c_size = const c_size_ + +-- | c_set : -> void +foreign import ccall "THStorage.h THByteStorage_set" + c_set_ :: Ptr C'THByteStorage -> CPtrdiff -> CUChar -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THByteStorage -> CPtrdiff -> CUChar -> IO () +c_set = const c_set_ + +-- | c_get : -> real +foreign import ccall "THStorage.h THByteStorage_get" + c_get_ :: Ptr C'THByteStorage -> CPtrdiff -> IO CUChar + +-- | alias of c_get_ with unused argument (for CTHState) to unify backpack signatures. +c_get :: Ptr C'THState -> Ptr C'THByteStorage -> CPtrdiff -> IO CUChar +c_get = const c_get_ + +-- | c_new : -> THStorage * +foreign import ccall "THStorage.h THByteStorage_new" + c_new_ :: IO (Ptr C'THByteStorage) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THByteStorage) +c_new = const c_new_ + +-- | c_newWithSize : size -> THStorage * +foreign import ccall "THStorage.h THByteStorage_newWithSize" + c_newWithSize_ :: CPtrdiff -> IO (Ptr C'THByteStorage) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> CPtrdiff -> IO (Ptr C'THByteStorage) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1 : -> THStorage * +foreign import ccall "THStorage.h THByteStorage_newWithSize1" + c_newWithSize1_ :: CUChar -> IO (Ptr C'THByteStorage) + +-- | alias of c_newWithSize1_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1 :: Ptr C'THState -> CUChar -> IO (Ptr C'THByteStorage) +c_newWithSize1 = const c_newWithSize1_ + +-- | c_newWithSize2 : -> THStorage * +foreign import ccall "THStorage.h THByteStorage_newWithSize2" + c_newWithSize2_ :: CUChar -> CUChar -> IO (Ptr C'THByteStorage) + +-- | alias of c_newWithSize2_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2 :: Ptr C'THState -> CUChar -> CUChar -> IO (Ptr C'THByteStorage) +c_newWithSize2 = const c_newWithSize2_ + +-- | c_newWithSize3 : -> THStorage * +foreign import ccall "THStorage.h THByteStorage_newWithSize3" + c_newWithSize3_ :: CUChar -> CUChar -> CUChar -> IO (Ptr C'THByteStorage) + +-- | alias of c_newWithSize3_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3 :: Ptr C'THState -> CUChar -> CUChar -> CUChar -> IO (Ptr C'THByteStorage) +c_newWithSize3 = const c_newWithSize3_ + +-- | c_newWithSize4 : -> THStorage * +foreign import ccall "THStorage.h THByteStorage_newWithSize4" + c_newWithSize4_ :: CUChar -> CUChar -> CUChar -> CUChar -> IO (Ptr C'THByteStorage) + +-- | alias of c_newWithSize4_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4 :: Ptr C'THState -> CUChar -> CUChar -> CUChar -> CUChar -> IO (Ptr C'THByteStorage) +c_newWithSize4 = const c_newWithSize4_ + +-- | c_newWithMapping : filename size flags -> THStorage * +foreign import ccall "THStorage.h THByteStorage_newWithMapping" + c_newWithMapping_ :: Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THByteStorage) + +-- | alias of c_newWithMapping_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithMapping :: Ptr C'THState -> Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THByteStorage) +c_newWithMapping = const c_newWithMapping_ + +-- | c_newWithData : data size -> THStorage * +foreign import ccall "THStorage.h THByteStorage_newWithData" + c_newWithData_ :: Ptr CUChar -> CPtrdiff -> IO (Ptr C'THByteStorage) + +-- | alias of c_newWithData_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithData :: Ptr C'THState -> Ptr CUChar -> CPtrdiff -> IO (Ptr C'THByteStorage) +c_newWithData = const c_newWithData_ + +-- | c_newWithAllocator : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THByteStorage_newWithAllocator" + c_newWithAllocator_ :: CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THByteStorage) + +-- | alias of c_newWithAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithAllocator :: Ptr C'THState -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THByteStorage) +c_newWithAllocator = const c_newWithAllocator_ + +-- | c_newWithDataAndAllocator : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THByteStorage_newWithDataAndAllocator" + c_newWithDataAndAllocator_ :: Ptr CUChar -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THByteStorage) + +-- | alias of c_newWithDataAndAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithDataAndAllocator :: Ptr C'THState -> Ptr CUChar -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THByteStorage) +c_newWithDataAndAllocator = const c_newWithDataAndAllocator_ + +-- | c_setFlag : storage flag -> void +foreign import ccall "THStorage.h THByteStorage_setFlag" + c_setFlag_ :: Ptr C'THByteStorage -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THByteStorage -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : storage flag -> void +foreign import ccall "THStorage.h THByteStorage_clearFlag" + c_clearFlag_ :: Ptr C'THByteStorage -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THByteStorage -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_retain : storage -> void +foreign import ccall "THStorage.h THByteStorage_retain" + c_retain_ :: Ptr C'THByteStorage -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THByteStorage -> IO () +c_retain = const c_retain_ + +-- | c_swap : storage1 storage2 -> void +foreign import ccall "THStorage.h THByteStorage_swap" + c_swap_ :: Ptr C'THByteStorage -> Ptr C'THByteStorage -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THByteStorage -> IO () +c_swap = const c_swap_ + +-- | c_free : storage -> void +foreign import ccall "THStorage.h THByteStorage_free" + c_free_ :: Ptr C'THByteStorage -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THByteStorage -> IO () +c_free = const c_free_ + +-- | c_resize : storage size -> void +foreign import ccall "THStorage.h THByteStorage_resize" + c_resize_ :: Ptr C'THByteStorage -> CPtrdiff -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THByteStorage -> CPtrdiff -> IO () +c_resize = const c_resize_ + +-- | c_fill : storage value -> void +foreign import ccall "THStorage.h THByteStorage_fill" + c_fill_ :: Ptr C'THByteStorage -> CUChar -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THByteStorage -> CUChar -> IO () +c_fill = const c_fill_ + +-- | p_data : Pointer to function : -> real * +foreign import ccall "THStorage.h &THByteStorage_data" + p_data :: FunPtr (Ptr C'THByteStorage -> IO (Ptr CUChar)) + +-- | p_size : Pointer to function : -> ptrdiff_t +foreign import ccall "THStorage.h &THByteStorage_size" + p_size :: FunPtr (Ptr C'THByteStorage -> IO CPtrdiff) + +-- | p_set : Pointer to function : -> void +foreign import ccall "THStorage.h &THByteStorage_set" + p_set :: FunPtr (Ptr C'THByteStorage -> CPtrdiff -> CUChar -> IO ()) + +-- | p_get : Pointer to function : -> real +foreign import ccall "THStorage.h &THByteStorage_get" + p_get :: FunPtr (Ptr C'THByteStorage -> CPtrdiff -> IO CUChar) + +-- | p_new : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_new" + p_new :: FunPtr (IO (Ptr C'THByteStorage)) + +-- | p_newWithSize : Pointer to function : size -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_newWithSize" + p_newWithSize :: FunPtr (CPtrdiff -> IO (Ptr C'THByteStorage)) + +-- | p_newWithSize1 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_newWithSize1" + p_newWithSize1 :: FunPtr (CUChar -> IO (Ptr C'THByteStorage)) + +-- | p_newWithSize2 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_newWithSize2" + p_newWithSize2 :: FunPtr (CUChar -> CUChar -> IO (Ptr C'THByteStorage)) + +-- | p_newWithSize3 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_newWithSize3" + p_newWithSize3 :: FunPtr (CUChar -> CUChar -> CUChar -> IO (Ptr C'THByteStorage)) + +-- | p_newWithSize4 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_newWithSize4" + p_newWithSize4 :: FunPtr (CUChar -> CUChar -> CUChar -> CUChar -> IO (Ptr C'THByteStorage)) + +-- | p_newWithMapping : Pointer to function : filename size flags -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_newWithMapping" + p_newWithMapping :: FunPtr (Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THByteStorage)) + +-- | p_newWithData : Pointer to function : data size -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_newWithData" + p_newWithData :: FunPtr (Ptr CUChar -> CPtrdiff -> IO (Ptr C'THByteStorage)) + +-- | p_newWithAllocator : Pointer to function : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_newWithAllocator" + p_newWithAllocator :: FunPtr (CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THByteStorage)) + +-- | p_newWithDataAndAllocator : Pointer to function : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THByteStorage_newWithDataAndAllocator" + p_newWithDataAndAllocator :: FunPtr (Ptr CUChar -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THByteStorage)) + +-- | p_setFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THByteStorage_setFlag" + p_setFlag :: FunPtr (Ptr C'THByteStorage -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THByteStorage_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THByteStorage -> CChar -> IO ()) + +-- | p_retain : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THByteStorage_retain" + p_retain :: FunPtr (Ptr C'THByteStorage -> IO ()) + +-- | p_swap : Pointer to function : storage1 storage2 -> void +foreign import ccall "THStorage.h &THByteStorage_swap" + p_swap :: FunPtr (Ptr C'THByteStorage -> Ptr C'THByteStorage -> IO ()) + +-- | p_free : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THByteStorage_free" + p_free :: FunPtr (Ptr C'THByteStorage -> IO ()) + +-- | p_resize : Pointer to function : storage size -> void +foreign import ccall "THStorage.h &THByteStorage_resize" + p_resize :: FunPtr (Ptr C'THByteStorage -> CPtrdiff -> IO ()) + +-- | p_fill : Pointer to function : storage value -> void +foreign import ccall "THStorage.h &THByteStorage_fill" + p_fill :: FunPtr (Ptr C'THByteStorage -> CUChar -> IO ()) diff --git a/src/Torch/FFI/TH/Byte/StorageCopy.hs b/src/Torch/FFI/TH/Byte/StorageCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Byte/StorageCopy.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.StorageCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_rawCopy : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_rawCopy" + c_rawCopy_ :: Ptr C'THByteStorage -> Ptr CUChar -> IO () + +-- | alias of c_rawCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_rawCopy :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr CUChar -> IO () +c_rawCopy = const c_rawCopy_ + +-- | c_copy : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_copy" + c_copy_ :: Ptr C'THByteStorage -> Ptr C'THByteStorage -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THByteStorage -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_copyByte" + c_copyByte_ :: Ptr C'THByteStorage -> Ptr C'THByteStorage -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THByteStorage -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_copyChar" + c_copyChar_ :: Ptr C'THByteStorage -> Ptr C'THCharStorage -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THCharStorage -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_copyShort" + c_copyShort_ :: Ptr C'THByteStorage -> Ptr C'THShortStorage -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THShortStorage -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_copyInt" + c_copyInt_ :: Ptr C'THByteStorage -> Ptr C'THIntStorage -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THIntStorage -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_copyLong" + c_copyLong_ :: Ptr C'THByteStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THLongStorage -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_copyFloat" + c_copyFloat_ :: Ptr C'THByteStorage -> Ptr C'THFloatStorage -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THFloatStorage -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_copyDouble" + c_copyDouble_ :: Ptr C'THByteStorage -> Ptr C'THDoubleStorage -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THDoubleStorage -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : storage src -> void +foreign import ccall "THStorageCopy.h THByteStorage_copyHalf" + c_copyHalf_ :: Ptr C'THByteStorage -> Ptr C'THHalfStorage -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THByteStorage -> Ptr C'THHalfStorage -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_rawCopy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_rawCopy" + p_rawCopy :: FunPtr (Ptr C'THByteStorage -> Ptr CUChar -> IO ()) + +-- | p_copy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_copy" + p_copy :: FunPtr (Ptr C'THByteStorage -> Ptr C'THByteStorage -> IO ()) + +-- | p_copyByte : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_copyByte" + p_copyByte :: FunPtr (Ptr C'THByteStorage -> Ptr C'THByteStorage -> IO ()) + +-- | p_copyChar : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_copyChar" + p_copyChar :: FunPtr (Ptr C'THByteStorage -> Ptr C'THCharStorage -> IO ()) + +-- | p_copyShort : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_copyShort" + p_copyShort :: FunPtr (Ptr C'THByteStorage -> Ptr C'THShortStorage -> IO ()) + +-- | p_copyInt : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_copyInt" + p_copyInt :: FunPtr (Ptr C'THByteStorage -> Ptr C'THIntStorage -> IO ()) + +-- | p_copyLong : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_copyLong" + p_copyLong :: FunPtr (Ptr C'THByteStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_copyFloat : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THByteStorage -> Ptr C'THFloatStorage -> IO ()) + +-- | p_copyDouble : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THByteStorage -> Ptr C'THDoubleStorage -> IO ()) + +-- | p_copyHalf : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THByteStorage_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THByteStorage -> Ptr C'THHalfStorage -> IO ()) diff --git a/src/Torch/FFI/TH/Byte/Tensor.hs b/src/Torch/FFI/TH/Byte/Tensor.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Byte/Tensor.hs @@ -0,0 +1,872 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.Tensor where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_storage : self -> THStorage * +foreign import ccall "THTensor.h THByteTensor_storage" + c_storage_ :: Ptr C'THByteTensor -> IO (Ptr C'THByteStorage) + +-- | alias of c_storage_ with unused argument (for CTHState) to unify backpack signatures. +c_storage :: Ptr C'THState -> Ptr C'THByteTensor -> IO (Ptr C'THByteStorage) +c_storage = const c_storage_ + +-- | c_storageOffset : self -> ptrdiff_t +foreign import ccall "THTensor.h THByteTensor_storageOffset" + c_storageOffset_ :: Ptr C'THByteTensor -> IO CPtrdiff + +-- | alias of c_storageOffset_ with unused argument (for CTHState) to unify backpack signatures. +c_storageOffset :: Ptr C'THState -> Ptr C'THByteTensor -> IO CPtrdiff +c_storageOffset = const c_storageOffset_ + +-- | c_nDimension : self -> int +foreign import ccall "THTensor.h THByteTensor_nDimension" + c_nDimension_ :: Ptr C'THByteTensor -> IO CInt + +-- | alias of c_nDimension_ with unused argument (for CTHState) to unify backpack signatures. +c_nDimension :: Ptr C'THState -> Ptr C'THByteTensor -> IO CInt +c_nDimension = const c_nDimension_ + +-- | c_size : self dim -> int64_t +foreign import ccall "THTensor.h THByteTensor_size" + c_size_ :: Ptr C'THByteTensor -> CInt -> IO CLLong + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> IO CLLong +c_size = const c_size_ + +-- | c_stride : self dim -> int64_t +foreign import ccall "THTensor.h THByteTensor_stride" + c_stride_ :: Ptr C'THByteTensor -> CInt -> IO CLLong + +-- | alias of c_stride_ with unused argument (for CTHState) to unify backpack signatures. +c_stride :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> IO CLLong +c_stride = const c_stride_ + +-- | c_newSizeOf : self -> THLongStorage * +foreign import ccall "THTensor.h THByteTensor_newSizeOf" + c_newSizeOf_ :: Ptr C'THByteTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newSizeOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newSizeOf :: Ptr C'THState -> Ptr C'THByteTensor -> IO (Ptr C'THLongStorage) +c_newSizeOf = const c_newSizeOf_ + +-- | c_newStrideOf : self -> THLongStorage * +foreign import ccall "THTensor.h THByteTensor_newStrideOf" + c_newStrideOf_ :: Ptr C'THByteTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newStrideOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newStrideOf :: Ptr C'THState -> Ptr C'THByteTensor -> IO (Ptr C'THLongStorage) +c_newStrideOf = const c_newStrideOf_ + +-- | c_data : self -> real * +foreign import ccall "THTensor.h THByteTensor_data" + c_data_ :: Ptr C'THByteTensor -> IO (Ptr CUChar) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THByteTensor -> IO (Ptr CUChar) +c_data = const c_data_ + +-- | c_setFlag : self flag -> void +foreign import ccall "THTensor.h THByteTensor_setFlag" + c_setFlag_ :: Ptr C'THByteTensor -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THByteTensor -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : self flag -> void +foreign import ccall "THTensor.h THByteTensor_clearFlag" + c_clearFlag_ :: Ptr C'THByteTensor -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THByteTensor -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_new : -> THTensor * +foreign import ccall "THTensor.h THByteTensor_new" + c_new_ :: IO (Ptr C'THByteTensor) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THByteTensor) +c_new = const c_new_ + +-- | c_newWithTensor : tensor -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithTensor" + c_newWithTensor_ :: Ptr C'THByteTensor -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithTensor :: Ptr C'THState -> Ptr C'THByteTensor -> IO (Ptr C'THByteTensor) +c_newWithTensor = const c_newWithTensor_ + +-- | c_newWithStorage : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithStorage" + c_newWithStorage_ :: Ptr C'THByteStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage :: Ptr C'THState -> Ptr C'THByteStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor) +c_newWithStorage = const c_newWithStorage_ + +-- | c_newWithStorage1d : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithStorage1d" + c_newWithStorage1d_ :: Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage1d :: Ptr C'THState -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) +c_newWithStorage1d = const c_newWithStorage1d_ + +-- | c_newWithStorage2d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithStorage2d" + c_newWithStorage2d_ :: Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage2d :: Ptr C'THState -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) +c_newWithStorage2d = const c_newWithStorage2d_ + +-- | c_newWithStorage3d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithStorage3d" + c_newWithStorage3d_ :: Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage3d :: Ptr C'THState -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) +c_newWithStorage3d = const c_newWithStorage3d_ + +-- | c_newWithStorage4d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithStorage4d" + c_newWithStorage4d_ :: Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage4d :: Ptr C'THState -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) +c_newWithStorage4d = const c_newWithStorage4d_ + +-- | c_newWithSize : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithSize" + c_newWithSize_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1d : size0_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithSize1d" + c_newWithSize1d_ :: CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithSize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1d :: Ptr C'THState -> CLLong -> IO (Ptr C'THByteTensor) +c_newWithSize1d = const c_newWithSize1d_ + +-- | c_newWithSize2d : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithSize2d" + c_newWithSize2d_ :: CLLong -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithSize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2d :: Ptr C'THState -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) +c_newWithSize2d = const c_newWithSize2d_ + +-- | c_newWithSize3d : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithSize3d" + c_newWithSize3d_ :: CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithSize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) +c_newWithSize3d = const c_newWithSize3d_ + +-- | c_newWithSize4d : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newWithSize4d" + c_newWithSize4d_ :: CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newWithSize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) +c_newWithSize4d = const c_newWithSize4d_ + +-- | c_newClone : self -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newClone" + c_newClone_ :: Ptr C'THByteTensor -> IO (Ptr C'THByteTensor) + +-- | alias of c_newClone_ with unused argument (for CTHState) to unify backpack signatures. +c_newClone :: Ptr C'THState -> Ptr C'THByteTensor -> IO (Ptr C'THByteTensor) +c_newClone = const c_newClone_ + +-- | c_newContiguous : tensor -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newContiguous" + c_newContiguous_ :: Ptr C'THByteTensor -> IO (Ptr C'THByteTensor) + +-- | alias of c_newContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_newContiguous :: Ptr C'THState -> Ptr C'THByteTensor -> IO (Ptr C'THByteTensor) +c_newContiguous = const c_newContiguous_ + +-- | c_newSelect : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newSelect" + c_newSelect_ :: Ptr C'THByteTensor -> CInt -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_newSelect :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> CLLong -> IO (Ptr C'THByteTensor) +c_newSelect = const c_newSelect_ + +-- | c_newNarrow : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newNarrow" + c_newNarrow_ :: Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newNarrow_ with unused argument (for CTHState) to unify backpack signatures. +c_newNarrow :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) +c_newNarrow = const c_newNarrow_ + +-- | c_newTranspose : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newTranspose" + c_newTranspose_ :: Ptr C'THByteTensor -> CInt -> CInt -> IO (Ptr C'THByteTensor) + +-- | alias of c_newTranspose_ with unused argument (for CTHState) to unify backpack signatures. +c_newTranspose :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> CInt -> IO (Ptr C'THByteTensor) +c_newTranspose = const c_newTranspose_ + +-- | c_newUnfold : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newUnfold" + c_newUnfold_ :: Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) + +-- | alias of c_newUnfold_ with unused argument (for CTHState) to unify backpack signatures. +c_newUnfold :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THByteTensor) +c_newUnfold = const c_newUnfold_ + +-- | c_newView : tensor size -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newView" + c_newView_ :: Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor) + +-- | alias of c_newView_ with unused argument (for CTHState) to unify backpack signatures. +c_newView :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor) +c_newView = const c_newView_ + +-- | c_newExpand : tensor size -> THTensor * +foreign import ccall "THTensor.h THByteTensor_newExpand" + c_newExpand_ :: Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor) + +-- | alias of c_newExpand_ with unused argument (for CTHState) to unify backpack signatures. +c_newExpand :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor) +c_newExpand = const c_newExpand_ + +-- | c_expand : r tensor size -> void +foreign import ccall "THTensor.h THByteTensor_expand" + c_expand_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_expand_ with unused argument (for CTHState) to unify backpack signatures. +c_expand :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO () +c_expand = const c_expand_ + +-- | c_expandNd : rets ops count -> void +foreign import ccall "THTensor.h THByteTensor_expandNd" + c_expandNd_ :: Ptr (Ptr C'THByteTensor) -> Ptr (Ptr C'THByteTensor) -> CInt -> IO () + +-- | alias of c_expandNd_ with unused argument (for CTHState) to unify backpack signatures. +c_expandNd :: Ptr C'THState -> Ptr (Ptr C'THByteTensor) -> Ptr (Ptr C'THByteTensor) -> CInt -> IO () +c_expandNd = const c_expandNd_ + +-- | c_resize : tensor size stride -> void +foreign import ccall "THTensor.h THByteTensor_resize" + c_resize_ :: Ptr C'THByteTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_resize = const c_resize_ + +-- | c_resizeAs : tensor src -> void +foreign import ccall "THTensor.h THByteTensor_resizeAs" + c_resizeAs_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_resizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeAs :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_resizeAs = const c_resizeAs_ + +-- | c_resizeNd : tensor nDimension size stride -> void +foreign import ccall "THTensor.h THByteTensor_resizeNd" + c_resizeNd_ :: Ptr C'THByteTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_resizeNd_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeNd :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_resizeNd = const c_resizeNd_ + +-- | c_resize1d : tensor size0_ -> void +foreign import ccall "THTensor.h THByteTensor_resize1d" + c_resize1d_ :: Ptr C'THByteTensor -> CLLong -> IO () + +-- | alias of c_resize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize1d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> IO () +c_resize1d = const c_resize1d_ + +-- | c_resize2d : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h THByteTensor_resize2d" + c_resize2d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_resize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize2d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> IO () +c_resize2d = const c_resize2d_ + +-- | c_resize3d : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h THByteTensor_resize3d" + c_resize3d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize3d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> IO () +c_resize3d = const c_resize3d_ + +-- | c_resize4d : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h THByteTensor_resize4d" + c_resize4d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize4d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize4d = const c_resize4d_ + +-- | c_resize5d : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h THByteTensor_resize5d" + c_resize5d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize5d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize5d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize5d = const c_resize5d_ + +-- | c_set : self src -> void +foreign import ccall "THTensor.h THByteTensor_set" + c_set_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_set = const c_set_ + +-- | c_setStorage : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h THByteTensor_setStorage" + c_setStorage_ :: Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_setStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_setStorage = const c_setStorage_ + +-- | c_setStorageNd : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h THByteTensor_setStorageNd" + c_setStorageNd_ :: Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_setStorageNd_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorageNd :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_setStorageNd = const c_setStorageNd_ + +-- | c_setStorage1d : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h THByteTensor_setStorage1d" + c_setStorage1d_ :: Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage1d :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> IO () +c_setStorage1d = const c_setStorage1d_ + +-- | c_setStorage2d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h THByteTensor_setStorage2d" + c_setStorage2d_ :: Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage2d :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage2d = const c_setStorage2d_ + +-- | c_setStorage3d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h THByteTensor_setStorage3d" + c_setStorage3d_ :: Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage3d :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage3d = const c_setStorage3d_ + +-- | c_setStorage4d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h THByteTensor_setStorage4d" + c_setStorage4d_ :: Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage4d :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage4d = const c_setStorage4d_ + +-- | c_narrow : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h THByteTensor_narrow" + c_narrow_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_narrow_ with unused argument (for CTHState) to unify backpack signatures. +c_narrow :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO () +c_narrow = const c_narrow_ + +-- | c_select : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h THByteTensor_select" + c_select_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CLLong -> IO () + +-- | alias of c_select_ with unused argument (for CTHState) to unify backpack signatures. +c_select :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CLLong -> IO () +c_select = const c_select_ + +-- | c_transpose : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h THByteTensor_transpose" + c_transpose_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () + +-- | alias of c_transpose_ with unused argument (for CTHState) to unify backpack signatures. +c_transpose :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () +c_transpose = const c_transpose_ + +-- | c_unfold : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h THByteTensor_unfold" + c_unfold_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_unfold_ with unused argument (for CTHState) to unify backpack signatures. +c_unfold :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO () +c_unfold = const c_unfold_ + +-- | c_squeeze : self src -> void +foreign import ccall "THTensor.h THByteTensor_squeeze" + c_squeeze_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_squeeze_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_squeeze = const c_squeeze_ + +-- | c_squeeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THByteTensor_squeeze1d" + c_squeeze1d_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () + +-- | alias of c_squeeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze1d :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () +c_squeeze1d = const c_squeeze1d_ + +-- | c_unsqueeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THByteTensor_unsqueeze1d" + c_unsqueeze1d_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () + +-- | alias of c_unsqueeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_unsqueeze1d :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () +c_unsqueeze1d = const c_unsqueeze1d_ + +-- | c_isContiguous : self -> int +foreign import ccall "THTensor.h THByteTensor_isContiguous" + c_isContiguous_ :: Ptr C'THByteTensor -> IO CInt + +-- | alias of c_isContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_isContiguous :: Ptr C'THState -> Ptr C'THByteTensor -> IO CInt +c_isContiguous = const c_isContiguous_ + +-- | c_isSameSizeAs : self src -> int +foreign import ccall "THTensor.h THByteTensor_isSameSizeAs" + c_isSameSizeAs_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CInt + +-- | alias of c_isSameSizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_isSameSizeAs :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CInt +c_isSameSizeAs = const c_isSameSizeAs_ + +-- | c_isSetTo : self src -> int +foreign import ccall "THTensor.h THByteTensor_isSetTo" + c_isSetTo_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CInt + +-- | alias of c_isSetTo_ with unused argument (for CTHState) to unify backpack signatures. +c_isSetTo :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CInt +c_isSetTo = const c_isSetTo_ + +-- | c_isSize : self dims -> int +foreign import ccall "THTensor.h THByteTensor_isSize" + c_isSize_ :: Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO CInt + +-- | alias of c_isSize_ with unused argument (for CTHState) to unify backpack signatures. +c_isSize :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO CInt +c_isSize = const c_isSize_ + +-- | c_nElement : self -> ptrdiff_t +foreign import ccall "THTensor.h THByteTensor_nElement" + c_nElement_ :: Ptr C'THByteTensor -> IO CPtrdiff + +-- | alias of c_nElement_ with unused argument (for CTHState) to unify backpack signatures. +c_nElement :: Ptr C'THState -> Ptr C'THByteTensor -> IO CPtrdiff +c_nElement = const c_nElement_ + +-- | c_retain : self -> void +foreign import ccall "THTensor.h THByteTensor_retain" + c_retain_ :: Ptr C'THByteTensor -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THByteTensor -> IO () +c_retain = const c_retain_ + +-- | c_free : self -> void +foreign import ccall "THTensor.h THByteTensor_free" + c_free_ :: Ptr C'THByteTensor -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THByteTensor -> IO () +c_free = const c_free_ + +-- | c_freeCopyTo : self dst -> void +foreign import ccall "THTensor.h THByteTensor_freeCopyTo" + c_freeCopyTo_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_freeCopyTo_ with unused argument (for CTHState) to unify backpack signatures. +c_freeCopyTo :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_freeCopyTo = const c_freeCopyTo_ + +-- | c_set1d : tensor x0 value -> void +foreign import ccall "THTensor.h THByteTensor_set1d" + c_set1d_ :: Ptr C'THByteTensor -> CLLong -> CUChar -> IO () + +-- | alias of c_set1d_ with unused argument (for CTHState) to unify backpack signatures. +c_set1d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CUChar -> IO () +c_set1d = const c_set1d_ + +-- | c_set2d : tensor x0 x1 value -> void +foreign import ccall "THTensor.h THByteTensor_set2d" + c_set2d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> CUChar -> IO () + +-- | alias of c_set2d_ with unused argument (for CTHState) to unify backpack signatures. +c_set2d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> CUChar -> IO () +c_set2d = const c_set2d_ + +-- | c_set3d : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h THByteTensor_set3d" + c_set3d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CUChar -> IO () + +-- | alias of c_set3d_ with unused argument (for CTHState) to unify backpack signatures. +c_set3d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CUChar -> IO () +c_set3d = const c_set3d_ + +-- | c_set4d : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h THByteTensor_set4d" + c_set4d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CUChar -> IO () + +-- | alias of c_set4d_ with unused argument (for CTHState) to unify backpack signatures. +c_set4d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CUChar -> IO () +c_set4d = const c_set4d_ + +-- | c_get1d : tensor x0 -> real +foreign import ccall "THTensor.h THByteTensor_get1d" + c_get1d_ :: Ptr C'THByteTensor -> CLLong -> IO CUChar + +-- | alias of c_get1d_ with unused argument (for CTHState) to unify backpack signatures. +c_get1d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> IO CUChar +c_get1d = const c_get1d_ + +-- | c_get2d : tensor x0 x1 -> real +foreign import ccall "THTensor.h THByteTensor_get2d" + c_get2d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> IO CUChar + +-- | alias of c_get2d_ with unused argument (for CTHState) to unify backpack signatures. +c_get2d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> IO CUChar +c_get2d = const c_get2d_ + +-- | c_get3d : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h THByteTensor_get3d" + c_get3d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> IO CUChar + +-- | alias of c_get3d_ with unused argument (for CTHState) to unify backpack signatures. +c_get3d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> IO CUChar +c_get3d = const c_get3d_ + +-- | c_get4d : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h THByteTensor_get4d" + c_get4d_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CUChar + +-- | alias of c_get4d_ with unused argument (for CTHState) to unify backpack signatures. +c_get4d :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CUChar +c_get4d = const c_get4d_ + +-- | c_desc : tensor -> THDescBuff +foreign import ccall "THTensor.h THByteTensor_desc" + c_desc_ :: Ptr C'THByteTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_desc_ with unused argument (for CTHState) to unify backpack signatures. +c_desc :: Ptr C'THState -> Ptr C'THByteTensor -> IO (Ptr C'THDescBuff) +c_desc = const c_desc_ + +-- | c_sizeDesc : tensor -> THDescBuff +foreign import ccall "THTensor.h THByteTensor_sizeDesc" + c_sizeDesc_ :: Ptr C'THByteTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_sizeDesc_ with unused argument (for CTHState) to unify backpack signatures. +c_sizeDesc :: Ptr C'THState -> Ptr C'THByteTensor -> IO (Ptr C'THDescBuff) +c_sizeDesc = const c_sizeDesc_ + +-- | p_storage : Pointer to function : self -> THStorage * +foreign import ccall "THTensor.h &THByteTensor_storage" + p_storage :: FunPtr (Ptr C'THByteTensor -> IO (Ptr C'THByteStorage)) + +-- | p_storageOffset : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THByteTensor_storageOffset" + p_storageOffset :: FunPtr (Ptr C'THByteTensor -> IO CPtrdiff) + +-- | p_nDimension : Pointer to function : self -> int +foreign import ccall "THTensor.h &THByteTensor_nDimension" + p_nDimension :: FunPtr (Ptr C'THByteTensor -> IO CInt) + +-- | p_size : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THByteTensor_size" + p_size :: FunPtr (Ptr C'THByteTensor -> CInt -> IO CLLong) + +-- | p_stride : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THByteTensor_stride" + p_stride :: FunPtr (Ptr C'THByteTensor -> CInt -> IO CLLong) + +-- | p_newSizeOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THByteTensor_newSizeOf" + p_newSizeOf :: FunPtr (Ptr C'THByteTensor -> IO (Ptr C'THLongStorage)) + +-- | p_newStrideOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THByteTensor_newStrideOf" + p_newStrideOf :: FunPtr (Ptr C'THByteTensor -> IO (Ptr C'THLongStorage)) + +-- | p_data : Pointer to function : self -> real * +foreign import ccall "THTensor.h &THByteTensor_data" + p_data :: FunPtr (Ptr C'THByteTensor -> IO (Ptr CUChar)) + +-- | p_setFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THByteTensor_setFlag" + p_setFlag :: FunPtr (Ptr C'THByteTensor -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THByteTensor_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THByteTensor -> CChar -> IO ()) + +-- | p_new : Pointer to function : -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_new" + p_new :: FunPtr (IO (Ptr C'THByteTensor)) + +-- | p_newWithTensor : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithTensor" + p_newWithTensor :: FunPtr (Ptr C'THByteTensor -> IO (Ptr C'THByteTensor)) + +-- | p_newWithStorage : Pointer to function : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithStorage" + p_newWithStorage :: FunPtr (Ptr C'THByteStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor)) + +-- | p_newWithStorage1d : Pointer to function : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithStorage1d" + p_newWithStorage1d :: FunPtr (Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newWithStorage2d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithStorage2d" + p_newWithStorage2d :: FunPtr (Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newWithStorage3d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithStorage3d" + p_newWithStorage3d :: FunPtr (Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newWithStorage4d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithStorage4d" + p_newWithStorage4d :: FunPtr (Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newWithSize : Pointer to function : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithSize" + p_newWithSize :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor)) + +-- | p_newWithSize1d : Pointer to function : size0_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithSize1d" + p_newWithSize1d :: FunPtr (CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newWithSize2d : Pointer to function : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithSize2d" + p_newWithSize2d :: FunPtr (CLLong -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newWithSize3d : Pointer to function : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithSize3d" + p_newWithSize3d :: FunPtr (CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newWithSize4d : Pointer to function : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newWithSize4d" + p_newWithSize4d :: FunPtr (CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newClone : Pointer to function : self -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newClone" + p_newClone :: FunPtr (Ptr C'THByteTensor -> IO (Ptr C'THByteTensor)) + +-- | p_newContiguous : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newContiguous" + p_newContiguous :: FunPtr (Ptr C'THByteTensor -> IO (Ptr C'THByteTensor)) + +-- | p_newSelect : Pointer to function : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newSelect" + p_newSelect :: FunPtr (Ptr C'THByteTensor -> CInt -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newNarrow : Pointer to function : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newNarrow" + p_newNarrow :: FunPtr (Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newTranspose : Pointer to function : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newTranspose" + p_newTranspose :: FunPtr (Ptr C'THByteTensor -> CInt -> CInt -> IO (Ptr C'THByteTensor)) + +-- | p_newUnfold : Pointer to function : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newUnfold" + p_newUnfold :: FunPtr (Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THByteTensor)) + +-- | p_newView : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newView" + p_newView :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor)) + +-- | p_newExpand : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THByteTensor_newExpand" + p_newExpand :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO (Ptr C'THByteTensor)) + +-- | p_expand : Pointer to function : r tensor size -> void +foreign import ccall "THTensor.h &THByteTensor_expand" + p_expand :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_expandNd : Pointer to function : rets ops count -> void +foreign import ccall "THTensor.h &THByteTensor_expandNd" + p_expandNd :: FunPtr (Ptr (Ptr C'THByteTensor) -> Ptr (Ptr C'THByteTensor) -> CInt -> IO ()) + +-- | p_resize : Pointer to function : tensor size stride -> void +foreign import ccall "THTensor.h &THByteTensor_resize" + p_resize :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_resizeAs : Pointer to function : tensor src -> void +foreign import ccall "THTensor.h &THByteTensor_resizeAs" + p_resizeAs :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_resizeNd : Pointer to function : tensor nDimension size stride -> void +foreign import ccall "THTensor.h &THByteTensor_resizeNd" + p_resizeNd :: FunPtr (Ptr C'THByteTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_resize1d : Pointer to function : tensor size0_ -> void +foreign import ccall "THTensor.h &THByteTensor_resize1d" + p_resize1d :: FunPtr (Ptr C'THByteTensor -> CLLong -> IO ()) + +-- | p_resize2d : Pointer to function : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h &THByteTensor_resize2d" + p_resize2d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> IO ()) + +-- | p_resize3d : Pointer to function : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h &THByteTensor_resize3d" + p_resize3d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize4d : Pointer to function : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h &THByteTensor_resize4d" + p_resize4d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize5d : Pointer to function : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h &THByteTensor_resize5d" + p_resize5d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_set : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THByteTensor_set" + p_set :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_setStorage : Pointer to function : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h &THByteTensor_setStorage" + p_setStorage :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_setStorageNd : Pointer to function : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h &THByteTensor_setStorageNd" + p_setStorageNd :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_setStorage1d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h &THByteTensor_setStorage1d" + p_setStorage1d :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage2d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h &THByteTensor_setStorage2d" + p_setStorage2d :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage3d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h &THByteTensor_setStorage3d" + p_setStorage3d :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage4d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h &THByteTensor_setStorage4d" + p_setStorage4d :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_narrow : Pointer to function : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h &THByteTensor_narrow" + p_narrow :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_select : Pointer to function : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h &THByteTensor_select" + p_select :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CLLong -> IO ()) + +-- | p_transpose : Pointer to function : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h &THByteTensor_transpose" + p_transpose :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO ()) + +-- | p_unfold : Pointer to function : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h &THByteTensor_unfold" + p_unfold :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_squeeze : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THByteTensor_squeeze" + p_squeeze :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_squeeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THByteTensor_squeeze1d" + p_squeeze1d :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO ()) + +-- | p_unsqueeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THByteTensor_unsqueeze1d" + p_unsqueeze1d :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO ()) + +-- | p_isContiguous : Pointer to function : self -> int +foreign import ccall "THTensor.h &THByteTensor_isContiguous" + p_isContiguous :: FunPtr (Ptr C'THByteTensor -> IO CInt) + +-- | p_isSameSizeAs : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THByteTensor_isSameSizeAs" + p_isSameSizeAs :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CInt) + +-- | p_isSetTo : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THByteTensor_isSetTo" + p_isSetTo :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CInt) + +-- | p_isSize : Pointer to function : self dims -> int +foreign import ccall "THTensor.h &THByteTensor_isSize" + p_isSize :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO CInt) + +-- | p_nElement : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THByteTensor_nElement" + p_nElement :: FunPtr (Ptr C'THByteTensor -> IO CPtrdiff) + +-- | p_retain : Pointer to function : self -> void +foreign import ccall "THTensor.h &THByteTensor_retain" + p_retain :: FunPtr (Ptr C'THByteTensor -> IO ()) + +-- | p_free : Pointer to function : self -> void +foreign import ccall "THTensor.h &THByteTensor_free" + p_free :: FunPtr (Ptr C'THByteTensor -> IO ()) + +-- | p_freeCopyTo : Pointer to function : self dst -> void +foreign import ccall "THTensor.h &THByteTensor_freeCopyTo" + p_freeCopyTo :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_set1d : Pointer to function : tensor x0 value -> void +foreign import ccall "THTensor.h &THByteTensor_set1d" + p_set1d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CUChar -> IO ()) + +-- | p_set2d : Pointer to function : tensor x0 x1 value -> void +foreign import ccall "THTensor.h &THByteTensor_set2d" + p_set2d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> CUChar -> IO ()) + +-- | p_set3d : Pointer to function : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h &THByteTensor_set3d" + p_set3d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CUChar -> IO ()) + +-- | p_set4d : Pointer to function : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h &THByteTensor_set4d" + p_set4d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CUChar -> IO ()) + +-- | p_get1d : Pointer to function : tensor x0 -> real +foreign import ccall "THTensor.h &THByteTensor_get1d" + p_get1d :: FunPtr (Ptr C'THByteTensor -> CLLong -> IO CUChar) + +-- | p_get2d : Pointer to function : tensor x0 x1 -> real +foreign import ccall "THTensor.h &THByteTensor_get2d" + p_get2d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> IO CUChar) + +-- | p_get3d : Pointer to function : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h &THByteTensor_get3d" + p_get3d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> IO CUChar) + +-- | p_get4d : Pointer to function : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h &THByteTensor_get4d" + p_get4d :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CUChar) + +-- | p_desc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THByteTensor_desc" + p_desc :: FunPtr (Ptr C'THByteTensor -> IO (Ptr C'THDescBuff)) + +-- | p_sizeDesc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THByteTensor_sizeDesc" + p_sizeDesc :: FunPtr (Ptr C'THByteTensor -> IO (Ptr C'THDescBuff)) diff --git a/src/Torch/FFI/TH/Byte/TensorConv.hs b/src/Torch/FFI/TH/Byte/TensorConv.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Byte/TensorConv.hs @@ -0,0 +1,272 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.TensorConv where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_validXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_validXCorr2Dptr" + c_validXCorr2Dptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2Dptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2Dptr = const c_validXCorr2Dptr_ + +-- | c_validConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_validConv2Dptr" + c_validConv2Dptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv2Dptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv2Dptr = const c_validConv2Dptr_ + +-- | c_fullXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_fullXCorr2Dptr" + c_fullXCorr2Dptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr2Dptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr2Dptr = const c_fullXCorr2Dptr_ + +-- | c_fullConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_fullConv2Dptr" + c_fullConv2Dptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv2Dptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv2Dptr = const c_fullConv2Dptr_ + +-- | c_validXCorr2DRevptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_validXCorr2DRevptr" + c_validXCorr2DRevptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2DRevptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2DRevptr = const c_validXCorr2DRevptr_ + +-- | c_conv2DRevger : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THByteTensor_conv2DRevger" + c_conv2DRevger_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevger :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> IO () +c_conv2DRevger = const c_conv2DRevger_ + +-- | c_conv2DRevgerm : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THByteTensor_conv2DRevgerm" + c_conv2DRevgerm_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevgerm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevgerm :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> IO () +c_conv2DRevgerm = const c_conv2DRevgerm_ + +-- | c_conv2Dger : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THByteTensor_conv2Dger" + c_conv2Dger_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dger :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dger = const c_conv2Dger_ + +-- | c_conv2Dmv : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THByteTensor_conv2Dmv" + c_conv2Dmv_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmv :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmv = const c_conv2Dmv_ + +-- | c_conv2Dmm : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THByteTensor_conv2Dmm" + c_conv2Dmm_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmm :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmm = const c_conv2Dmm_ + +-- | c_conv2Dmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THByteTensor_conv2Dmul" + c_conv2Dmul_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmul :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmul = const c_conv2Dmul_ + +-- | c_conv2Dcmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THByteTensor_conv2Dcmul" + c_conv2Dcmul_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dcmul :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dcmul = const c_conv2Dcmul_ + +-- | c_validXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_validXCorr3Dptr" + c_validXCorr3Dptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3Dptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3Dptr = const c_validXCorr3Dptr_ + +-- | c_validConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_validConv3Dptr" + c_validConv3Dptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv3Dptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv3Dptr = const c_validConv3Dptr_ + +-- | c_fullXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_fullXCorr3Dptr" + c_fullXCorr3Dptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr3Dptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr3Dptr = const c_fullXCorr3Dptr_ + +-- | c_fullConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_fullConv3Dptr" + c_fullConv3Dptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv3Dptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv3Dptr = const c_fullConv3Dptr_ + +-- | c_validXCorr3DRevptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THByteTensor_validXCorr3DRevptr" + c_validXCorr3DRevptr_ :: Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3DRevptr :: Ptr C'THState -> Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3DRevptr = const c_validXCorr3DRevptr_ + +-- | c_conv3DRevger : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h THByteTensor_conv3DRevger" + c_conv3DRevger_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_conv3DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3DRevger :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> IO () +c_conv3DRevger = const c_conv3DRevger_ + +-- | c_conv3Dger : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THByteTensor_conv3Dger" + c_conv3Dger_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dger :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dger = const c_conv3Dger_ + +-- | c_conv3Dmv : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THByteTensor_conv3Dmv" + c_conv3Dmv_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmv :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmv = const c_conv3Dmv_ + +-- | c_conv3Dmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THByteTensor_conv3Dmul" + c_conv3Dmul_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmul :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmul = const c_conv3Dmul_ + +-- | c_conv3Dcmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THByteTensor_conv3Dcmul" + c_conv3Dcmul_ :: Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dcmul :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dcmul = const c_conv3Dcmul_ + +-- | p_validXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_validXCorr2Dptr" + p_validXCorr2Dptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_validConv2Dptr" + p_validConv2Dptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_fullXCorr2Dptr" + p_fullXCorr2Dptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_fullConv2Dptr" + p_fullConv2Dptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr2DRevptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_validXCorr2DRevptr" + p_validXCorr2DRevptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevger : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv2DRevger" + p_conv2DRevger :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevgerm : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv2DRevgerm" + p_conv2DRevgerm :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2Dger : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv2Dger" + p_conv2Dger :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmv : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv2Dmv" + p_conv2Dmv :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmm : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv2Dmm" + p_conv2Dmm :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv2Dmul" + p_conv2Dmul :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dcmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv2Dcmul" + p_conv2Dcmul :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_validXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_validXCorr3Dptr" + p_validXCorr3Dptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_validConv3Dptr" + p_validConv3Dptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_fullXCorr3Dptr" + p_fullXCorr3Dptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_fullConv3Dptr" + p_fullConv3Dptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr3DRevptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THByteTensor_validXCorr3DRevptr" + p_validXCorr3DRevptr :: FunPtr (Ptr CUChar -> CUChar -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> Ptr CUChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3DRevger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv3DRevger" + p_conv3DRevger :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3Dger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv3Dger" + p_conv3Dger :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmv : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv3Dmv" + p_conv3Dmv :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv3Dmul" + p_conv3Dmul :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dcmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THByteTensor_conv3Dcmul" + p_conv3Dcmul :: FunPtr (Ptr C'THByteTensor -> CUChar -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) diff --git a/src/Torch/FFI/TH/Byte/TensorCopy.hs b/src/Torch/FFI/TH/Byte/TensorCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Byte/TensorCopy.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.TensorCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_copy : tensor src -> void +foreign import ccall "THTensorCopy.h THByteTensor_copy" + c_copy_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : tensor src -> void +foreign import ccall "THTensorCopy.h THByteTensor_copyByte" + c_copyByte_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : tensor src -> void +foreign import ccall "THTensorCopy.h THByteTensor_copyChar" + c_copyChar_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : tensor src -> void +foreign import ccall "THTensorCopy.h THByteTensor_copyShort" + c_copyShort_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : tensor src -> void +foreign import ccall "THTensorCopy.h THByteTensor_copyInt" + c_copyInt_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : tensor src -> void +foreign import ccall "THTensorCopy.h THByteTensor_copyLong" + c_copyLong_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : tensor src -> void +foreign import ccall "THTensorCopy.h THByteTensor_copyFloat" + c_copyFloat_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : tensor src -> void +foreign import ccall "THTensorCopy.h THByteTensor_copyDouble" + c_copyDouble_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : tensor src -> void +foreign import ccall "THTensorCopy.h THByteTensor_copyHalf" + c_copyHalf_ :: Ptr C'THByteTensor -> Ptr C'THHalfTensor -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THHalfTensor -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_copy : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THByteTensor_copy" + p_copy :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_copyByte : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THByteTensor_copyByte" + p_copyByte :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_copyChar : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THByteTensor_copyChar" + p_copyChar :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_copyShort : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THByteTensor_copyShort" + p_copyShort :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_copyInt : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THByteTensor_copyInt" + p_copyInt :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_copyLong : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THByteTensor_copyLong" + p_copyLong :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_copyFloat : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THByteTensor_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_copyDouble : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THByteTensor_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_copyHalf : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THByteTensor_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THByteTensor -> Ptr C'THHalfTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Byte/TensorMath.hs b/src/Torch/FFI/TH/Byte/TensorMath.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Byte/TensorMath.hs @@ -0,0 +1,1412 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.TensorMath where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : r_ value -> void +foreign import ccall "THTensorMath.h THByteTensor_fill" + c_fill_ :: Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> IO () +c_fill = const c_fill_ + +-- | c_zero : r_ -> void +foreign import ccall "THTensorMath.h THByteTensor_zero" + c_zero_ :: Ptr C'THByteTensor -> IO () + +-- | alias of c_zero_ with unused argument (for CTHState) to unify backpack signatures. +c_zero :: Ptr C'THState -> Ptr C'THByteTensor -> IO () +c_zero = const c_zero_ + +-- | c_maskedFill : tensor mask value -> void +foreign import ccall "THTensorMath.h THByteTensor_maskedFill" + c_maskedFill_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_maskedFill_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedFill :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_maskedFill = const c_maskedFill_ + +-- | c_maskedCopy : tensor mask src -> void +foreign import ccall "THTensorMath.h THByteTensor_maskedCopy" + c_maskedCopy_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_maskedCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedCopy :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_maskedCopy = const c_maskedCopy_ + +-- | c_maskedSelect : tensor src mask -> void +foreign import ccall "THTensorMath.h THByteTensor_maskedSelect" + c_maskedSelect_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_maskedSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedSelect :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_maskedSelect = const c_maskedSelect_ + +-- | c_nonzero : subscript tensor -> void +foreign import ccall "THTensorMath.h THByteTensor_nonzero" + c_nonzero_ :: Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_nonzero_ with unused argument (for CTHState) to unify backpack signatures. +c_nonzero :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () +c_nonzero = const c_nonzero_ + +-- | c_indexSelect : tensor src dim index -> void +foreign import ccall "THTensorMath.h THByteTensor_indexSelect" + c_indexSelect_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_indexSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_indexSelect :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_indexSelect = const c_indexSelect_ + +-- | c_indexCopy : tensor dim index src -> void +foreign import ccall "THTensorMath.h THByteTensor_indexCopy" + c_indexCopy_ :: Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_indexCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_indexCopy :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () +c_indexCopy = const c_indexCopy_ + +-- | c_indexAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THByteTensor_indexAdd" + c_indexAdd_ :: Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_indexAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_indexAdd :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () +c_indexAdd = const c_indexAdd_ + +-- | c_indexFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THByteTensor_indexFill" + c_indexFill_ :: Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> CUChar -> IO () + +-- | alias of c_indexFill_ with unused argument (for CTHState) to unify backpack signatures. +c_indexFill :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> CUChar -> IO () +c_indexFill = const c_indexFill_ + +-- | c_take : tensor src index -> void +foreign import ccall "THTensorMath.h THByteTensor_take" + c_take_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_take_ with unused argument (for CTHState) to unify backpack signatures. +c_take :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> IO () +c_take = const c_take_ + +-- | c_put : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h THByteTensor_put" + c_put_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> IO () + +-- | alias of c_put_ with unused argument (for CTHState) to unify backpack signatures. +c_put :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> IO () +c_put = const c_put_ + +-- | c_gather : tensor src dim index -> void +foreign import ccall "THTensorMath.h THByteTensor_gather" + c_gather_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_gather_ with unused argument (for CTHState) to unify backpack signatures. +c_gather :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_gather = const c_gather_ + +-- | c_scatter : tensor dim index src -> void +foreign import ccall "THTensorMath.h THByteTensor_scatter" + c_scatter_ :: Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_scatter_ with unused argument (for CTHState) to unify backpack signatures. +c_scatter :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () +c_scatter = const c_scatter_ + +-- | c_scatterAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THByteTensor_scatterAdd" + c_scatterAdd_ :: Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_scatterAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterAdd :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () +c_scatterAdd = const c_scatterAdd_ + +-- | c_scatterFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THByteTensor_scatterFill" + c_scatterFill_ :: Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> CUChar -> IO () + +-- | alias of c_scatterFill_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterFill :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> CUChar -> IO () +c_scatterFill = const c_scatterFill_ + +-- | c_dot : t src -> accreal +foreign import ccall "THTensorMath.h THByteTensor_dot" + c_dot_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CLong + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CLong +c_dot = const c_dot_ + +-- | c_minall : t -> real +foreign import ccall "THTensorMath.h THByteTensor_minall" + c_minall_ :: Ptr C'THByteTensor -> IO CUChar + +-- | alias of c_minall_ with unused argument (for CTHState) to unify backpack signatures. +c_minall :: Ptr C'THState -> Ptr C'THByteTensor -> IO CUChar +c_minall = const c_minall_ + +-- | c_maxall : t -> real +foreign import ccall "THTensorMath.h THByteTensor_maxall" + c_maxall_ :: Ptr C'THByteTensor -> IO CUChar + +-- | alias of c_maxall_ with unused argument (for CTHState) to unify backpack signatures. +c_maxall :: Ptr C'THState -> Ptr C'THByteTensor -> IO CUChar +c_maxall = const c_maxall_ + +-- | c_medianall : t -> real +foreign import ccall "THTensorMath.h THByteTensor_medianall" + c_medianall_ :: Ptr C'THByteTensor -> IO CUChar + +-- | alias of c_medianall_ with unused argument (for CTHState) to unify backpack signatures. +c_medianall :: Ptr C'THState -> Ptr C'THByteTensor -> IO CUChar +c_medianall = const c_medianall_ + +-- | c_sumall : t -> accreal +foreign import ccall "THTensorMath.h THByteTensor_sumall" + c_sumall_ :: Ptr C'THByteTensor -> IO CLong + +-- | alias of c_sumall_ with unused argument (for CTHState) to unify backpack signatures. +c_sumall :: Ptr C'THState -> Ptr C'THByteTensor -> IO CLong +c_sumall = const c_sumall_ + +-- | c_prodall : t -> accreal +foreign import ccall "THTensorMath.h THByteTensor_prodall" + c_prodall_ :: Ptr C'THByteTensor -> IO CLong + +-- | alias of c_prodall_ with unused argument (for CTHState) to unify backpack signatures. +c_prodall :: Ptr C'THState -> Ptr C'THByteTensor -> IO CLong +c_prodall = const c_prodall_ + +-- | c_add : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_add" + c_add_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_add_ with unused argument (for CTHState) to unify backpack signatures. +c_add :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_add = const c_add_ + +-- | c_sub : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_sub" + c_sub_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_sub_ with unused argument (for CTHState) to unify backpack signatures. +c_sub :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_sub = const c_sub_ + +-- | c_add_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THByteTensor_add_scaled" + c_add_scaled_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> CUChar -> IO () + +-- | alias of c_add_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_add_scaled :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> CUChar -> IO () +c_add_scaled = const c_add_scaled_ + +-- | c_sub_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THByteTensor_sub_scaled" + c_sub_scaled_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> CUChar -> IO () + +-- | alias of c_sub_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_sub_scaled :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> CUChar -> IO () +c_sub_scaled = const c_sub_scaled_ + +-- | c_mul : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_mul" + c_mul_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_mul_ with unused argument (for CTHState) to unify backpack signatures. +c_mul :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_mul = const c_mul_ + +-- | c_div : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_div" + c_div_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_div_ with unused argument (for CTHState) to unify backpack signatures. +c_div :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_div = const c_div_ + +-- | c_lshift : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_lshift" + c_lshift_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_lshift_ with unused argument (for CTHState) to unify backpack signatures. +c_lshift :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_lshift = const c_lshift_ + +-- | c_rshift : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_rshift" + c_rshift_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_rshift_ with unused argument (for CTHState) to unify backpack signatures. +c_rshift :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_rshift = const c_rshift_ + +-- | c_fmod : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_fmod" + c_fmod_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_fmod_ with unused argument (for CTHState) to unify backpack signatures. +c_fmod :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_fmod = const c_fmod_ + +-- | c_remainder : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_remainder" + c_remainder_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_remainder_ with unused argument (for CTHState) to unify backpack signatures. +c_remainder :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_remainder = const c_remainder_ + +-- | c_clamp : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h THByteTensor_clamp" + c_clamp_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> CUChar -> IO () + +-- | alias of c_clamp_ with unused argument (for CTHState) to unify backpack signatures. +c_clamp :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> CUChar -> IO () +c_clamp = const c_clamp_ + +-- | c_bitand : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_bitand" + c_bitand_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_bitand_ with unused argument (for CTHState) to unify backpack signatures. +c_bitand :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_bitand = const c_bitand_ + +-- | c_bitor : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_bitor" + c_bitor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_bitor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_bitor = const c_bitor_ + +-- | c_bitxor : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_bitxor" + c_bitxor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_bitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitxor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_bitxor = const c_bitxor_ + +-- | c_cadd : r_ t value src -> void +foreign import ccall "THTensorMath.h THByteTensor_cadd" + c_cadd_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> IO () +c_cadd = const c_cadd_ + +-- | c_csub : self src1 value src2 -> void +foreign import ccall "THTensorMath.h THByteTensor_csub" + c_csub_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> IO () + +-- | alias of c_csub_ with unused argument (for CTHState) to unify backpack signatures. +c_csub :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> IO () +c_csub = const c_csub_ + +-- | c_cmul : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cmul" + c_cmul_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cmul = const c_cmul_ + +-- | c_cpow : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cpow" + c_cpow_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cpow_ with unused argument (for CTHState) to unify backpack signatures. +c_cpow :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cpow = const c_cpow_ + +-- | c_cdiv : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cdiv" + c_cdiv_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cdiv = const c_cdiv_ + +-- | c_clshift : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_clshift" + c_clshift_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_clshift_ with unused argument (for CTHState) to unify backpack signatures. +c_clshift :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_clshift = const c_clshift_ + +-- | c_crshift : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_crshift" + c_crshift_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_crshift_ with unused argument (for CTHState) to unify backpack signatures. +c_crshift :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_crshift = const c_crshift_ + +-- | c_cfmod : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cfmod" + c_cfmod_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cfmod_ with unused argument (for CTHState) to unify backpack signatures. +c_cfmod :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cfmod = const c_cfmod_ + +-- | c_cremainder : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cremainder" + c_cremainder_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cremainder_ with unused argument (for CTHState) to unify backpack signatures. +c_cremainder :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cremainder = const c_cremainder_ + +-- | c_cbitand : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cbitand" + c_cbitand_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cbitand_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitand :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cbitand = const c_cbitand_ + +-- | c_cbitor : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cbitor" + c_cbitor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cbitor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cbitor = const c_cbitor_ + +-- | c_cbitxor : r_ t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cbitxor" + c_cbitxor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cbitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitxor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cbitxor = const c_cbitxor_ + +-- | c_addcmul : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THByteTensor_addcmul" + c_addcmul_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_addcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_addcmul :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_addcmul = const c_addcmul_ + +-- | c_addcdiv : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THByteTensor_addcdiv" + c_addcdiv_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_addcdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_addcdiv :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_addcdiv = const c_addcdiv_ + +-- | c_addmv : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h THByteTensor_addmv" + c_addmv_ :: Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_addmv_ with unused argument (for CTHState) to unify backpack signatures. +c_addmv :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_addmv = const c_addmv_ + +-- | c_addmm : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h THByteTensor_addmm" + c_addmm_ :: Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_addmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addmm :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_addmm = const c_addmm_ + +-- | c_addr : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h THByteTensor_addr" + c_addr_ :: Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_addr_ with unused argument (for CTHState) to unify backpack signatures. +c_addr :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_addr = const c_addr_ + +-- | c_addbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THByteTensor_addbmm" + c_addbmm_ :: Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_addbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addbmm :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_addbmm = const c_addbmm_ + +-- | c_baddbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THByteTensor_baddbmm" + c_baddbmm_ :: Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_baddbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_baddbmm :: Ptr C'THState -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_baddbmm = const c_baddbmm_ + +-- | c_match : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h THByteTensor_match" + c_match_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_match_ with unused argument (for CTHState) to unify backpack signatures. +c_match :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_match = const c_match_ + +-- | c_numel : t -> ptrdiff_t +foreign import ccall "THTensorMath.h THByteTensor_numel" + c_numel_ :: Ptr C'THByteTensor -> IO CPtrdiff + +-- | alias of c_numel_ with unused argument (for CTHState) to unify backpack signatures. +c_numel :: Ptr C'THState -> Ptr C'THByteTensor -> IO CPtrdiff +c_numel = const c_numel_ + +-- | c_preserveReduceDimSemantics : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h THByteTensor_preserveReduceDimSemantics" + c_preserveReduceDimSemantics_ :: Ptr C'THByteTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_preserveReduceDimSemantics_ with unused argument (for CTHState) to unify backpack signatures. +c_preserveReduceDimSemantics :: Ptr C'THState -> Ptr C'THByteTensor -> CInt -> CInt -> CInt -> IO () +c_preserveReduceDimSemantics = const c_preserveReduceDimSemantics_ + +-- | c_max : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THByteTensor_max" + c_max_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () + +-- | alias of c_max_ with unused argument (for CTHState) to unify backpack signatures. +c_max :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () +c_max = const c_max_ + +-- | c_min : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THByteTensor_min" + c_min_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () + +-- | alias of c_min_ with unused argument (for CTHState) to unify backpack signatures. +c_min :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () +c_min = const c_min_ + +-- | c_kthvalue : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h THByteTensor_kthvalue" + c_kthvalue_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CLLong -> CInt -> CInt -> IO () + +-- | alias of c_kthvalue_ with unused argument (for CTHState) to unify backpack signatures. +c_kthvalue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CLLong -> CInt -> CInt -> IO () +c_kthvalue = const c_kthvalue_ + +-- | c_mode : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THByteTensor_mode" + c_mode_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () + +-- | alias of c_mode_ with unused argument (for CTHState) to unify backpack signatures. +c_mode :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () +c_mode = const c_mode_ + +-- | c_median : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THByteTensor_median" + c_median_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () + +-- | alias of c_median_ with unused argument (for CTHState) to unify backpack signatures. +c_median :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () +c_median = const c_median_ + +-- | c_sum : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THByteTensor_sum" + c_sum_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () + +-- | alias of c_sum_ with unused argument (for CTHState) to unify backpack signatures. +c_sum :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () +c_sum = const c_sum_ + +-- | c_prod : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THByteTensor_prod" + c_prod_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () + +-- | alias of c_prod_ with unused argument (for CTHState) to unify backpack signatures. +c_prod :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () +c_prod = const c_prod_ + +-- | c_cumsum : r_ t dimension -> void +foreign import ccall "THTensorMath.h THByteTensor_cumsum" + c_cumsum_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () + +-- | alias of c_cumsum_ with unused argument (for CTHState) to unify backpack signatures. +c_cumsum :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () +c_cumsum = const c_cumsum_ + +-- | c_cumprod : r_ t dimension -> void +foreign import ccall "THTensorMath.h THByteTensor_cumprod" + c_cumprod_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () + +-- | alias of c_cumprod_ with unused argument (for CTHState) to unify backpack signatures. +c_cumprod :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () +c_cumprod = const c_cumprod_ + +-- | c_sign : r_ t -> void +foreign import ccall "THTensorMath.h THByteTensor_sign" + c_sign_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_sign_ with unused argument (for CTHState) to unify backpack signatures. +c_sign :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_sign = const c_sign_ + +-- | c_trace : t -> accreal +foreign import ccall "THTensorMath.h THByteTensor_trace" + c_trace_ :: Ptr C'THByteTensor -> IO CLong + +-- | alias of c_trace_ with unused argument (for CTHState) to unify backpack signatures. +c_trace :: Ptr C'THState -> Ptr C'THByteTensor -> IO CLong +c_trace = const c_trace_ + +-- | c_cross : r_ a b dimension -> void +foreign import ccall "THTensorMath.h THByteTensor_cross" + c_cross_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () + +-- | alias of c_cross_ with unused argument (for CTHState) to unify backpack signatures. +c_cross :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () +c_cross = const c_cross_ + +-- | c_cmax : r t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cmax" + c_cmax_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cmax_ with unused argument (for CTHState) to unify backpack signatures. +c_cmax :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cmax = const c_cmax_ + +-- | c_cmin : r t src -> void +foreign import ccall "THTensorMath.h THByteTensor_cmin" + c_cmin_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_cmin_ with unused argument (for CTHState) to unify backpack signatures. +c_cmin :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_cmin = const c_cmin_ + +-- | c_cmaxValue : r t value -> void +foreign import ccall "THTensorMath.h THByteTensor_cmaxValue" + c_cmaxValue_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_cmaxValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cmaxValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_cmaxValue = const c_cmaxValue_ + +-- | c_cminValue : r t value -> void +foreign import ccall "THTensorMath.h THByteTensor_cminValue" + c_cminValue_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_cminValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cminValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_cminValue = const c_cminValue_ + +-- | c_zeros : r_ size -> void +foreign import ccall "THTensorMath.h THByteTensor_zeros" + c_zeros_ :: Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_zeros_ with unused argument (for CTHState) to unify backpack signatures. +c_zeros :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO () +c_zeros = const c_zeros_ + +-- | c_zerosLike : r_ input -> void +foreign import ccall "THTensorMath.h THByteTensor_zerosLike" + c_zerosLike_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_zerosLike_ with unused argument (for CTHState) to unify backpack signatures. +c_zerosLike :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_zerosLike = const c_zerosLike_ + +-- | c_ones : r_ size -> void +foreign import ccall "THTensorMath.h THByteTensor_ones" + c_ones_ :: Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_ones_ with unused argument (for CTHState) to unify backpack signatures. +c_ones :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO () +c_ones = const c_ones_ + +-- | c_onesLike : r_ input -> void +foreign import ccall "THTensorMath.h THByteTensor_onesLike" + c_onesLike_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_onesLike_ with unused argument (for CTHState) to unify backpack signatures. +c_onesLike :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_onesLike = const c_onesLike_ + +-- | c_diag : r_ t k -> void +foreign import ccall "THTensorMath.h THByteTensor_diag" + c_diag_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () + +-- | alias of c_diag_ with unused argument (for CTHState) to unify backpack signatures. +c_diag :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () +c_diag = const c_diag_ + +-- | c_eye : r_ n m -> void +foreign import ccall "THTensorMath.h THByteTensor_eye" + c_eye_ :: Ptr C'THByteTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_eye_ with unused argument (for CTHState) to unify backpack signatures. +c_eye :: Ptr C'THState -> Ptr C'THByteTensor -> CLLong -> CLLong -> IO () +c_eye = const c_eye_ + +-- | c_arange : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THByteTensor_arange" + c_arange_ :: Ptr C'THByteTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_arange_ with unused argument (for CTHState) to unify backpack signatures. +c_arange :: Ptr C'THState -> Ptr C'THByteTensor -> CLong -> CLong -> CLong -> IO () +c_arange = const c_arange_ + +-- | c_range : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THByteTensor_range" + c_range_ :: Ptr C'THByteTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_range_ with unused argument (for CTHState) to unify backpack signatures. +c_range :: Ptr C'THState -> Ptr C'THByteTensor -> CLong -> CLong -> CLong -> IO () +c_range = const c_range_ + +-- | c_randperm : r_ _generator n -> void +foreign import ccall "THTensorMath.h THByteTensor_randperm" + c_randperm_ :: Ptr C'THByteTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_randperm_ with unused argument (for CTHState) to unify backpack signatures. +c_randperm :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_randperm = const c_randperm_ + +-- | c_reshape : r_ t size -> void +foreign import ccall "THTensorMath.h THByteTensor_reshape" + c_reshape_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_reshape_ with unused argument (for CTHState) to unify backpack signatures. +c_reshape :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO () +c_reshape = const c_reshape_ + +-- | c_sort : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h THByteTensor_sort" + c_sort_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () + +-- | alias of c_sort_ with unused argument (for CTHState) to unify backpack signatures. +c_sort :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO () +c_sort = const c_sort_ + +-- | c_topk : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h THByteTensor_topk" + c_topk_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CLLong -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_topk_ with unused argument (for CTHState) to unify backpack signatures. +c_topk :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CLLong -> CInt -> CInt -> CInt -> IO () +c_topk = const c_topk_ + +-- | c_tril : r_ t k -> void +foreign import ccall "THTensorMath.h THByteTensor_tril" + c_tril_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> IO () + +-- | alias of c_tril_ with unused argument (for CTHState) to unify backpack signatures. +c_tril :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> IO () +c_tril = const c_tril_ + +-- | c_triu : r_ t k -> void +foreign import ccall "THTensorMath.h THByteTensor_triu" + c_triu_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> IO () + +-- | alias of c_triu_ with unused argument (for CTHState) to unify backpack signatures. +c_triu :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> IO () +c_triu = const c_triu_ + +-- | c_cat : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h THByteTensor_cat" + c_cat_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () + +-- | alias of c_cat_ with unused argument (for CTHState) to unify backpack signatures. +c_cat :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO () +c_cat = const c_cat_ + +-- | c_catArray : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h THByteTensor_catArray" + c_catArray_ :: Ptr C'THByteTensor -> Ptr (Ptr C'THByteTensor) -> CInt -> CInt -> IO () + +-- | alias of c_catArray_ with unused argument (for CTHState) to unify backpack signatures. +c_catArray :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr (Ptr C'THByteTensor) -> CInt -> CInt -> IO () +c_catArray = const c_catArray_ + +-- | c_equal : ta tb -> int +foreign import ccall "THTensorMath.h THByteTensor_equal" + c_equal_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CInt + +-- | alias of c_equal_ with unused argument (for CTHState) to unify backpack signatures. +c_equal :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CInt +c_equal = const c_equal_ + +-- | c_ltValue : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_ltValue" + c_ltValue_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_ltValue_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_ltValue = const c_ltValue_ + +-- | c_leValue : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_leValue" + c_leValue_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_leValue_ with unused argument (for CTHState) to unify backpack signatures. +c_leValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_leValue = const c_leValue_ + +-- | c_gtValue : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_gtValue" + c_gtValue_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_gtValue_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_gtValue = const c_gtValue_ + +-- | c_geValue : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_geValue" + c_geValue_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_geValue_ with unused argument (for CTHState) to unify backpack signatures. +c_geValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_geValue = const c_geValue_ + +-- | c_neValue : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_neValue" + c_neValue_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_neValue_ with unused argument (for CTHState) to unify backpack signatures. +c_neValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_neValue = const c_neValue_ + +-- | c_eqValue : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_eqValue" + c_eqValue_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_eqValue_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_eqValue = const c_eqValue_ + +-- | c_ltValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_ltValueT" + c_ltValueT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_ltValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValueT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_ltValueT = const c_ltValueT_ + +-- | c_leValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_leValueT" + c_leValueT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_leValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_leValueT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_leValueT = const c_leValueT_ + +-- | c_gtValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_gtValueT" + c_gtValueT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_gtValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValueT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_gtValueT = const c_gtValueT_ + +-- | c_geValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_geValueT" + c_geValueT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_geValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_geValueT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_geValueT = const c_geValueT_ + +-- | c_neValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_neValueT" + c_neValueT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_neValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_neValueT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_neValueT = const c_neValueT_ + +-- | c_eqValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THByteTensor_eqValueT" + c_eqValueT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () + +-- | alias of c_eqValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValueT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO () +c_eqValueT = const c_eqValueT_ + +-- | c_ltTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_ltTensor" + c_ltTensor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_ltTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_ltTensor = const c_ltTensor_ + +-- | c_leTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_leTensor" + c_leTensor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_leTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_leTensor = const c_leTensor_ + +-- | c_gtTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_gtTensor" + c_gtTensor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_gtTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_gtTensor = const c_gtTensor_ + +-- | c_geTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_geTensor" + c_geTensor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_geTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_geTensor = const c_geTensor_ + +-- | c_neTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_neTensor" + c_neTensor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_neTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_neTensor = const c_neTensor_ + +-- | c_eqTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_eqTensor" + c_eqTensor_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_eqTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_eqTensor = const c_eqTensor_ + +-- | c_ltTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_ltTensorT" + c_ltTensorT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_ltTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensorT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_ltTensorT = const c_ltTensorT_ + +-- | c_leTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_leTensorT" + c_leTensorT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_leTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensorT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_leTensorT = const c_leTensorT_ + +-- | c_gtTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_gtTensorT" + c_gtTensorT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_gtTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensorT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_gtTensorT = const c_gtTensorT_ + +-- | c_geTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_geTensorT" + c_geTensorT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_geTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensorT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_geTensorT = const c_geTensorT_ + +-- | c_neTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_neTensorT" + c_neTensorT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_neTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensorT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_neTensorT = const c_neTensorT_ + +-- | c_eqTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THByteTensor_eqTensorT" + c_eqTensorT_ :: Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_eqTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensorT :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO () +c_eqTensorT = const c_eqTensorT_ + +-- | c_logicalall : self -> int +foreign import ccall "THTensorMath.h THByteTensor_logicalall" + c_logicalall_ :: Ptr C'THByteTensor -> IO CInt + +-- | alias of c_logicalall_ with unused argument (for CTHState) to unify backpack signatures. +c_logicalall :: Ptr C'THState -> Ptr C'THByteTensor -> IO CInt +c_logicalall = const c_logicalall_ + +-- | c_logicalany : self -> int +foreign import ccall "THTensorMath.h THByteTensor_logicalany" + c_logicalany_ :: Ptr C'THByteTensor -> IO CInt + +-- | alias of c_logicalany_ with unused argument (for CTHState) to unify backpack signatures. +c_logicalany :: Ptr C'THState -> Ptr C'THByteTensor -> IO CInt +c_logicalany = const c_logicalany_ + +-- | p_fill : Pointer to function : r_ value -> void +foreign import ccall "THTensorMath.h &THByteTensor_fill" + p_fill :: FunPtr (Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_zero : Pointer to function : r_ -> void +foreign import ccall "THTensorMath.h &THByteTensor_zero" + p_zero :: FunPtr (Ptr C'THByteTensor -> IO ()) + +-- | p_maskedFill : Pointer to function : tensor mask value -> void +foreign import ccall "THTensorMath.h &THByteTensor_maskedFill" + p_maskedFill :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_maskedCopy : Pointer to function : tensor mask src -> void +foreign import ccall "THTensorMath.h &THByteTensor_maskedCopy" + p_maskedCopy :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_maskedSelect : Pointer to function : tensor src mask -> void +foreign import ccall "THTensorMath.h &THByteTensor_maskedSelect" + p_maskedSelect :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_nonzero : Pointer to function : subscript tensor -> void +foreign import ccall "THTensorMath.h &THByteTensor_nonzero" + p_nonzero :: FunPtr (Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_indexSelect : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THByteTensor_indexSelect" + p_indexSelect :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexCopy : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THByteTensor_indexCopy" + p_indexCopy :: FunPtr (Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_indexAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THByteTensor_indexAdd" + p_indexAdd :: FunPtr (Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_indexFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THByteTensor_indexFill" + p_indexFill :: FunPtr (Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> CUChar -> IO ()) + +-- | p_take : Pointer to function : tensor src index -> void +foreign import ccall "THTensorMath.h &THByteTensor_take" + p_take :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_put : Pointer to function : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h &THByteTensor_put" + p_put :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> IO ()) + +-- | p_gather : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THByteTensor_gather" + p_gather :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_scatter : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THByteTensor_scatter" + p_scatter :: FunPtr (Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_scatterAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THByteTensor_scatterAdd" + p_scatterAdd :: FunPtr (Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_scatterFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THByteTensor_scatterFill" + p_scatterFill :: FunPtr (Ptr C'THByteTensor -> CInt -> Ptr C'THLongTensor -> CUChar -> IO ()) + +-- | p_dot : Pointer to function : t src -> accreal +foreign import ccall "THTensorMath.h &THByteTensor_dot" + p_dot :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CLong) + +-- | p_minall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THByteTensor_minall" + p_minall :: FunPtr (Ptr C'THByteTensor -> IO CUChar) + +-- | p_maxall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THByteTensor_maxall" + p_maxall :: FunPtr (Ptr C'THByteTensor -> IO CUChar) + +-- | p_medianall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THByteTensor_medianall" + p_medianall :: FunPtr (Ptr C'THByteTensor -> IO CUChar) + +-- | p_sumall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THByteTensor_sumall" + p_sumall :: FunPtr (Ptr C'THByteTensor -> IO CLong) + +-- | p_prodall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THByteTensor_prodall" + p_prodall :: FunPtr (Ptr C'THByteTensor -> IO CLong) + +-- | p_add : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_add" + p_add :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_sub : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_sub" + p_sub :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_add_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THByteTensor_add_scaled" + p_add_scaled :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> CUChar -> IO ()) + +-- | p_sub_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THByteTensor_sub_scaled" + p_sub_scaled :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> CUChar -> IO ()) + +-- | p_mul : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_mul" + p_mul :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_div : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_div" + p_div :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_lshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_lshift" + p_lshift :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_rshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_rshift" + p_rshift :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_fmod : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_fmod" + p_fmod :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_remainder : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_remainder" + p_remainder :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_clamp : Pointer to function : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h &THByteTensor_clamp" + p_clamp :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> CUChar -> IO ()) + +-- | p_bitand : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_bitand" + p_bitand :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_bitor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_bitor" + p_bitor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_bitxor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_bitxor" + p_bitxor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_cadd : Pointer to function : r_ t value src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cadd" + p_cadd :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> IO ()) + +-- | p_csub : Pointer to function : self src1 value src2 -> void +foreign import ccall "THTensorMath.h &THByteTensor_csub" + p_csub :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> IO ()) + +-- | p_cmul : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cmul" + p_cmul :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_cpow : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cpow" + p_cpow :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_cdiv : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cdiv" + p_cdiv :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_clshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_clshift" + p_clshift :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_crshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_crshift" + p_crshift :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_cfmod : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cfmod" + p_cfmod :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_cremainder : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cremainder" + p_cremainder :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_cbitand : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cbitand" + p_cbitand :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_cbitor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cbitor" + p_cbitor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_cbitxor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cbitxor" + p_cbitxor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_addcmul : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THByteTensor_addcmul" + p_addcmul :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_addcdiv : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THByteTensor_addcdiv" + p_addcdiv :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_addmv : Pointer to function : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h &THByteTensor_addmv" + p_addmv :: FunPtr (Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_addmm : Pointer to function : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h &THByteTensor_addmm" + p_addmm :: FunPtr (Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_addr : Pointer to function : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h &THByteTensor_addr" + p_addr :: FunPtr (Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_addbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THByteTensor_addbmm" + p_addbmm :: FunPtr (Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_baddbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THByteTensor_baddbmm" + p_baddbmm :: FunPtr (Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> CUChar -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_match : Pointer to function : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h &THByteTensor_match" + p_match :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_numel : Pointer to function : t -> ptrdiff_t +foreign import ccall "THTensorMath.h &THByteTensor_numel" + p_numel :: FunPtr (Ptr C'THByteTensor -> IO CPtrdiff) + +-- | p_preserveReduceDimSemantics : Pointer to function : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h &THByteTensor_preserveReduceDimSemantics" + p_preserveReduceDimSemantics :: FunPtr (Ptr C'THByteTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_max : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THByteTensor_max" + p_max :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO ()) + +-- | p_min : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THByteTensor_min" + p_min :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO ()) + +-- | p_kthvalue : Pointer to function : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h &THByteTensor_kthvalue" + p_kthvalue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CLLong -> CInt -> CInt -> IO ()) + +-- | p_mode : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THByteTensor_mode" + p_mode :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO ()) + +-- | p_median : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THByteTensor_median" + p_median :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO ()) + +-- | p_sum : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THByteTensor_sum" + p_sum :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO ()) + +-- | p_prod : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THByteTensor_prod" + p_prod :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO ()) + +-- | p_cumsum : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THByteTensor_cumsum" + p_cumsum :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO ()) + +-- | p_cumprod : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THByteTensor_cumprod" + p_cumprod :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO ()) + +-- | p_sign : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THByteTensor_sign" + p_sign :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_trace : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THByteTensor_trace" + p_trace :: FunPtr (Ptr C'THByteTensor -> IO CLong) + +-- | p_cross : Pointer to function : r_ a b dimension -> void +foreign import ccall "THTensorMath.h &THByteTensor_cross" + p_cross :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO ()) + +-- | p_cmax : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cmax" + p_cmax :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_cmin : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THByteTensor_cmin" + p_cmin :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_cmaxValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_cmaxValue" + p_cmaxValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_cminValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_cminValue" + p_cminValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_zeros : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THByteTensor_zeros" + p_zeros :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_zerosLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THByteTensor_zerosLike" + p_zerosLike :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_ones : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THByteTensor_ones" + p_ones :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_onesLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THByteTensor_onesLike" + p_onesLike :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_diag : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THByteTensor_diag" + p_diag :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO ()) + +-- | p_eye : Pointer to function : r_ n m -> void +foreign import ccall "THTensorMath.h &THByteTensor_eye" + p_eye :: FunPtr (Ptr C'THByteTensor -> CLLong -> CLLong -> IO ()) + +-- | p_arange : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THByteTensor_arange" + p_arange :: FunPtr (Ptr C'THByteTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_range : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THByteTensor_range" + p_range :: FunPtr (Ptr C'THByteTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_randperm : Pointer to function : r_ _generator n -> void +foreign import ccall "THTensorMath.h &THByteTensor_randperm" + p_randperm :: FunPtr (Ptr C'THByteTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_reshape : Pointer to function : r_ t size -> void +foreign import ccall "THTensorMath.h &THByteTensor_reshape" + p_reshape :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_sort : Pointer to function : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h &THByteTensor_sort" + p_sort :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CInt -> CInt -> IO ()) + +-- | p_topk : Pointer to function : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h &THByteTensor_topk" + p_topk :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CLLong -> CInt -> CInt -> CInt -> IO ()) + +-- | p_tril : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THByteTensor_tril" + p_tril :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> IO ()) + +-- | p_triu : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THByteTensor_triu" + p_triu :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CLLong -> IO ()) + +-- | p_cat : Pointer to function : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h &THByteTensor_cat" + p_cat :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> CInt -> IO ()) + +-- | p_catArray : Pointer to function : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h &THByteTensor_catArray" + p_catArray :: FunPtr (Ptr C'THByteTensor -> Ptr (Ptr C'THByteTensor) -> CInt -> CInt -> IO ()) + +-- | p_equal : Pointer to function : ta tb -> int +foreign import ccall "THTensorMath.h &THByteTensor_equal" + p_equal :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO CInt) + +-- | p_ltValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_ltValue" + p_ltValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_leValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_leValue" + p_leValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_gtValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_gtValue" + p_gtValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_geValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_geValue" + p_geValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_neValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_neValue" + p_neValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_eqValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_eqValue" + p_eqValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_ltValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_ltValueT" + p_ltValueT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_leValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_leValueT" + p_leValueT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_gtValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_gtValueT" + p_gtValueT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_geValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_geValueT" + p_geValueT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_neValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_neValueT" + p_neValueT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_eqValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THByteTensor_eqValueT" + p_eqValueT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> CUChar -> IO ()) + +-- | p_ltTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_ltTensor" + p_ltTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_leTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_leTensor" + p_leTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_gtTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_gtTensor" + p_gtTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_geTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_geTensor" + p_geTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_neTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_neTensor" + p_neTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_eqTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_eqTensor" + p_eqTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_ltTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_ltTensorT" + p_ltTensorT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_leTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_leTensorT" + p_leTensorT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_gtTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_gtTensorT" + p_gtTensorT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_geTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_geTensorT" + p_geTensorT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_neTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_neTensorT" + p_neTensorT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_eqTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THByteTensor_eqTensorT" + p_eqTensorT :: FunPtr (Ptr C'THByteTensor -> Ptr C'THByteTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_logicalall : Pointer to function : self -> int +foreign import ccall "THTensorMath.h &THByteTensor_logicalall" + p_logicalall :: FunPtr (Ptr C'THByteTensor -> IO CInt) + +-- | p_logicalany : Pointer to function : self -> int +foreign import ccall "THTensorMath.h &THByteTensor_logicalany" + p_logicalany :: FunPtr (Ptr C'THByteTensor -> IO CInt) diff --git a/src/Torch/FFI/TH/Byte/TensorRandom.hs b/src/Torch/FFI/TH/Byte/TensorRandom.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Byte/TensorRandom.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.TensorRandom where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_random : self _generator -> void +foreign import ccall "THTensorRandom.h THByteTensor_random" + c_random_ :: Ptr C'THByteTensor -> Ptr C'THGenerator -> IO () + +-- | alias of c_random_ with unused argument (for CTHState) to unify backpack signatures. +c_random :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THGenerator -> IO () +c_random = const c_random_ + +-- | c_clampedRandom : self _generator min max -> void +foreign import ccall "THTensorRandom.h THByteTensor_clampedRandom" + c_clampedRandom_ :: Ptr C'THByteTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () + +-- | alias of c_clampedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_clampedRandom :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () +c_clampedRandom = const c_clampedRandom_ + +-- | c_cappedRandom : self _generator max -> void +foreign import ccall "THTensorRandom.h THByteTensor_cappedRandom" + c_cappedRandom_ :: Ptr C'THByteTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_cappedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_cappedRandom :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_cappedRandom = const c_cappedRandom_ + +-- | c_geometric : self _generator p -> void +foreign import ccall "THTensorRandom.h THByteTensor_geometric" + c_geometric_ :: Ptr C'THByteTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_geometric_ with unused argument (for CTHState) to unify backpack signatures. +c_geometric :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_geometric = const c_geometric_ + +-- | c_bernoulli : self _generator p -> void +foreign import ccall "THTensorRandom.h THByteTensor_bernoulli" + c_bernoulli_ :: Ptr C'THByteTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_bernoulli_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_bernoulli = const c_bernoulli_ + +-- | c_bernoulli_FloatTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THByteTensor_bernoulli_FloatTensor" + c_bernoulli_FloatTensor_ :: Ptr C'THByteTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_bernoulli_FloatTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_FloatTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () +c_bernoulli_FloatTensor = const c_bernoulli_FloatTensor_ + +-- | c_bernoulli_DoubleTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THByteTensor_bernoulli_DoubleTensor" + c_bernoulli_DoubleTensor_ :: Ptr C'THByteTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_bernoulli_DoubleTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_DoubleTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () +c_bernoulli_DoubleTensor = const c_bernoulli_DoubleTensor_ + +-- | c_getRNGState : _generator self -> void +foreign import ccall "THTensorRandom.h THByteTensor_getRNGState" + c_getRNGState_ :: Ptr C'THGenerator -> Ptr C'THByteTensor -> IO () + +-- | alias of c_getRNGState_ with unused argument (for CTHState) to unify backpack signatures. +c_getRNGState :: Ptr C'THState -> Ptr C'THGenerator -> Ptr C'THByteTensor -> IO () +c_getRNGState = const c_getRNGState_ + +-- | c_setRNGState : _generator self -> void +foreign import ccall "THTensorRandom.h THByteTensor_setRNGState" + c_setRNGState_ :: Ptr C'THGenerator -> Ptr C'THByteTensor -> IO () + +-- | alias of c_setRNGState_ with unused argument (for CTHState) to unify backpack signatures. +c_setRNGState :: Ptr C'THState -> Ptr C'THGenerator -> Ptr C'THByteTensor -> IO () +c_setRNGState = const c_setRNGState_ + +-- | p_random : Pointer to function : self _generator -> void +foreign import ccall "THTensorRandom.h &THByteTensor_random" + p_random :: FunPtr (Ptr C'THByteTensor -> Ptr C'THGenerator -> IO ()) + +-- | p_clampedRandom : Pointer to function : self _generator min max -> void +foreign import ccall "THTensorRandom.h &THByteTensor_clampedRandom" + p_clampedRandom :: FunPtr (Ptr C'THByteTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO ()) + +-- | p_cappedRandom : Pointer to function : self _generator max -> void +foreign import ccall "THTensorRandom.h &THByteTensor_cappedRandom" + p_cappedRandom :: FunPtr (Ptr C'THByteTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_geometric : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THByteTensor_geometric" + p_geometric :: FunPtr (Ptr C'THByteTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THByteTensor_bernoulli" + p_bernoulli :: FunPtr (Ptr C'THByteTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli_FloatTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THByteTensor_bernoulli_FloatTensor" + p_bernoulli_FloatTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO ()) + +-- | p_bernoulli_DoubleTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THByteTensor_bernoulli_DoubleTensor" + p_bernoulli_DoubleTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_getRNGState : Pointer to function : _generator self -> void +foreign import ccall "THTensorRandom.h &THByteTensor_getRNGState" + p_getRNGState :: FunPtr (Ptr C'THGenerator -> Ptr C'THByteTensor -> IO ()) + +-- | p_setRNGState : Pointer to function : _generator self -> void +foreign import ccall "THTensorRandom.h &THByteTensor_setRNGState" + p_setRNGState :: FunPtr (Ptr C'THGenerator -> Ptr C'THByteTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Byte/Vector.hs b/src/Torch/FFI/TH/Byte/Vector.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Byte/Vector.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Byte.Vector where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : x c n -> void +foreign import ccall "THVector.h THByteVector_fill" + c_fill_ :: Ptr CUChar -> CUChar -> CPtrdiff -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr CUChar -> CUChar -> CPtrdiff -> IO () +c_fill = const c_fill_ + +-- | c_cadd : z x y c n -> void +foreign import ccall "THVector.h THByteVector_cadd" + c_cadd_ :: Ptr CUChar -> Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr CUChar -> Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO () +c_cadd = const c_cadd_ + +-- | c_adds : y x c n -> void +foreign import ccall "THVector.h THByteVector_adds" + c_adds_ :: Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO () + +-- | alias of c_adds_ with unused argument (for CTHState) to unify backpack signatures. +c_adds :: Ptr C'THState -> Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO () +c_adds = const c_adds_ + +-- | c_cmul : z x y n -> void +foreign import ccall "THVector.h THByteVector_cmul" + c_cmul_ :: Ptr CUChar -> Ptr CUChar -> Ptr CUChar -> CPtrdiff -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr CUChar -> Ptr CUChar -> Ptr CUChar -> CPtrdiff -> IO () +c_cmul = const c_cmul_ + +-- | c_muls : y x c n -> void +foreign import ccall "THVector.h THByteVector_muls" + c_muls_ :: Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO () + +-- | alias of c_muls_ with unused argument (for CTHState) to unify backpack signatures. +c_muls :: Ptr C'THState -> Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO () +c_muls = const c_muls_ + +-- | c_cdiv : z x y n -> void +foreign import ccall "THVector.h THByteVector_cdiv" + c_cdiv_ :: Ptr CUChar -> Ptr CUChar -> Ptr CUChar -> CPtrdiff -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr CUChar -> Ptr CUChar -> Ptr CUChar -> CPtrdiff -> IO () +c_cdiv = const c_cdiv_ + +-- | c_divs : y x c n -> void +foreign import ccall "THVector.h THByteVector_divs" + c_divs_ :: Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO () + +-- | alias of c_divs_ with unused argument (for CTHState) to unify backpack signatures. +c_divs :: Ptr C'THState -> Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO () +c_divs = const c_divs_ + +-- | c_copy : y x n -> void +foreign import ccall "THVector.h THByteVector_copy" + c_copy_ :: Ptr CUChar -> Ptr CUChar -> CPtrdiff -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr CUChar -> Ptr CUChar -> CPtrdiff -> IO () +c_copy = const c_copy_ + +-- | c_normal_fill : data size generator mean stddev -> void +foreign import ccall "THVector.h THByteVector_normal_fill" + c_normal_fill_ :: Ptr CUChar -> CLLong -> Ptr C'THGenerator -> CUChar -> CUChar -> IO () + +-- | alias of c_normal_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_fill :: Ptr C'THState -> Ptr CUChar -> CLLong -> Ptr C'THGenerator -> CUChar -> CUChar -> IO () +c_normal_fill = const c_normal_fill_ + +-- | p_fill : Pointer to function : x c n -> void +foreign import ccall "THVector.h &THByteVector_fill" + p_fill :: FunPtr (Ptr CUChar -> CUChar -> CPtrdiff -> IO ()) + +-- | p_cadd : Pointer to function : z x y c n -> void +foreign import ccall "THVector.h &THByteVector_cadd" + p_cadd :: FunPtr (Ptr CUChar -> Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO ()) + +-- | p_adds : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THByteVector_adds" + p_adds :: FunPtr (Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO ()) + +-- | p_cmul : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THByteVector_cmul" + p_cmul :: FunPtr (Ptr CUChar -> Ptr CUChar -> Ptr CUChar -> CPtrdiff -> IO ()) + +-- | p_muls : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THByteVector_muls" + p_muls :: FunPtr (Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO ()) + +-- | p_cdiv : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THByteVector_cdiv" + p_cdiv :: FunPtr (Ptr CUChar -> Ptr CUChar -> Ptr CUChar -> CPtrdiff -> IO ()) + +-- | p_divs : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THByteVector_divs" + p_divs :: FunPtr (Ptr CUChar -> Ptr CUChar -> CUChar -> CPtrdiff -> IO ()) + +-- | p_copy : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THByteVector_copy" + p_copy :: FunPtr (Ptr CUChar -> Ptr CUChar -> CPtrdiff -> IO ()) + +-- | p_normal_fill : Pointer to function : data size generator mean stddev -> void +foreign import ccall "THVector.h &THByteVector_normal_fill" + p_normal_fill :: FunPtr (Ptr CUChar -> CLLong -> Ptr C'THGenerator -> CUChar -> CUChar -> IO ()) diff --git a/src/Torch/FFI/TH/Char/Blas.hs b/src/Torch/FFI/TH/Char/Blas.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Char/Blas.hs @@ -0,0 +1,104 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.Blas where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_swap : n x incx y incy -> void +foreign import ccall "THBlas.h THCharBlas_swap" + c_swap_ :: CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO () +c_swap = const c_swap_ + +-- | c_scal : n a x incx -> void +foreign import ccall "THBlas.h THCharBlas_scal" + c_scal_ :: CLLong -> CChar -> Ptr CChar -> CLLong -> IO () + +-- | alias of c_scal_ with unused argument (for CTHState) to unify backpack signatures. +c_scal :: Ptr C'THState -> CLLong -> CChar -> Ptr CChar -> CLLong -> IO () +c_scal = const c_scal_ + +-- | c_copy : n x incx y incy -> void +foreign import ccall "THBlas.h THCharBlas_copy" + c_copy_ :: CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO () +c_copy = const c_copy_ + +-- | c_axpy : n a x incx y incy -> void +foreign import ccall "THBlas.h THCharBlas_axpy" + c_axpy_ :: CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO () + +-- | alias of c_axpy_ with unused argument (for CTHState) to unify backpack signatures. +c_axpy :: Ptr C'THState -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO () +c_axpy = const c_axpy_ + +-- | c_dot : n x incx y incy -> real +foreign import ccall "THBlas.h THCharBlas_dot" + c_dot_ :: CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO CChar + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO CChar +c_dot = const c_dot_ + +-- | c_gemv : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h THCharBlas_gemv" + c_gemv_ :: CChar -> CLLong -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> CChar -> Ptr CChar -> CLLong -> IO () + +-- | alias of c_gemv_ with unused argument (for CTHState) to unify backpack signatures. +c_gemv :: Ptr C'THState -> CChar -> CLLong -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> CChar -> Ptr CChar -> CLLong -> IO () +c_gemv = const c_gemv_ + +-- | c_ger : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h THCharBlas_ger" + c_ger_ :: CLLong -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO () + +-- | alias of c_ger_ with unused argument (for CTHState) to unify backpack signatures. +c_ger :: Ptr C'THState -> CLLong -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO () +c_ger = const c_ger_ + +-- | c_gemm : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h THCharBlas_gemm" + c_gemm_ :: CChar -> CChar -> CLLong -> CLLong -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> CChar -> Ptr CChar -> CLLong -> IO () + +-- | alias of c_gemm_ with unused argument (for CTHState) to unify backpack signatures. +c_gemm :: Ptr C'THState -> CChar -> CChar -> CLLong -> CLLong -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> CChar -> Ptr CChar -> CLLong -> IO () +c_gemm = const c_gemm_ + +-- | p_swap : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THCharBlas_swap" + p_swap :: FunPtr (CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO ()) + +-- | p_scal : Pointer to function : n a x incx -> void +foreign import ccall "THBlas.h &THCharBlas_scal" + p_scal :: FunPtr (CLLong -> CChar -> Ptr CChar -> CLLong -> IO ()) + +-- | p_copy : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THCharBlas_copy" + p_copy :: FunPtr (CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO ()) + +-- | p_axpy : Pointer to function : n a x incx y incy -> void +foreign import ccall "THBlas.h &THCharBlas_axpy" + p_axpy :: FunPtr (CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO ()) + +-- | p_dot : Pointer to function : n x incx y incy -> real +foreign import ccall "THBlas.h &THCharBlas_dot" + p_dot :: FunPtr (CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO CChar) + +-- | p_gemv : Pointer to function : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h &THCharBlas_gemv" + p_gemv :: FunPtr (CChar -> CLLong -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> CChar -> Ptr CChar -> CLLong -> IO ()) + +-- | p_ger : Pointer to function : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h &THCharBlas_ger" + p_ger :: FunPtr (CLLong -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> IO ()) + +-- | p_gemm : Pointer to function : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h &THCharBlas_gemm" + p_gemm :: FunPtr (CChar -> CChar -> CLLong -> CLLong -> CLLong -> CChar -> Ptr CChar -> CLLong -> Ptr CChar -> CLLong -> CChar -> Ptr CChar -> CLLong -> IO ()) diff --git a/src/Torch/FFI/TH/Char/Storage.hs b/src/Torch/FFI/TH/Char/Storage.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Char/Storage.hs @@ -0,0 +1,260 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.Storage where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_data : -> real * +foreign import ccall "THStorage.h THCharStorage_data" + c_data_ :: Ptr C'THCharStorage -> IO (Ptr CChar) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THCharStorage -> IO (Ptr CChar) +c_data = const c_data_ + +-- | c_size : -> ptrdiff_t +foreign import ccall "THStorage.h THCharStorage_size" + c_size_ :: Ptr C'THCharStorage -> IO CPtrdiff + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THCharStorage -> IO CPtrdiff +c_size = const c_size_ + +-- | c_set : -> void +foreign import ccall "THStorage.h THCharStorage_set" + c_set_ :: Ptr C'THCharStorage -> CPtrdiff -> CChar -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THCharStorage -> CPtrdiff -> CChar -> IO () +c_set = const c_set_ + +-- | c_get : -> real +foreign import ccall "THStorage.h THCharStorage_get" + c_get_ :: Ptr C'THCharStorage -> CPtrdiff -> IO CChar + +-- | alias of c_get_ with unused argument (for CTHState) to unify backpack signatures. +c_get :: Ptr C'THState -> Ptr C'THCharStorage -> CPtrdiff -> IO CChar +c_get = const c_get_ + +-- | c_new : -> THStorage * +foreign import ccall "THStorage.h THCharStorage_new" + c_new_ :: IO (Ptr C'THCharStorage) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THCharStorage) +c_new = const c_new_ + +-- | c_newWithSize : size -> THStorage * +foreign import ccall "THStorage.h THCharStorage_newWithSize" + c_newWithSize_ :: CPtrdiff -> IO (Ptr C'THCharStorage) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> CPtrdiff -> IO (Ptr C'THCharStorage) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1 : -> THStorage * +foreign import ccall "THStorage.h THCharStorage_newWithSize1" + c_newWithSize1_ :: CChar -> IO (Ptr C'THCharStorage) + +-- | alias of c_newWithSize1_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1 :: Ptr C'THState -> CChar -> IO (Ptr C'THCharStorage) +c_newWithSize1 = const c_newWithSize1_ + +-- | c_newWithSize2 : -> THStorage * +foreign import ccall "THStorage.h THCharStorage_newWithSize2" + c_newWithSize2_ :: CChar -> CChar -> IO (Ptr C'THCharStorage) + +-- | alias of c_newWithSize2_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2 :: Ptr C'THState -> CChar -> CChar -> IO (Ptr C'THCharStorage) +c_newWithSize2 = const c_newWithSize2_ + +-- | c_newWithSize3 : -> THStorage * +foreign import ccall "THStorage.h THCharStorage_newWithSize3" + c_newWithSize3_ :: CChar -> CChar -> CChar -> IO (Ptr C'THCharStorage) + +-- | alias of c_newWithSize3_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3 :: Ptr C'THState -> CChar -> CChar -> CChar -> IO (Ptr C'THCharStorage) +c_newWithSize3 = const c_newWithSize3_ + +-- | c_newWithSize4 : -> THStorage * +foreign import ccall "THStorage.h THCharStorage_newWithSize4" + c_newWithSize4_ :: CChar -> CChar -> CChar -> CChar -> IO (Ptr C'THCharStorage) + +-- | alias of c_newWithSize4_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4 :: Ptr C'THState -> CChar -> CChar -> CChar -> CChar -> IO (Ptr C'THCharStorage) +c_newWithSize4 = const c_newWithSize4_ + +-- | c_newWithMapping : filename size flags -> THStorage * +foreign import ccall "THStorage.h THCharStorage_newWithMapping" + c_newWithMapping_ :: Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THCharStorage) + +-- | alias of c_newWithMapping_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithMapping :: Ptr C'THState -> Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THCharStorage) +c_newWithMapping = const c_newWithMapping_ + +-- | c_newWithData : data size -> THStorage * +foreign import ccall "THStorage.h THCharStorage_newWithData" + c_newWithData_ :: Ptr CChar -> CPtrdiff -> IO (Ptr C'THCharStorage) + +-- | alias of c_newWithData_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithData :: Ptr C'THState -> Ptr CChar -> CPtrdiff -> IO (Ptr C'THCharStorage) +c_newWithData = const c_newWithData_ + +-- | c_newWithAllocator : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THCharStorage_newWithAllocator" + c_newWithAllocator_ :: CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THCharStorage) + +-- | alias of c_newWithAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithAllocator :: Ptr C'THState -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THCharStorage) +c_newWithAllocator = const c_newWithAllocator_ + +-- | c_newWithDataAndAllocator : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THCharStorage_newWithDataAndAllocator" + c_newWithDataAndAllocator_ :: Ptr CChar -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THCharStorage) + +-- | alias of c_newWithDataAndAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithDataAndAllocator :: Ptr C'THState -> Ptr CChar -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THCharStorage) +c_newWithDataAndAllocator = const c_newWithDataAndAllocator_ + +-- | c_setFlag : storage flag -> void +foreign import ccall "THStorage.h THCharStorage_setFlag" + c_setFlag_ :: Ptr C'THCharStorage -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THCharStorage -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : storage flag -> void +foreign import ccall "THStorage.h THCharStorage_clearFlag" + c_clearFlag_ :: Ptr C'THCharStorage -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THCharStorage -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_retain : storage -> void +foreign import ccall "THStorage.h THCharStorage_retain" + c_retain_ :: Ptr C'THCharStorage -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THCharStorage -> IO () +c_retain = const c_retain_ + +-- | c_swap : storage1 storage2 -> void +foreign import ccall "THStorage.h THCharStorage_swap" + c_swap_ :: Ptr C'THCharStorage -> Ptr C'THCharStorage -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THCharStorage -> IO () +c_swap = const c_swap_ + +-- | c_free : storage -> void +foreign import ccall "THStorage.h THCharStorage_free" + c_free_ :: Ptr C'THCharStorage -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THCharStorage -> IO () +c_free = const c_free_ + +-- | c_resize : storage size -> void +foreign import ccall "THStorage.h THCharStorage_resize" + c_resize_ :: Ptr C'THCharStorage -> CPtrdiff -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THCharStorage -> CPtrdiff -> IO () +c_resize = const c_resize_ + +-- | c_fill : storage value -> void +foreign import ccall "THStorage.h THCharStorage_fill" + c_fill_ :: Ptr C'THCharStorage -> CChar -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THCharStorage -> CChar -> IO () +c_fill = const c_fill_ + +-- | p_data : Pointer to function : -> real * +foreign import ccall "THStorage.h &THCharStorage_data" + p_data :: FunPtr (Ptr C'THCharStorage -> IO (Ptr CChar)) + +-- | p_size : Pointer to function : -> ptrdiff_t +foreign import ccall "THStorage.h &THCharStorage_size" + p_size :: FunPtr (Ptr C'THCharStorage -> IO CPtrdiff) + +-- | p_set : Pointer to function : -> void +foreign import ccall "THStorage.h &THCharStorage_set" + p_set :: FunPtr (Ptr C'THCharStorage -> CPtrdiff -> CChar -> IO ()) + +-- | p_get : Pointer to function : -> real +foreign import ccall "THStorage.h &THCharStorage_get" + p_get :: FunPtr (Ptr C'THCharStorage -> CPtrdiff -> IO CChar) + +-- | p_new : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_new" + p_new :: FunPtr (IO (Ptr C'THCharStorage)) + +-- | p_newWithSize : Pointer to function : size -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_newWithSize" + p_newWithSize :: FunPtr (CPtrdiff -> IO (Ptr C'THCharStorage)) + +-- | p_newWithSize1 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_newWithSize1" + p_newWithSize1 :: FunPtr (CChar -> IO (Ptr C'THCharStorage)) + +-- | p_newWithSize2 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_newWithSize2" + p_newWithSize2 :: FunPtr (CChar -> CChar -> IO (Ptr C'THCharStorage)) + +-- | p_newWithSize3 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_newWithSize3" + p_newWithSize3 :: FunPtr (CChar -> CChar -> CChar -> IO (Ptr C'THCharStorage)) + +-- | p_newWithSize4 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_newWithSize4" + p_newWithSize4 :: FunPtr (CChar -> CChar -> CChar -> CChar -> IO (Ptr C'THCharStorage)) + +-- | p_newWithMapping : Pointer to function : filename size flags -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_newWithMapping" + p_newWithMapping :: FunPtr (Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THCharStorage)) + +-- | p_newWithData : Pointer to function : data size -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_newWithData" + p_newWithData :: FunPtr (Ptr CChar -> CPtrdiff -> IO (Ptr C'THCharStorage)) + +-- | p_newWithAllocator : Pointer to function : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_newWithAllocator" + p_newWithAllocator :: FunPtr (CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THCharStorage)) + +-- | p_newWithDataAndAllocator : Pointer to function : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THCharStorage_newWithDataAndAllocator" + p_newWithDataAndAllocator :: FunPtr (Ptr CChar -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THCharStorage)) + +-- | p_setFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THCharStorage_setFlag" + p_setFlag :: FunPtr (Ptr C'THCharStorage -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THCharStorage_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THCharStorage -> CChar -> IO ()) + +-- | p_retain : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THCharStorage_retain" + p_retain :: FunPtr (Ptr C'THCharStorage -> IO ()) + +-- | p_swap : Pointer to function : storage1 storage2 -> void +foreign import ccall "THStorage.h &THCharStorage_swap" + p_swap :: FunPtr (Ptr C'THCharStorage -> Ptr C'THCharStorage -> IO ()) + +-- | p_free : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THCharStorage_free" + p_free :: FunPtr (Ptr C'THCharStorage -> IO ()) + +-- | p_resize : Pointer to function : storage size -> void +foreign import ccall "THStorage.h &THCharStorage_resize" + p_resize :: FunPtr (Ptr C'THCharStorage -> CPtrdiff -> IO ()) + +-- | p_fill : Pointer to function : storage value -> void +foreign import ccall "THStorage.h &THCharStorage_fill" + p_fill :: FunPtr (Ptr C'THCharStorage -> CChar -> IO ()) diff --git a/src/Torch/FFI/TH/Char/StorageCopy.hs b/src/Torch/FFI/TH/Char/StorageCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Char/StorageCopy.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.StorageCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_rawCopy : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_rawCopy" + c_rawCopy_ :: Ptr C'THCharStorage -> Ptr CChar -> IO () + +-- | alias of c_rawCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_rawCopy :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr CChar -> IO () +c_rawCopy = const c_rawCopy_ + +-- | c_copy : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_copy" + c_copy_ :: Ptr C'THCharStorage -> Ptr C'THCharStorage -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THCharStorage -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_copyByte" + c_copyByte_ :: Ptr C'THCharStorage -> Ptr C'THByteStorage -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THByteStorage -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_copyChar" + c_copyChar_ :: Ptr C'THCharStorage -> Ptr C'THCharStorage -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THCharStorage -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_copyShort" + c_copyShort_ :: Ptr C'THCharStorage -> Ptr C'THShortStorage -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THShortStorage -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_copyInt" + c_copyInt_ :: Ptr C'THCharStorage -> Ptr C'THIntStorage -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THIntStorage -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_copyLong" + c_copyLong_ :: Ptr C'THCharStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THLongStorage -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_copyFloat" + c_copyFloat_ :: Ptr C'THCharStorage -> Ptr C'THFloatStorage -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THFloatStorage -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_copyDouble" + c_copyDouble_ :: Ptr C'THCharStorage -> Ptr C'THDoubleStorage -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THDoubleStorage -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : storage src -> void +foreign import ccall "THStorageCopy.h THCharStorage_copyHalf" + c_copyHalf_ :: Ptr C'THCharStorage -> Ptr C'THHalfStorage -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THCharStorage -> Ptr C'THHalfStorage -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_rawCopy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_rawCopy" + p_rawCopy :: FunPtr (Ptr C'THCharStorage -> Ptr CChar -> IO ()) + +-- | p_copy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_copy" + p_copy :: FunPtr (Ptr C'THCharStorage -> Ptr C'THCharStorage -> IO ()) + +-- | p_copyByte : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_copyByte" + p_copyByte :: FunPtr (Ptr C'THCharStorage -> Ptr C'THByteStorage -> IO ()) + +-- | p_copyChar : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_copyChar" + p_copyChar :: FunPtr (Ptr C'THCharStorage -> Ptr C'THCharStorage -> IO ()) + +-- | p_copyShort : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_copyShort" + p_copyShort :: FunPtr (Ptr C'THCharStorage -> Ptr C'THShortStorage -> IO ()) + +-- | p_copyInt : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_copyInt" + p_copyInt :: FunPtr (Ptr C'THCharStorage -> Ptr C'THIntStorage -> IO ()) + +-- | p_copyLong : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_copyLong" + p_copyLong :: FunPtr (Ptr C'THCharStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_copyFloat : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THCharStorage -> Ptr C'THFloatStorage -> IO ()) + +-- | p_copyDouble : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THCharStorage -> Ptr C'THDoubleStorage -> IO ()) + +-- | p_copyHalf : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THCharStorage_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THCharStorage -> Ptr C'THHalfStorage -> IO ()) diff --git a/src/Torch/FFI/TH/Char/Tensor.hs b/src/Torch/FFI/TH/Char/Tensor.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Char/Tensor.hs @@ -0,0 +1,872 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.Tensor where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_storage : self -> THStorage * +foreign import ccall "THTensor.h THCharTensor_storage" + c_storage_ :: Ptr C'THCharTensor -> IO (Ptr C'THCharStorage) + +-- | alias of c_storage_ with unused argument (for CTHState) to unify backpack signatures. +c_storage :: Ptr C'THState -> Ptr C'THCharTensor -> IO (Ptr C'THCharStorage) +c_storage = const c_storage_ + +-- | c_storageOffset : self -> ptrdiff_t +foreign import ccall "THTensor.h THCharTensor_storageOffset" + c_storageOffset_ :: Ptr C'THCharTensor -> IO CPtrdiff + +-- | alias of c_storageOffset_ with unused argument (for CTHState) to unify backpack signatures. +c_storageOffset :: Ptr C'THState -> Ptr C'THCharTensor -> IO CPtrdiff +c_storageOffset = const c_storageOffset_ + +-- | c_nDimension : self -> int +foreign import ccall "THTensor.h THCharTensor_nDimension" + c_nDimension_ :: Ptr C'THCharTensor -> IO CInt + +-- | alias of c_nDimension_ with unused argument (for CTHState) to unify backpack signatures. +c_nDimension :: Ptr C'THState -> Ptr C'THCharTensor -> IO CInt +c_nDimension = const c_nDimension_ + +-- | c_size : self dim -> int64_t +foreign import ccall "THTensor.h THCharTensor_size" + c_size_ :: Ptr C'THCharTensor -> CInt -> IO CLLong + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> IO CLLong +c_size = const c_size_ + +-- | c_stride : self dim -> int64_t +foreign import ccall "THTensor.h THCharTensor_stride" + c_stride_ :: Ptr C'THCharTensor -> CInt -> IO CLLong + +-- | alias of c_stride_ with unused argument (for CTHState) to unify backpack signatures. +c_stride :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> IO CLLong +c_stride = const c_stride_ + +-- | c_newSizeOf : self -> THLongStorage * +foreign import ccall "THTensor.h THCharTensor_newSizeOf" + c_newSizeOf_ :: Ptr C'THCharTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newSizeOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newSizeOf :: Ptr C'THState -> Ptr C'THCharTensor -> IO (Ptr C'THLongStorage) +c_newSizeOf = const c_newSizeOf_ + +-- | c_newStrideOf : self -> THLongStorage * +foreign import ccall "THTensor.h THCharTensor_newStrideOf" + c_newStrideOf_ :: Ptr C'THCharTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newStrideOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newStrideOf :: Ptr C'THState -> Ptr C'THCharTensor -> IO (Ptr C'THLongStorage) +c_newStrideOf = const c_newStrideOf_ + +-- | c_data : self -> real * +foreign import ccall "THTensor.h THCharTensor_data" + c_data_ :: Ptr C'THCharTensor -> IO (Ptr CChar) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THCharTensor -> IO (Ptr CChar) +c_data = const c_data_ + +-- | c_setFlag : self flag -> void +foreign import ccall "THTensor.h THCharTensor_setFlag" + c_setFlag_ :: Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : self flag -> void +foreign import ccall "THTensor.h THCharTensor_clearFlag" + c_clearFlag_ :: Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_new : -> THTensor * +foreign import ccall "THTensor.h THCharTensor_new" + c_new_ :: IO (Ptr C'THCharTensor) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THCharTensor) +c_new = const c_new_ + +-- | c_newWithTensor : tensor -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithTensor" + c_newWithTensor_ :: Ptr C'THCharTensor -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithTensor :: Ptr C'THState -> Ptr C'THCharTensor -> IO (Ptr C'THCharTensor) +c_newWithTensor = const c_newWithTensor_ + +-- | c_newWithStorage : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithStorage" + c_newWithStorage_ :: Ptr C'THCharStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage :: Ptr C'THState -> Ptr C'THCharStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor) +c_newWithStorage = const c_newWithStorage_ + +-- | c_newWithStorage1d : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithStorage1d" + c_newWithStorage1d_ :: Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage1d :: Ptr C'THState -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) +c_newWithStorage1d = const c_newWithStorage1d_ + +-- | c_newWithStorage2d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithStorage2d" + c_newWithStorage2d_ :: Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage2d :: Ptr C'THState -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) +c_newWithStorage2d = const c_newWithStorage2d_ + +-- | c_newWithStorage3d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithStorage3d" + c_newWithStorage3d_ :: Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage3d :: Ptr C'THState -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) +c_newWithStorage3d = const c_newWithStorage3d_ + +-- | c_newWithStorage4d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithStorage4d" + c_newWithStorage4d_ :: Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage4d :: Ptr C'THState -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) +c_newWithStorage4d = const c_newWithStorage4d_ + +-- | c_newWithSize : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithSize" + c_newWithSize_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1d : size0_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithSize1d" + c_newWithSize1d_ :: CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithSize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1d :: Ptr C'THState -> CLLong -> IO (Ptr C'THCharTensor) +c_newWithSize1d = const c_newWithSize1d_ + +-- | c_newWithSize2d : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithSize2d" + c_newWithSize2d_ :: CLLong -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithSize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2d :: Ptr C'THState -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) +c_newWithSize2d = const c_newWithSize2d_ + +-- | c_newWithSize3d : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithSize3d" + c_newWithSize3d_ :: CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithSize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) +c_newWithSize3d = const c_newWithSize3d_ + +-- | c_newWithSize4d : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newWithSize4d" + c_newWithSize4d_ :: CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newWithSize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) +c_newWithSize4d = const c_newWithSize4d_ + +-- | c_newClone : self -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newClone" + c_newClone_ :: Ptr C'THCharTensor -> IO (Ptr C'THCharTensor) + +-- | alias of c_newClone_ with unused argument (for CTHState) to unify backpack signatures. +c_newClone :: Ptr C'THState -> Ptr C'THCharTensor -> IO (Ptr C'THCharTensor) +c_newClone = const c_newClone_ + +-- | c_newContiguous : tensor -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newContiguous" + c_newContiguous_ :: Ptr C'THCharTensor -> IO (Ptr C'THCharTensor) + +-- | alias of c_newContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_newContiguous :: Ptr C'THState -> Ptr C'THCharTensor -> IO (Ptr C'THCharTensor) +c_newContiguous = const c_newContiguous_ + +-- | c_newSelect : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newSelect" + c_newSelect_ :: Ptr C'THCharTensor -> CInt -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_newSelect :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> CLLong -> IO (Ptr C'THCharTensor) +c_newSelect = const c_newSelect_ + +-- | c_newNarrow : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newNarrow" + c_newNarrow_ :: Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newNarrow_ with unused argument (for CTHState) to unify backpack signatures. +c_newNarrow :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) +c_newNarrow = const c_newNarrow_ + +-- | c_newTranspose : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newTranspose" + c_newTranspose_ :: Ptr C'THCharTensor -> CInt -> CInt -> IO (Ptr C'THCharTensor) + +-- | alias of c_newTranspose_ with unused argument (for CTHState) to unify backpack signatures. +c_newTranspose :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> CInt -> IO (Ptr C'THCharTensor) +c_newTranspose = const c_newTranspose_ + +-- | c_newUnfold : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newUnfold" + c_newUnfold_ :: Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) + +-- | alias of c_newUnfold_ with unused argument (for CTHState) to unify backpack signatures. +c_newUnfold :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THCharTensor) +c_newUnfold = const c_newUnfold_ + +-- | c_newView : tensor size -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newView" + c_newView_ :: Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor) + +-- | alias of c_newView_ with unused argument (for CTHState) to unify backpack signatures. +c_newView :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor) +c_newView = const c_newView_ + +-- | c_newExpand : tensor size -> THTensor * +foreign import ccall "THTensor.h THCharTensor_newExpand" + c_newExpand_ :: Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor) + +-- | alias of c_newExpand_ with unused argument (for CTHState) to unify backpack signatures. +c_newExpand :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor) +c_newExpand = const c_newExpand_ + +-- | c_expand : r tensor size -> void +foreign import ccall "THTensor.h THCharTensor_expand" + c_expand_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_expand_ with unused argument (for CTHState) to unify backpack signatures. +c_expand :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO () +c_expand = const c_expand_ + +-- | c_expandNd : rets ops count -> void +foreign import ccall "THTensor.h THCharTensor_expandNd" + c_expandNd_ :: Ptr (Ptr C'THCharTensor) -> Ptr (Ptr C'THCharTensor) -> CInt -> IO () + +-- | alias of c_expandNd_ with unused argument (for CTHState) to unify backpack signatures. +c_expandNd :: Ptr C'THState -> Ptr (Ptr C'THCharTensor) -> Ptr (Ptr C'THCharTensor) -> CInt -> IO () +c_expandNd = const c_expandNd_ + +-- | c_resize : tensor size stride -> void +foreign import ccall "THTensor.h THCharTensor_resize" + c_resize_ :: Ptr C'THCharTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_resize = const c_resize_ + +-- | c_resizeAs : tensor src -> void +foreign import ccall "THTensor.h THCharTensor_resizeAs" + c_resizeAs_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_resizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeAs :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_resizeAs = const c_resizeAs_ + +-- | c_resizeNd : tensor nDimension size stride -> void +foreign import ccall "THTensor.h THCharTensor_resizeNd" + c_resizeNd_ :: Ptr C'THCharTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_resizeNd_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeNd :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_resizeNd = const c_resizeNd_ + +-- | c_resize1d : tensor size0_ -> void +foreign import ccall "THTensor.h THCharTensor_resize1d" + c_resize1d_ :: Ptr C'THCharTensor -> CLLong -> IO () + +-- | alias of c_resize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize1d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> IO () +c_resize1d = const c_resize1d_ + +-- | c_resize2d : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h THCharTensor_resize2d" + c_resize2d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_resize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize2d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> IO () +c_resize2d = const c_resize2d_ + +-- | c_resize3d : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h THCharTensor_resize3d" + c_resize3d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize3d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> IO () +c_resize3d = const c_resize3d_ + +-- | c_resize4d : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h THCharTensor_resize4d" + c_resize4d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize4d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize4d = const c_resize4d_ + +-- | c_resize5d : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h THCharTensor_resize5d" + c_resize5d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize5d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize5d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize5d = const c_resize5d_ + +-- | c_set : self src -> void +foreign import ccall "THTensor.h THCharTensor_set" + c_set_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_set = const c_set_ + +-- | c_setStorage : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h THCharTensor_setStorage" + c_setStorage_ :: Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_setStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_setStorage = const c_setStorage_ + +-- | c_setStorageNd : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h THCharTensor_setStorageNd" + c_setStorageNd_ :: Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_setStorageNd_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorageNd :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_setStorageNd = const c_setStorageNd_ + +-- | c_setStorage1d : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h THCharTensor_setStorage1d" + c_setStorage1d_ :: Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage1d :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> IO () +c_setStorage1d = const c_setStorage1d_ + +-- | c_setStorage2d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h THCharTensor_setStorage2d" + c_setStorage2d_ :: Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage2d :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage2d = const c_setStorage2d_ + +-- | c_setStorage3d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h THCharTensor_setStorage3d" + c_setStorage3d_ :: Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage3d :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage3d = const c_setStorage3d_ + +-- | c_setStorage4d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h THCharTensor_setStorage4d" + c_setStorage4d_ :: Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage4d :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage4d = const c_setStorage4d_ + +-- | c_narrow : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h THCharTensor_narrow" + c_narrow_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_narrow_ with unused argument (for CTHState) to unify backpack signatures. +c_narrow :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO () +c_narrow = const c_narrow_ + +-- | c_select : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h THCharTensor_select" + c_select_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CLLong -> IO () + +-- | alias of c_select_ with unused argument (for CTHState) to unify backpack signatures. +c_select :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CLLong -> IO () +c_select = const c_select_ + +-- | c_transpose : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h THCharTensor_transpose" + c_transpose_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () + +-- | alias of c_transpose_ with unused argument (for CTHState) to unify backpack signatures. +c_transpose :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () +c_transpose = const c_transpose_ + +-- | c_unfold : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h THCharTensor_unfold" + c_unfold_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_unfold_ with unused argument (for CTHState) to unify backpack signatures. +c_unfold :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO () +c_unfold = const c_unfold_ + +-- | c_squeeze : self src -> void +foreign import ccall "THTensor.h THCharTensor_squeeze" + c_squeeze_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_squeeze_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_squeeze = const c_squeeze_ + +-- | c_squeeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THCharTensor_squeeze1d" + c_squeeze1d_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () + +-- | alias of c_squeeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze1d :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () +c_squeeze1d = const c_squeeze1d_ + +-- | c_unsqueeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THCharTensor_unsqueeze1d" + c_unsqueeze1d_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () + +-- | alias of c_unsqueeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_unsqueeze1d :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () +c_unsqueeze1d = const c_unsqueeze1d_ + +-- | c_isContiguous : self -> int +foreign import ccall "THTensor.h THCharTensor_isContiguous" + c_isContiguous_ :: Ptr C'THCharTensor -> IO CInt + +-- | alias of c_isContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_isContiguous :: Ptr C'THState -> Ptr C'THCharTensor -> IO CInt +c_isContiguous = const c_isContiguous_ + +-- | c_isSameSizeAs : self src -> int +foreign import ccall "THTensor.h THCharTensor_isSameSizeAs" + c_isSameSizeAs_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CInt + +-- | alias of c_isSameSizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_isSameSizeAs :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CInt +c_isSameSizeAs = const c_isSameSizeAs_ + +-- | c_isSetTo : self src -> int +foreign import ccall "THTensor.h THCharTensor_isSetTo" + c_isSetTo_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CInt + +-- | alias of c_isSetTo_ with unused argument (for CTHState) to unify backpack signatures. +c_isSetTo :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CInt +c_isSetTo = const c_isSetTo_ + +-- | c_isSize : self dims -> int +foreign import ccall "THTensor.h THCharTensor_isSize" + c_isSize_ :: Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO CInt + +-- | alias of c_isSize_ with unused argument (for CTHState) to unify backpack signatures. +c_isSize :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO CInt +c_isSize = const c_isSize_ + +-- | c_nElement : self -> ptrdiff_t +foreign import ccall "THTensor.h THCharTensor_nElement" + c_nElement_ :: Ptr C'THCharTensor -> IO CPtrdiff + +-- | alias of c_nElement_ with unused argument (for CTHState) to unify backpack signatures. +c_nElement :: Ptr C'THState -> Ptr C'THCharTensor -> IO CPtrdiff +c_nElement = const c_nElement_ + +-- | c_retain : self -> void +foreign import ccall "THTensor.h THCharTensor_retain" + c_retain_ :: Ptr C'THCharTensor -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THCharTensor -> IO () +c_retain = const c_retain_ + +-- | c_free : self -> void +foreign import ccall "THTensor.h THCharTensor_free" + c_free_ :: Ptr C'THCharTensor -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THCharTensor -> IO () +c_free = const c_free_ + +-- | c_freeCopyTo : self dst -> void +foreign import ccall "THTensor.h THCharTensor_freeCopyTo" + c_freeCopyTo_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_freeCopyTo_ with unused argument (for CTHState) to unify backpack signatures. +c_freeCopyTo :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_freeCopyTo = const c_freeCopyTo_ + +-- | c_set1d : tensor x0 value -> void +foreign import ccall "THTensor.h THCharTensor_set1d" + c_set1d_ :: Ptr C'THCharTensor -> CLLong -> CChar -> IO () + +-- | alias of c_set1d_ with unused argument (for CTHState) to unify backpack signatures. +c_set1d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CChar -> IO () +c_set1d = const c_set1d_ + +-- | c_set2d : tensor x0 x1 value -> void +foreign import ccall "THTensor.h THCharTensor_set2d" + c_set2d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> CChar -> IO () + +-- | alias of c_set2d_ with unused argument (for CTHState) to unify backpack signatures. +c_set2d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> CChar -> IO () +c_set2d = const c_set2d_ + +-- | c_set3d : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h THCharTensor_set3d" + c_set3d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CChar -> IO () + +-- | alias of c_set3d_ with unused argument (for CTHState) to unify backpack signatures. +c_set3d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CChar -> IO () +c_set3d = const c_set3d_ + +-- | c_set4d : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h THCharTensor_set4d" + c_set4d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CChar -> IO () + +-- | alias of c_set4d_ with unused argument (for CTHState) to unify backpack signatures. +c_set4d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CChar -> IO () +c_set4d = const c_set4d_ + +-- | c_get1d : tensor x0 -> real +foreign import ccall "THTensor.h THCharTensor_get1d" + c_get1d_ :: Ptr C'THCharTensor -> CLLong -> IO CChar + +-- | alias of c_get1d_ with unused argument (for CTHState) to unify backpack signatures. +c_get1d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> IO CChar +c_get1d = const c_get1d_ + +-- | c_get2d : tensor x0 x1 -> real +foreign import ccall "THTensor.h THCharTensor_get2d" + c_get2d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> IO CChar + +-- | alias of c_get2d_ with unused argument (for CTHState) to unify backpack signatures. +c_get2d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> IO CChar +c_get2d = const c_get2d_ + +-- | c_get3d : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h THCharTensor_get3d" + c_get3d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> IO CChar + +-- | alias of c_get3d_ with unused argument (for CTHState) to unify backpack signatures. +c_get3d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> IO CChar +c_get3d = const c_get3d_ + +-- | c_get4d : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h THCharTensor_get4d" + c_get4d_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CChar + +-- | alias of c_get4d_ with unused argument (for CTHState) to unify backpack signatures. +c_get4d :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CChar +c_get4d = const c_get4d_ + +-- | c_desc : tensor -> THDescBuff +foreign import ccall "THTensor.h THCharTensor_desc" + c_desc_ :: Ptr C'THCharTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_desc_ with unused argument (for CTHState) to unify backpack signatures. +c_desc :: Ptr C'THState -> Ptr C'THCharTensor -> IO (Ptr C'THDescBuff) +c_desc = const c_desc_ + +-- | c_sizeDesc : tensor -> THDescBuff +foreign import ccall "THTensor.h THCharTensor_sizeDesc" + c_sizeDesc_ :: Ptr C'THCharTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_sizeDesc_ with unused argument (for CTHState) to unify backpack signatures. +c_sizeDesc :: Ptr C'THState -> Ptr C'THCharTensor -> IO (Ptr C'THDescBuff) +c_sizeDesc = const c_sizeDesc_ + +-- | p_storage : Pointer to function : self -> THStorage * +foreign import ccall "THTensor.h &THCharTensor_storage" + p_storage :: FunPtr (Ptr C'THCharTensor -> IO (Ptr C'THCharStorage)) + +-- | p_storageOffset : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THCharTensor_storageOffset" + p_storageOffset :: FunPtr (Ptr C'THCharTensor -> IO CPtrdiff) + +-- | p_nDimension : Pointer to function : self -> int +foreign import ccall "THTensor.h &THCharTensor_nDimension" + p_nDimension :: FunPtr (Ptr C'THCharTensor -> IO CInt) + +-- | p_size : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THCharTensor_size" + p_size :: FunPtr (Ptr C'THCharTensor -> CInt -> IO CLLong) + +-- | p_stride : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THCharTensor_stride" + p_stride :: FunPtr (Ptr C'THCharTensor -> CInt -> IO CLLong) + +-- | p_newSizeOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THCharTensor_newSizeOf" + p_newSizeOf :: FunPtr (Ptr C'THCharTensor -> IO (Ptr C'THLongStorage)) + +-- | p_newStrideOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THCharTensor_newStrideOf" + p_newStrideOf :: FunPtr (Ptr C'THCharTensor -> IO (Ptr C'THLongStorage)) + +-- | p_data : Pointer to function : self -> real * +foreign import ccall "THTensor.h &THCharTensor_data" + p_data :: FunPtr (Ptr C'THCharTensor -> IO (Ptr CChar)) + +-- | p_setFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THCharTensor_setFlag" + p_setFlag :: FunPtr (Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THCharTensor_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_new : Pointer to function : -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_new" + p_new :: FunPtr (IO (Ptr C'THCharTensor)) + +-- | p_newWithTensor : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithTensor" + p_newWithTensor :: FunPtr (Ptr C'THCharTensor -> IO (Ptr C'THCharTensor)) + +-- | p_newWithStorage : Pointer to function : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithStorage" + p_newWithStorage :: FunPtr (Ptr C'THCharStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor)) + +-- | p_newWithStorage1d : Pointer to function : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithStorage1d" + p_newWithStorage1d :: FunPtr (Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newWithStorage2d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithStorage2d" + p_newWithStorage2d :: FunPtr (Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newWithStorage3d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithStorage3d" + p_newWithStorage3d :: FunPtr (Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newWithStorage4d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithStorage4d" + p_newWithStorage4d :: FunPtr (Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newWithSize : Pointer to function : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithSize" + p_newWithSize :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor)) + +-- | p_newWithSize1d : Pointer to function : size0_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithSize1d" + p_newWithSize1d :: FunPtr (CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newWithSize2d : Pointer to function : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithSize2d" + p_newWithSize2d :: FunPtr (CLLong -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newWithSize3d : Pointer to function : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithSize3d" + p_newWithSize3d :: FunPtr (CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newWithSize4d : Pointer to function : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newWithSize4d" + p_newWithSize4d :: FunPtr (CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newClone : Pointer to function : self -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newClone" + p_newClone :: FunPtr (Ptr C'THCharTensor -> IO (Ptr C'THCharTensor)) + +-- | p_newContiguous : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newContiguous" + p_newContiguous :: FunPtr (Ptr C'THCharTensor -> IO (Ptr C'THCharTensor)) + +-- | p_newSelect : Pointer to function : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newSelect" + p_newSelect :: FunPtr (Ptr C'THCharTensor -> CInt -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newNarrow : Pointer to function : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newNarrow" + p_newNarrow :: FunPtr (Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newTranspose : Pointer to function : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newTranspose" + p_newTranspose :: FunPtr (Ptr C'THCharTensor -> CInt -> CInt -> IO (Ptr C'THCharTensor)) + +-- | p_newUnfold : Pointer to function : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newUnfold" + p_newUnfold :: FunPtr (Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THCharTensor)) + +-- | p_newView : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newView" + p_newView :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor)) + +-- | p_newExpand : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THCharTensor_newExpand" + p_newExpand :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO (Ptr C'THCharTensor)) + +-- | p_expand : Pointer to function : r tensor size -> void +foreign import ccall "THTensor.h &THCharTensor_expand" + p_expand :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_expandNd : Pointer to function : rets ops count -> void +foreign import ccall "THTensor.h &THCharTensor_expandNd" + p_expandNd :: FunPtr (Ptr (Ptr C'THCharTensor) -> Ptr (Ptr C'THCharTensor) -> CInt -> IO ()) + +-- | p_resize : Pointer to function : tensor size stride -> void +foreign import ccall "THTensor.h &THCharTensor_resize" + p_resize :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_resizeAs : Pointer to function : tensor src -> void +foreign import ccall "THTensor.h &THCharTensor_resizeAs" + p_resizeAs :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_resizeNd : Pointer to function : tensor nDimension size stride -> void +foreign import ccall "THTensor.h &THCharTensor_resizeNd" + p_resizeNd :: FunPtr (Ptr C'THCharTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_resize1d : Pointer to function : tensor size0_ -> void +foreign import ccall "THTensor.h &THCharTensor_resize1d" + p_resize1d :: FunPtr (Ptr C'THCharTensor -> CLLong -> IO ()) + +-- | p_resize2d : Pointer to function : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h &THCharTensor_resize2d" + p_resize2d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> IO ()) + +-- | p_resize3d : Pointer to function : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h &THCharTensor_resize3d" + p_resize3d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize4d : Pointer to function : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h &THCharTensor_resize4d" + p_resize4d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize5d : Pointer to function : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h &THCharTensor_resize5d" + p_resize5d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_set : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THCharTensor_set" + p_set :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_setStorage : Pointer to function : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h &THCharTensor_setStorage" + p_setStorage :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_setStorageNd : Pointer to function : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h &THCharTensor_setStorageNd" + p_setStorageNd :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_setStorage1d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h &THCharTensor_setStorage1d" + p_setStorage1d :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage2d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h &THCharTensor_setStorage2d" + p_setStorage2d :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage3d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h &THCharTensor_setStorage3d" + p_setStorage3d :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage4d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h &THCharTensor_setStorage4d" + p_setStorage4d :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_narrow : Pointer to function : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h &THCharTensor_narrow" + p_narrow :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_select : Pointer to function : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h &THCharTensor_select" + p_select :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CLLong -> IO ()) + +-- | p_transpose : Pointer to function : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h &THCharTensor_transpose" + p_transpose :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO ()) + +-- | p_unfold : Pointer to function : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h &THCharTensor_unfold" + p_unfold :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_squeeze : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THCharTensor_squeeze" + p_squeeze :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_squeeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THCharTensor_squeeze1d" + p_squeeze1d :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO ()) + +-- | p_unsqueeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THCharTensor_unsqueeze1d" + p_unsqueeze1d :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO ()) + +-- | p_isContiguous : Pointer to function : self -> int +foreign import ccall "THTensor.h &THCharTensor_isContiguous" + p_isContiguous :: FunPtr (Ptr C'THCharTensor -> IO CInt) + +-- | p_isSameSizeAs : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THCharTensor_isSameSizeAs" + p_isSameSizeAs :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CInt) + +-- | p_isSetTo : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THCharTensor_isSetTo" + p_isSetTo :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CInt) + +-- | p_isSize : Pointer to function : self dims -> int +foreign import ccall "THTensor.h &THCharTensor_isSize" + p_isSize :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO CInt) + +-- | p_nElement : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THCharTensor_nElement" + p_nElement :: FunPtr (Ptr C'THCharTensor -> IO CPtrdiff) + +-- | p_retain : Pointer to function : self -> void +foreign import ccall "THTensor.h &THCharTensor_retain" + p_retain :: FunPtr (Ptr C'THCharTensor -> IO ()) + +-- | p_free : Pointer to function : self -> void +foreign import ccall "THTensor.h &THCharTensor_free" + p_free :: FunPtr (Ptr C'THCharTensor -> IO ()) + +-- | p_freeCopyTo : Pointer to function : self dst -> void +foreign import ccall "THTensor.h &THCharTensor_freeCopyTo" + p_freeCopyTo :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_set1d : Pointer to function : tensor x0 value -> void +foreign import ccall "THTensor.h &THCharTensor_set1d" + p_set1d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CChar -> IO ()) + +-- | p_set2d : Pointer to function : tensor x0 x1 value -> void +foreign import ccall "THTensor.h &THCharTensor_set2d" + p_set2d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> CChar -> IO ()) + +-- | p_set3d : Pointer to function : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h &THCharTensor_set3d" + p_set3d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CChar -> IO ()) + +-- | p_set4d : Pointer to function : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h &THCharTensor_set4d" + p_set4d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CChar -> IO ()) + +-- | p_get1d : Pointer to function : tensor x0 -> real +foreign import ccall "THTensor.h &THCharTensor_get1d" + p_get1d :: FunPtr (Ptr C'THCharTensor -> CLLong -> IO CChar) + +-- | p_get2d : Pointer to function : tensor x0 x1 -> real +foreign import ccall "THTensor.h &THCharTensor_get2d" + p_get2d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> IO CChar) + +-- | p_get3d : Pointer to function : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h &THCharTensor_get3d" + p_get3d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> IO CChar) + +-- | p_get4d : Pointer to function : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h &THCharTensor_get4d" + p_get4d :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CChar) + +-- | p_desc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THCharTensor_desc" + p_desc :: FunPtr (Ptr C'THCharTensor -> IO (Ptr C'THDescBuff)) + +-- | p_sizeDesc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THCharTensor_sizeDesc" + p_sizeDesc :: FunPtr (Ptr C'THCharTensor -> IO (Ptr C'THDescBuff)) diff --git a/src/Torch/FFI/TH/Char/TensorConv.hs b/src/Torch/FFI/TH/Char/TensorConv.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Char/TensorConv.hs @@ -0,0 +1,272 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.TensorConv where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_validXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_validXCorr2Dptr" + c_validXCorr2Dptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2Dptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2Dptr = const c_validXCorr2Dptr_ + +-- | c_validConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_validConv2Dptr" + c_validConv2Dptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv2Dptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv2Dptr = const c_validConv2Dptr_ + +-- | c_fullXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_fullXCorr2Dptr" + c_fullXCorr2Dptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr2Dptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr2Dptr = const c_fullXCorr2Dptr_ + +-- | c_fullConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_fullConv2Dptr" + c_fullConv2Dptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv2Dptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv2Dptr = const c_fullConv2Dptr_ + +-- | c_validXCorr2DRevptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_validXCorr2DRevptr" + c_validXCorr2DRevptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2DRevptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2DRevptr = const c_validXCorr2DRevptr_ + +-- | c_conv2DRevger : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THCharTensor_conv2DRevger" + c_conv2DRevger_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevger :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> IO () +c_conv2DRevger = const c_conv2DRevger_ + +-- | c_conv2DRevgerm : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THCharTensor_conv2DRevgerm" + c_conv2DRevgerm_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevgerm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevgerm :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> IO () +c_conv2DRevgerm = const c_conv2DRevgerm_ + +-- | c_conv2Dger : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THCharTensor_conv2Dger" + c_conv2Dger_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dger :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dger = const c_conv2Dger_ + +-- | c_conv2Dmv : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THCharTensor_conv2Dmv" + c_conv2Dmv_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmv :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmv = const c_conv2Dmv_ + +-- | c_conv2Dmm : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THCharTensor_conv2Dmm" + c_conv2Dmm_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmm :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmm = const c_conv2Dmm_ + +-- | c_conv2Dmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THCharTensor_conv2Dmul" + c_conv2Dmul_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmul :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmul = const c_conv2Dmul_ + +-- | c_conv2Dcmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THCharTensor_conv2Dcmul" + c_conv2Dcmul_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dcmul :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dcmul = const c_conv2Dcmul_ + +-- | c_validXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_validXCorr3Dptr" + c_validXCorr3Dptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3Dptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3Dptr = const c_validXCorr3Dptr_ + +-- | c_validConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_validConv3Dptr" + c_validConv3Dptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv3Dptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv3Dptr = const c_validConv3Dptr_ + +-- | c_fullXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_fullXCorr3Dptr" + c_fullXCorr3Dptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr3Dptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr3Dptr = const c_fullXCorr3Dptr_ + +-- | c_fullConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_fullConv3Dptr" + c_fullConv3Dptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv3Dptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv3Dptr = const c_fullConv3Dptr_ + +-- | c_validXCorr3DRevptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THCharTensor_validXCorr3DRevptr" + c_validXCorr3DRevptr_ :: Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3DRevptr :: Ptr C'THState -> Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3DRevptr = const c_validXCorr3DRevptr_ + +-- | c_conv3DRevger : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h THCharTensor_conv3DRevger" + c_conv3DRevger_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_conv3DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3DRevger :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> IO () +c_conv3DRevger = const c_conv3DRevger_ + +-- | c_conv3Dger : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THCharTensor_conv3Dger" + c_conv3Dger_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dger :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dger = const c_conv3Dger_ + +-- | c_conv3Dmv : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THCharTensor_conv3Dmv" + c_conv3Dmv_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmv :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmv = const c_conv3Dmv_ + +-- | c_conv3Dmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THCharTensor_conv3Dmul" + c_conv3Dmul_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmul :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmul = const c_conv3Dmul_ + +-- | c_conv3Dcmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THCharTensor_conv3Dcmul" + c_conv3Dcmul_ :: Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dcmul :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dcmul = const c_conv3Dcmul_ + +-- | p_validXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_validXCorr2Dptr" + p_validXCorr2Dptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_validConv2Dptr" + p_validConv2Dptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_fullXCorr2Dptr" + p_fullXCorr2Dptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_fullConv2Dptr" + p_fullConv2Dptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr2DRevptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_validXCorr2DRevptr" + p_validXCorr2DRevptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevger : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv2DRevger" + p_conv2DRevger :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevgerm : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv2DRevgerm" + p_conv2DRevgerm :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2Dger : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv2Dger" + p_conv2Dger :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmv : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv2Dmv" + p_conv2Dmv :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmm : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv2Dmm" + p_conv2Dmm :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv2Dmul" + p_conv2Dmul :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dcmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv2Dcmul" + p_conv2Dcmul :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_validXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_validXCorr3Dptr" + p_validXCorr3Dptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_validConv3Dptr" + p_validConv3Dptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_fullXCorr3Dptr" + p_fullXCorr3Dptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_fullConv3Dptr" + p_fullConv3Dptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr3DRevptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THCharTensor_validXCorr3DRevptr" + p_validXCorr3DRevptr :: FunPtr (Ptr CChar -> CChar -> Ptr CChar -> CLLong -> CLLong -> CLLong -> Ptr CChar -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3DRevger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv3DRevger" + p_conv3DRevger :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3Dger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv3Dger" + p_conv3Dger :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmv : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv3Dmv" + p_conv3Dmv :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv3Dmul" + p_conv3Dmul :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dcmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THCharTensor_conv3Dcmul" + p_conv3Dcmul :: FunPtr (Ptr C'THCharTensor -> CChar -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) diff --git a/src/Torch/FFI/TH/Char/TensorCopy.hs b/src/Torch/FFI/TH/Char/TensorCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Char/TensorCopy.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.TensorCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_copy : tensor src -> void +foreign import ccall "THTensorCopy.h THCharTensor_copy" + c_copy_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : tensor src -> void +foreign import ccall "THTensorCopy.h THCharTensor_copyByte" + c_copyByte_ :: Ptr C'THCharTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THByteTensor -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : tensor src -> void +foreign import ccall "THTensorCopy.h THCharTensor_copyChar" + c_copyChar_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : tensor src -> void +foreign import ccall "THTensorCopy.h THCharTensor_copyShort" + c_copyShort_ :: Ptr C'THCharTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THShortTensor -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : tensor src -> void +foreign import ccall "THTensorCopy.h THCharTensor_copyInt" + c_copyInt_ :: Ptr C'THCharTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THIntTensor -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : tensor src -> void +foreign import ccall "THTensorCopy.h THCharTensor_copyLong" + c_copyLong_ :: Ptr C'THCharTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : tensor src -> void +foreign import ccall "THTensorCopy.h THCharTensor_copyFloat" + c_copyFloat_ :: Ptr C'THCharTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THFloatTensor -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : tensor src -> void +foreign import ccall "THTensorCopy.h THCharTensor_copyDouble" + c_copyDouble_ :: Ptr C'THCharTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THDoubleTensor -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : tensor src -> void +foreign import ccall "THTensorCopy.h THCharTensor_copyHalf" + c_copyHalf_ :: Ptr C'THCharTensor -> Ptr C'THHalfTensor -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THHalfTensor -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_copy : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THCharTensor_copy" + p_copy :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_copyByte : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THCharTensor_copyByte" + p_copyByte :: FunPtr (Ptr C'THCharTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_copyChar : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THCharTensor_copyChar" + p_copyChar :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_copyShort : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THCharTensor_copyShort" + p_copyShort :: FunPtr (Ptr C'THCharTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_copyInt : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THCharTensor_copyInt" + p_copyInt :: FunPtr (Ptr C'THCharTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_copyLong : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THCharTensor_copyLong" + p_copyLong :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_copyFloat : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THCharTensor_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THCharTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_copyDouble : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THCharTensor_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THCharTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_copyHalf : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THCharTensor_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THCharTensor -> Ptr C'THHalfTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Char/TensorMath.hs b/src/Torch/FFI/TH/Char/TensorMath.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Char/TensorMath.hs @@ -0,0 +1,1388 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.TensorMath where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : r_ value -> void +foreign import ccall "THTensorMath.h THCharTensor_fill" + c_fill_ :: Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> IO () +c_fill = const c_fill_ + +-- | c_zero : r_ -> void +foreign import ccall "THTensorMath.h THCharTensor_zero" + c_zero_ :: Ptr C'THCharTensor -> IO () + +-- | alias of c_zero_ with unused argument (for CTHState) to unify backpack signatures. +c_zero :: Ptr C'THState -> Ptr C'THCharTensor -> IO () +c_zero = const c_zero_ + +-- | c_maskedFill : tensor mask value -> void +foreign import ccall "THTensorMath.h THCharTensor_maskedFill" + c_maskedFill_ :: Ptr C'THCharTensor -> Ptr C'THByteTensor -> CChar -> IO () + +-- | alias of c_maskedFill_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedFill :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THByteTensor -> CChar -> IO () +c_maskedFill = const c_maskedFill_ + +-- | c_maskedCopy : tensor mask src -> void +foreign import ccall "THTensorMath.h THCharTensor_maskedCopy" + c_maskedCopy_ :: Ptr C'THCharTensor -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_maskedCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedCopy :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> IO () +c_maskedCopy = const c_maskedCopy_ + +-- | c_maskedSelect : tensor src mask -> void +foreign import ccall "THTensorMath.h THCharTensor_maskedSelect" + c_maskedSelect_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_maskedSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedSelect :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THByteTensor -> IO () +c_maskedSelect = const c_maskedSelect_ + +-- | c_nonzero : subscript tensor -> void +foreign import ccall "THTensorMath.h THCharTensor_nonzero" + c_nonzero_ :: Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_nonzero_ with unused argument (for CTHState) to unify backpack signatures. +c_nonzero :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () +c_nonzero = const c_nonzero_ + +-- | c_indexSelect : tensor src dim index -> void +foreign import ccall "THTensorMath.h THCharTensor_indexSelect" + c_indexSelect_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_indexSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_indexSelect :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_indexSelect = const c_indexSelect_ + +-- | c_indexCopy : tensor dim index src -> void +foreign import ccall "THTensorMath.h THCharTensor_indexCopy" + c_indexCopy_ :: Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_indexCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_indexCopy :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () +c_indexCopy = const c_indexCopy_ + +-- | c_indexAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THCharTensor_indexAdd" + c_indexAdd_ :: Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_indexAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_indexAdd :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () +c_indexAdd = const c_indexAdd_ + +-- | c_indexFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THCharTensor_indexFill" + c_indexFill_ :: Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> CChar -> IO () + +-- | alias of c_indexFill_ with unused argument (for CTHState) to unify backpack signatures. +c_indexFill :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> CChar -> IO () +c_indexFill = const c_indexFill_ + +-- | c_take : tensor src index -> void +foreign import ccall "THTensorMath.h THCharTensor_take" + c_take_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_take_ with unused argument (for CTHState) to unify backpack signatures. +c_take :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> IO () +c_take = const c_take_ + +-- | c_put : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h THCharTensor_put" + c_put_ :: Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> IO () + +-- | alias of c_put_ with unused argument (for CTHState) to unify backpack signatures. +c_put :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> IO () +c_put = const c_put_ + +-- | c_gather : tensor src dim index -> void +foreign import ccall "THTensorMath.h THCharTensor_gather" + c_gather_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_gather_ with unused argument (for CTHState) to unify backpack signatures. +c_gather :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_gather = const c_gather_ + +-- | c_scatter : tensor dim index src -> void +foreign import ccall "THTensorMath.h THCharTensor_scatter" + c_scatter_ :: Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_scatter_ with unused argument (for CTHState) to unify backpack signatures. +c_scatter :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () +c_scatter = const c_scatter_ + +-- | c_scatterAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THCharTensor_scatterAdd" + c_scatterAdd_ :: Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_scatterAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterAdd :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () +c_scatterAdd = const c_scatterAdd_ + +-- | c_scatterFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THCharTensor_scatterFill" + c_scatterFill_ :: Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> CChar -> IO () + +-- | alias of c_scatterFill_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterFill :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> CChar -> IO () +c_scatterFill = const c_scatterFill_ + +-- | c_dot : t src -> accreal +foreign import ccall "THTensorMath.h THCharTensor_dot" + c_dot_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CLong + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CLong +c_dot = const c_dot_ + +-- | c_minall : t -> real +foreign import ccall "THTensorMath.h THCharTensor_minall" + c_minall_ :: Ptr C'THCharTensor -> IO CChar + +-- | alias of c_minall_ with unused argument (for CTHState) to unify backpack signatures. +c_minall :: Ptr C'THState -> Ptr C'THCharTensor -> IO CChar +c_minall = const c_minall_ + +-- | c_maxall : t -> real +foreign import ccall "THTensorMath.h THCharTensor_maxall" + c_maxall_ :: Ptr C'THCharTensor -> IO CChar + +-- | alias of c_maxall_ with unused argument (for CTHState) to unify backpack signatures. +c_maxall :: Ptr C'THState -> Ptr C'THCharTensor -> IO CChar +c_maxall = const c_maxall_ + +-- | c_medianall : t -> real +foreign import ccall "THTensorMath.h THCharTensor_medianall" + c_medianall_ :: Ptr C'THCharTensor -> IO CChar + +-- | alias of c_medianall_ with unused argument (for CTHState) to unify backpack signatures. +c_medianall :: Ptr C'THState -> Ptr C'THCharTensor -> IO CChar +c_medianall = const c_medianall_ + +-- | c_sumall : t -> accreal +foreign import ccall "THTensorMath.h THCharTensor_sumall" + c_sumall_ :: Ptr C'THCharTensor -> IO CLong + +-- | alias of c_sumall_ with unused argument (for CTHState) to unify backpack signatures. +c_sumall :: Ptr C'THState -> Ptr C'THCharTensor -> IO CLong +c_sumall = const c_sumall_ + +-- | c_prodall : t -> accreal +foreign import ccall "THTensorMath.h THCharTensor_prodall" + c_prodall_ :: Ptr C'THCharTensor -> IO CLong + +-- | alias of c_prodall_ with unused argument (for CTHState) to unify backpack signatures. +c_prodall :: Ptr C'THState -> Ptr C'THCharTensor -> IO CLong +c_prodall = const c_prodall_ + +-- | c_add : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_add" + c_add_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_add_ with unused argument (for CTHState) to unify backpack signatures. +c_add :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_add = const c_add_ + +-- | c_sub : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_sub" + c_sub_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_sub_ with unused argument (for CTHState) to unify backpack signatures. +c_sub :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_sub = const c_sub_ + +-- | c_add_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THCharTensor_add_scaled" + c_add_scaled_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> CChar -> IO () + +-- | alias of c_add_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_add_scaled :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> CChar -> IO () +c_add_scaled = const c_add_scaled_ + +-- | c_sub_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THCharTensor_sub_scaled" + c_sub_scaled_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> CChar -> IO () + +-- | alias of c_sub_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_sub_scaled :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> CChar -> IO () +c_sub_scaled = const c_sub_scaled_ + +-- | c_mul : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_mul" + c_mul_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_mul_ with unused argument (for CTHState) to unify backpack signatures. +c_mul :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_mul = const c_mul_ + +-- | c_div : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_div" + c_div_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_div_ with unused argument (for CTHState) to unify backpack signatures. +c_div :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_div = const c_div_ + +-- | c_lshift : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_lshift" + c_lshift_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_lshift_ with unused argument (for CTHState) to unify backpack signatures. +c_lshift :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_lshift = const c_lshift_ + +-- | c_rshift : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_rshift" + c_rshift_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_rshift_ with unused argument (for CTHState) to unify backpack signatures. +c_rshift :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_rshift = const c_rshift_ + +-- | c_fmod : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_fmod" + c_fmod_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_fmod_ with unused argument (for CTHState) to unify backpack signatures. +c_fmod :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_fmod = const c_fmod_ + +-- | c_remainder : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_remainder" + c_remainder_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_remainder_ with unused argument (for CTHState) to unify backpack signatures. +c_remainder :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_remainder = const c_remainder_ + +-- | c_clamp : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h THCharTensor_clamp" + c_clamp_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> CChar -> IO () + +-- | alias of c_clamp_ with unused argument (for CTHState) to unify backpack signatures. +c_clamp :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> CChar -> IO () +c_clamp = const c_clamp_ + +-- | c_bitand : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_bitand" + c_bitand_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_bitand_ with unused argument (for CTHState) to unify backpack signatures. +c_bitand :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_bitand = const c_bitand_ + +-- | c_bitor : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_bitor" + c_bitor_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_bitor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitor :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_bitor = const c_bitor_ + +-- | c_bitxor : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_bitxor" + c_bitxor_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_bitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitxor :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_bitxor = const c_bitxor_ + +-- | c_cadd : r_ t value src -> void +foreign import ccall "THTensorMath.h THCharTensor_cadd" + c_cadd_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> IO () +c_cadd = const c_cadd_ + +-- | c_csub : self src1 value src2 -> void +foreign import ccall "THTensorMath.h THCharTensor_csub" + c_csub_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> IO () + +-- | alias of c_csub_ with unused argument (for CTHState) to unify backpack signatures. +c_csub :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> IO () +c_csub = const c_csub_ + +-- | c_cmul : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cmul" + c_cmul_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cmul = const c_cmul_ + +-- | c_cpow : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cpow" + c_cpow_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cpow_ with unused argument (for CTHState) to unify backpack signatures. +c_cpow :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cpow = const c_cpow_ + +-- | c_cdiv : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cdiv" + c_cdiv_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cdiv = const c_cdiv_ + +-- | c_clshift : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_clshift" + c_clshift_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_clshift_ with unused argument (for CTHState) to unify backpack signatures. +c_clshift :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_clshift = const c_clshift_ + +-- | c_crshift : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_crshift" + c_crshift_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_crshift_ with unused argument (for CTHState) to unify backpack signatures. +c_crshift :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_crshift = const c_crshift_ + +-- | c_cfmod : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cfmod" + c_cfmod_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cfmod_ with unused argument (for CTHState) to unify backpack signatures. +c_cfmod :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cfmod = const c_cfmod_ + +-- | c_cremainder : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cremainder" + c_cremainder_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cremainder_ with unused argument (for CTHState) to unify backpack signatures. +c_cremainder :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cremainder = const c_cremainder_ + +-- | c_cbitand : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cbitand" + c_cbitand_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cbitand_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitand :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cbitand = const c_cbitand_ + +-- | c_cbitor : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cbitor" + c_cbitor_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cbitor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitor :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cbitor = const c_cbitor_ + +-- | c_cbitxor : r_ t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cbitxor" + c_cbitxor_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cbitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitxor :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cbitxor = const c_cbitxor_ + +-- | c_addcmul : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THCharTensor_addcmul" + c_addcmul_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_addcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_addcmul :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_addcmul = const c_addcmul_ + +-- | c_addcdiv : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THCharTensor_addcdiv" + c_addcdiv_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_addcdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_addcdiv :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_addcdiv = const c_addcdiv_ + +-- | c_addmv : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h THCharTensor_addmv" + c_addmv_ :: Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_addmv_ with unused argument (for CTHState) to unify backpack signatures. +c_addmv :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_addmv = const c_addmv_ + +-- | c_addmm : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h THCharTensor_addmm" + c_addmm_ :: Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_addmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addmm :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_addmm = const c_addmm_ + +-- | c_addr : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h THCharTensor_addr" + c_addr_ :: Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_addr_ with unused argument (for CTHState) to unify backpack signatures. +c_addr :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_addr = const c_addr_ + +-- | c_addbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THCharTensor_addbmm" + c_addbmm_ :: Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_addbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addbmm :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_addbmm = const c_addbmm_ + +-- | c_baddbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THCharTensor_baddbmm" + c_baddbmm_ :: Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_baddbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_baddbmm :: Ptr C'THState -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_baddbmm = const c_baddbmm_ + +-- | c_match : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h THCharTensor_match" + c_match_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_match_ with unused argument (for CTHState) to unify backpack signatures. +c_match :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_match = const c_match_ + +-- | c_numel : t -> ptrdiff_t +foreign import ccall "THTensorMath.h THCharTensor_numel" + c_numel_ :: Ptr C'THCharTensor -> IO CPtrdiff + +-- | alias of c_numel_ with unused argument (for CTHState) to unify backpack signatures. +c_numel :: Ptr C'THState -> Ptr C'THCharTensor -> IO CPtrdiff +c_numel = const c_numel_ + +-- | c_preserveReduceDimSemantics : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h THCharTensor_preserveReduceDimSemantics" + c_preserveReduceDimSemantics_ :: Ptr C'THCharTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_preserveReduceDimSemantics_ with unused argument (for CTHState) to unify backpack signatures. +c_preserveReduceDimSemantics :: Ptr C'THState -> Ptr C'THCharTensor -> CInt -> CInt -> CInt -> IO () +c_preserveReduceDimSemantics = const c_preserveReduceDimSemantics_ + +-- | c_max : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THCharTensor_max" + c_max_ :: Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () + +-- | alias of c_max_ with unused argument (for CTHState) to unify backpack signatures. +c_max :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () +c_max = const c_max_ + +-- | c_min : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THCharTensor_min" + c_min_ :: Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () + +-- | alias of c_min_ with unused argument (for CTHState) to unify backpack signatures. +c_min :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () +c_min = const c_min_ + +-- | c_kthvalue : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h THCharTensor_kthvalue" + c_kthvalue_ :: Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CLLong -> CInt -> CInt -> IO () + +-- | alias of c_kthvalue_ with unused argument (for CTHState) to unify backpack signatures. +c_kthvalue :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CLLong -> CInt -> CInt -> IO () +c_kthvalue = const c_kthvalue_ + +-- | c_mode : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THCharTensor_mode" + c_mode_ :: Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () + +-- | alias of c_mode_ with unused argument (for CTHState) to unify backpack signatures. +c_mode :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () +c_mode = const c_mode_ + +-- | c_median : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THCharTensor_median" + c_median_ :: Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () + +-- | alias of c_median_ with unused argument (for CTHState) to unify backpack signatures. +c_median :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () +c_median = const c_median_ + +-- | c_sum : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THCharTensor_sum" + c_sum_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () + +-- | alias of c_sum_ with unused argument (for CTHState) to unify backpack signatures. +c_sum :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () +c_sum = const c_sum_ + +-- | c_prod : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THCharTensor_prod" + c_prod_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () + +-- | alias of c_prod_ with unused argument (for CTHState) to unify backpack signatures. +c_prod :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () +c_prod = const c_prod_ + +-- | c_cumsum : r_ t dimension -> void +foreign import ccall "THTensorMath.h THCharTensor_cumsum" + c_cumsum_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () + +-- | alias of c_cumsum_ with unused argument (for CTHState) to unify backpack signatures. +c_cumsum :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () +c_cumsum = const c_cumsum_ + +-- | c_cumprod : r_ t dimension -> void +foreign import ccall "THTensorMath.h THCharTensor_cumprod" + c_cumprod_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () + +-- | alias of c_cumprod_ with unused argument (for CTHState) to unify backpack signatures. +c_cumprod :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () +c_cumprod = const c_cumprod_ + +-- | c_sign : r_ t -> void +foreign import ccall "THTensorMath.h THCharTensor_sign" + c_sign_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_sign_ with unused argument (for CTHState) to unify backpack signatures. +c_sign :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_sign = const c_sign_ + +-- | c_trace : t -> accreal +foreign import ccall "THTensorMath.h THCharTensor_trace" + c_trace_ :: Ptr C'THCharTensor -> IO CLong + +-- | alias of c_trace_ with unused argument (for CTHState) to unify backpack signatures. +c_trace :: Ptr C'THState -> Ptr C'THCharTensor -> IO CLong +c_trace = const c_trace_ + +-- | c_cross : r_ a b dimension -> void +foreign import ccall "THTensorMath.h THCharTensor_cross" + c_cross_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () + +-- | alias of c_cross_ with unused argument (for CTHState) to unify backpack signatures. +c_cross :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () +c_cross = const c_cross_ + +-- | c_cmax : r t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cmax" + c_cmax_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cmax_ with unused argument (for CTHState) to unify backpack signatures. +c_cmax :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cmax = const c_cmax_ + +-- | c_cmin : r t src -> void +foreign import ccall "THTensorMath.h THCharTensor_cmin" + c_cmin_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_cmin_ with unused argument (for CTHState) to unify backpack signatures. +c_cmin :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_cmin = const c_cmin_ + +-- | c_cmaxValue : r t value -> void +foreign import ccall "THTensorMath.h THCharTensor_cmaxValue" + c_cmaxValue_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_cmaxValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cmaxValue :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_cmaxValue = const c_cmaxValue_ + +-- | c_cminValue : r t value -> void +foreign import ccall "THTensorMath.h THCharTensor_cminValue" + c_cminValue_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_cminValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cminValue :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_cminValue = const c_cminValue_ + +-- | c_zeros : r_ size -> void +foreign import ccall "THTensorMath.h THCharTensor_zeros" + c_zeros_ :: Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_zeros_ with unused argument (for CTHState) to unify backpack signatures. +c_zeros :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO () +c_zeros = const c_zeros_ + +-- | c_zerosLike : r_ input -> void +foreign import ccall "THTensorMath.h THCharTensor_zerosLike" + c_zerosLike_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_zerosLike_ with unused argument (for CTHState) to unify backpack signatures. +c_zerosLike :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_zerosLike = const c_zerosLike_ + +-- | c_ones : r_ size -> void +foreign import ccall "THTensorMath.h THCharTensor_ones" + c_ones_ :: Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_ones_ with unused argument (for CTHState) to unify backpack signatures. +c_ones :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO () +c_ones = const c_ones_ + +-- | c_onesLike : r_ input -> void +foreign import ccall "THTensorMath.h THCharTensor_onesLike" + c_onesLike_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_onesLike_ with unused argument (for CTHState) to unify backpack signatures. +c_onesLike :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_onesLike = const c_onesLike_ + +-- | c_diag : r_ t k -> void +foreign import ccall "THTensorMath.h THCharTensor_diag" + c_diag_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () + +-- | alias of c_diag_ with unused argument (for CTHState) to unify backpack signatures. +c_diag :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () +c_diag = const c_diag_ + +-- | c_eye : r_ n m -> void +foreign import ccall "THTensorMath.h THCharTensor_eye" + c_eye_ :: Ptr C'THCharTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_eye_ with unused argument (for CTHState) to unify backpack signatures. +c_eye :: Ptr C'THState -> Ptr C'THCharTensor -> CLLong -> CLLong -> IO () +c_eye = const c_eye_ + +-- | c_arange : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THCharTensor_arange" + c_arange_ :: Ptr C'THCharTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_arange_ with unused argument (for CTHState) to unify backpack signatures. +c_arange :: Ptr C'THState -> Ptr C'THCharTensor -> CLong -> CLong -> CLong -> IO () +c_arange = const c_arange_ + +-- | c_range : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THCharTensor_range" + c_range_ :: Ptr C'THCharTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_range_ with unused argument (for CTHState) to unify backpack signatures. +c_range :: Ptr C'THState -> Ptr C'THCharTensor -> CLong -> CLong -> CLong -> IO () +c_range = const c_range_ + +-- | c_randperm : r_ _generator n -> void +foreign import ccall "THTensorMath.h THCharTensor_randperm" + c_randperm_ :: Ptr C'THCharTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_randperm_ with unused argument (for CTHState) to unify backpack signatures. +c_randperm :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_randperm = const c_randperm_ + +-- | c_reshape : r_ t size -> void +foreign import ccall "THTensorMath.h THCharTensor_reshape" + c_reshape_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_reshape_ with unused argument (for CTHState) to unify backpack signatures. +c_reshape :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO () +c_reshape = const c_reshape_ + +-- | c_sort : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h THCharTensor_sort" + c_sort_ :: Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () + +-- | alias of c_sort_ with unused argument (for CTHState) to unify backpack signatures. +c_sort :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO () +c_sort = const c_sort_ + +-- | c_topk : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h THCharTensor_topk" + c_topk_ :: Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CLLong -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_topk_ with unused argument (for CTHState) to unify backpack signatures. +c_topk :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CLLong -> CInt -> CInt -> CInt -> IO () +c_topk = const c_topk_ + +-- | c_tril : r_ t k -> void +foreign import ccall "THTensorMath.h THCharTensor_tril" + c_tril_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> IO () + +-- | alias of c_tril_ with unused argument (for CTHState) to unify backpack signatures. +c_tril :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> IO () +c_tril = const c_tril_ + +-- | c_triu : r_ t k -> void +foreign import ccall "THTensorMath.h THCharTensor_triu" + c_triu_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> IO () + +-- | alias of c_triu_ with unused argument (for CTHState) to unify backpack signatures. +c_triu :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> IO () +c_triu = const c_triu_ + +-- | c_cat : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h THCharTensor_cat" + c_cat_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () + +-- | alias of c_cat_ with unused argument (for CTHState) to unify backpack signatures. +c_cat :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO () +c_cat = const c_cat_ + +-- | c_catArray : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h THCharTensor_catArray" + c_catArray_ :: Ptr C'THCharTensor -> Ptr (Ptr C'THCharTensor) -> CInt -> CInt -> IO () + +-- | alias of c_catArray_ with unused argument (for CTHState) to unify backpack signatures. +c_catArray :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr (Ptr C'THCharTensor) -> CInt -> CInt -> IO () +c_catArray = const c_catArray_ + +-- | c_equal : ta tb -> int +foreign import ccall "THTensorMath.h THCharTensor_equal" + c_equal_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CInt + +-- | alias of c_equal_ with unused argument (for CTHState) to unify backpack signatures. +c_equal :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CInt +c_equal = const c_equal_ + +-- | c_ltValue : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_ltValue" + c_ltValue_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_ltValue_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_ltValue = const c_ltValue_ + +-- | c_leValue : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_leValue" + c_leValue_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_leValue_ with unused argument (for CTHState) to unify backpack signatures. +c_leValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_leValue = const c_leValue_ + +-- | c_gtValue : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_gtValue" + c_gtValue_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_gtValue_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_gtValue = const c_gtValue_ + +-- | c_geValue : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_geValue" + c_geValue_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_geValue_ with unused argument (for CTHState) to unify backpack signatures. +c_geValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_geValue = const c_geValue_ + +-- | c_neValue : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_neValue" + c_neValue_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_neValue_ with unused argument (for CTHState) to unify backpack signatures. +c_neValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_neValue = const c_neValue_ + +-- | c_eqValue : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_eqValue" + c_eqValue_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_eqValue_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_eqValue = const c_eqValue_ + +-- | c_ltValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_ltValueT" + c_ltValueT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_ltValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValueT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_ltValueT = const c_ltValueT_ + +-- | c_leValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_leValueT" + c_leValueT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_leValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_leValueT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_leValueT = const c_leValueT_ + +-- | c_gtValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_gtValueT" + c_gtValueT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_gtValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValueT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_gtValueT = const c_gtValueT_ + +-- | c_geValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_geValueT" + c_geValueT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_geValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_geValueT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_geValueT = const c_geValueT_ + +-- | c_neValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_neValueT" + c_neValueT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_neValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_neValueT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_neValueT = const c_neValueT_ + +-- | c_eqValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THCharTensor_eqValueT" + c_eqValueT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () + +-- | alias of c_eqValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValueT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO () +c_eqValueT = const c_eqValueT_ + +-- | c_ltTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_ltTensor" + c_ltTensor_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_ltTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_ltTensor = const c_ltTensor_ + +-- | c_leTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_leTensor" + c_leTensor_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_leTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_leTensor = const c_leTensor_ + +-- | c_gtTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_gtTensor" + c_gtTensor_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_gtTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_gtTensor = const c_gtTensor_ + +-- | c_geTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_geTensor" + c_geTensor_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_geTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_geTensor = const c_geTensor_ + +-- | c_neTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_neTensor" + c_neTensor_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_neTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_neTensor = const c_neTensor_ + +-- | c_eqTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_eqTensor" + c_eqTensor_ :: Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_eqTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_eqTensor = const c_eqTensor_ + +-- | c_ltTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_ltTensorT" + c_ltTensorT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_ltTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensorT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_ltTensorT = const c_ltTensorT_ + +-- | c_leTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_leTensorT" + c_leTensorT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_leTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensorT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_leTensorT = const c_leTensorT_ + +-- | c_gtTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_gtTensorT" + c_gtTensorT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_gtTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensorT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_gtTensorT = const c_gtTensorT_ + +-- | c_geTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_geTensorT" + c_geTensorT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_geTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensorT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_geTensorT = const c_geTensorT_ + +-- | c_neTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_neTensorT" + c_neTensorT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_neTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensorT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_neTensorT = const c_neTensorT_ + +-- | c_eqTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THCharTensor_eqTensorT" + c_eqTensorT_ :: Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_eqTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensorT :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO () +c_eqTensorT = const c_eqTensorT_ + +-- | p_fill : Pointer to function : r_ value -> void +foreign import ccall "THTensorMath.h &THCharTensor_fill" + p_fill :: FunPtr (Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_zero : Pointer to function : r_ -> void +foreign import ccall "THTensorMath.h &THCharTensor_zero" + p_zero :: FunPtr (Ptr C'THCharTensor -> IO ()) + +-- | p_maskedFill : Pointer to function : tensor mask value -> void +foreign import ccall "THTensorMath.h &THCharTensor_maskedFill" + p_maskedFill :: FunPtr (Ptr C'THCharTensor -> Ptr C'THByteTensor -> CChar -> IO ()) + +-- | p_maskedCopy : Pointer to function : tensor mask src -> void +foreign import ccall "THTensorMath.h &THCharTensor_maskedCopy" + p_maskedCopy :: FunPtr (Ptr C'THCharTensor -> Ptr C'THByteTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_maskedSelect : Pointer to function : tensor src mask -> void +foreign import ccall "THTensorMath.h &THCharTensor_maskedSelect" + p_maskedSelect :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_nonzero : Pointer to function : subscript tensor -> void +foreign import ccall "THTensorMath.h &THCharTensor_nonzero" + p_nonzero :: FunPtr (Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_indexSelect : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THCharTensor_indexSelect" + p_indexSelect :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexCopy : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THCharTensor_indexCopy" + p_indexCopy :: FunPtr (Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_indexAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THCharTensor_indexAdd" + p_indexAdd :: FunPtr (Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_indexFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THCharTensor_indexFill" + p_indexFill :: FunPtr (Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> CChar -> IO ()) + +-- | p_take : Pointer to function : tensor src index -> void +foreign import ccall "THTensorMath.h &THCharTensor_take" + p_take :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_put : Pointer to function : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h &THCharTensor_put" + p_put :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> IO ()) + +-- | p_gather : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THCharTensor_gather" + p_gather :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_scatter : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THCharTensor_scatter" + p_scatter :: FunPtr (Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_scatterAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THCharTensor_scatterAdd" + p_scatterAdd :: FunPtr (Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_scatterFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THCharTensor_scatterFill" + p_scatterFill :: FunPtr (Ptr C'THCharTensor -> CInt -> Ptr C'THLongTensor -> CChar -> IO ()) + +-- | p_dot : Pointer to function : t src -> accreal +foreign import ccall "THTensorMath.h &THCharTensor_dot" + p_dot :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CLong) + +-- | p_minall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THCharTensor_minall" + p_minall :: FunPtr (Ptr C'THCharTensor -> IO CChar) + +-- | p_maxall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THCharTensor_maxall" + p_maxall :: FunPtr (Ptr C'THCharTensor -> IO CChar) + +-- | p_medianall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THCharTensor_medianall" + p_medianall :: FunPtr (Ptr C'THCharTensor -> IO CChar) + +-- | p_sumall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THCharTensor_sumall" + p_sumall :: FunPtr (Ptr C'THCharTensor -> IO CLong) + +-- | p_prodall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THCharTensor_prodall" + p_prodall :: FunPtr (Ptr C'THCharTensor -> IO CLong) + +-- | p_add : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_add" + p_add :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_sub : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_sub" + p_sub :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_add_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THCharTensor_add_scaled" + p_add_scaled :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> CChar -> IO ()) + +-- | p_sub_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THCharTensor_sub_scaled" + p_sub_scaled :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> CChar -> IO ()) + +-- | p_mul : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_mul" + p_mul :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_div : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_div" + p_div :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_lshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_lshift" + p_lshift :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_rshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_rshift" + p_rshift :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_fmod : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_fmod" + p_fmod :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_remainder : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_remainder" + p_remainder :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_clamp : Pointer to function : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h &THCharTensor_clamp" + p_clamp :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> CChar -> IO ()) + +-- | p_bitand : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_bitand" + p_bitand :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_bitor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_bitor" + p_bitor :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_bitxor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_bitxor" + p_bitxor :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_cadd : Pointer to function : r_ t value src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cadd" + p_cadd :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> IO ()) + +-- | p_csub : Pointer to function : self src1 value src2 -> void +foreign import ccall "THTensorMath.h &THCharTensor_csub" + p_csub :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> IO ()) + +-- | p_cmul : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cmul" + p_cmul :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_cpow : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cpow" + p_cpow :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_cdiv : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cdiv" + p_cdiv :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_clshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_clshift" + p_clshift :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_crshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_crshift" + p_crshift :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_cfmod : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cfmod" + p_cfmod :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_cremainder : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cremainder" + p_cremainder :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_cbitand : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cbitand" + p_cbitand :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_cbitor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cbitor" + p_cbitor :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_cbitxor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cbitxor" + p_cbitxor :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_addcmul : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THCharTensor_addcmul" + p_addcmul :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_addcdiv : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THCharTensor_addcdiv" + p_addcdiv :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_addmv : Pointer to function : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h &THCharTensor_addmv" + p_addmv :: FunPtr (Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_addmm : Pointer to function : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h &THCharTensor_addmm" + p_addmm :: FunPtr (Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_addr : Pointer to function : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h &THCharTensor_addr" + p_addr :: FunPtr (Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_addbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THCharTensor_addbmm" + p_addbmm :: FunPtr (Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_baddbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THCharTensor_baddbmm" + p_baddbmm :: FunPtr (Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> CChar -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_match : Pointer to function : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h &THCharTensor_match" + p_match :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_numel : Pointer to function : t -> ptrdiff_t +foreign import ccall "THTensorMath.h &THCharTensor_numel" + p_numel :: FunPtr (Ptr C'THCharTensor -> IO CPtrdiff) + +-- | p_preserveReduceDimSemantics : Pointer to function : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h &THCharTensor_preserveReduceDimSemantics" + p_preserveReduceDimSemantics :: FunPtr (Ptr C'THCharTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_max : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THCharTensor_max" + p_max :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO ()) + +-- | p_min : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THCharTensor_min" + p_min :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO ()) + +-- | p_kthvalue : Pointer to function : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h &THCharTensor_kthvalue" + p_kthvalue :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CLLong -> CInt -> CInt -> IO ()) + +-- | p_mode : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THCharTensor_mode" + p_mode :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO ()) + +-- | p_median : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THCharTensor_median" + p_median :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO ()) + +-- | p_sum : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THCharTensor_sum" + p_sum :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO ()) + +-- | p_prod : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THCharTensor_prod" + p_prod :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO ()) + +-- | p_cumsum : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THCharTensor_cumsum" + p_cumsum :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO ()) + +-- | p_cumprod : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THCharTensor_cumprod" + p_cumprod :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO ()) + +-- | p_sign : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THCharTensor_sign" + p_sign :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_trace : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THCharTensor_trace" + p_trace :: FunPtr (Ptr C'THCharTensor -> IO CLong) + +-- | p_cross : Pointer to function : r_ a b dimension -> void +foreign import ccall "THTensorMath.h &THCharTensor_cross" + p_cross :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO ()) + +-- | p_cmax : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cmax" + p_cmax :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_cmin : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THCharTensor_cmin" + p_cmin :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_cmaxValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_cmaxValue" + p_cmaxValue :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_cminValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_cminValue" + p_cminValue :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_zeros : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THCharTensor_zeros" + p_zeros :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_zerosLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THCharTensor_zerosLike" + p_zerosLike :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_ones : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THCharTensor_ones" + p_ones :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_onesLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THCharTensor_onesLike" + p_onesLike :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_diag : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THCharTensor_diag" + p_diag :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO ()) + +-- | p_eye : Pointer to function : r_ n m -> void +foreign import ccall "THTensorMath.h &THCharTensor_eye" + p_eye :: FunPtr (Ptr C'THCharTensor -> CLLong -> CLLong -> IO ()) + +-- | p_arange : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THCharTensor_arange" + p_arange :: FunPtr (Ptr C'THCharTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_range : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THCharTensor_range" + p_range :: FunPtr (Ptr C'THCharTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_randperm : Pointer to function : r_ _generator n -> void +foreign import ccall "THTensorMath.h &THCharTensor_randperm" + p_randperm :: FunPtr (Ptr C'THCharTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_reshape : Pointer to function : r_ t size -> void +foreign import ccall "THTensorMath.h &THCharTensor_reshape" + p_reshape :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_sort : Pointer to function : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h &THCharTensor_sort" + p_sort :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CInt -> CInt -> IO ()) + +-- | p_topk : Pointer to function : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h &THCharTensor_topk" + p_topk :: FunPtr (Ptr C'THCharTensor -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> CLLong -> CInt -> CInt -> CInt -> IO ()) + +-- | p_tril : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THCharTensor_tril" + p_tril :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> IO ()) + +-- | p_triu : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THCharTensor_triu" + p_triu :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CLLong -> IO ()) + +-- | p_cat : Pointer to function : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h &THCharTensor_cat" + p_cat :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> CInt -> IO ()) + +-- | p_catArray : Pointer to function : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h &THCharTensor_catArray" + p_catArray :: FunPtr (Ptr C'THCharTensor -> Ptr (Ptr C'THCharTensor) -> CInt -> CInt -> IO ()) + +-- | p_equal : Pointer to function : ta tb -> int +foreign import ccall "THTensorMath.h &THCharTensor_equal" + p_equal :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO CInt) + +-- | p_ltValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_ltValue" + p_ltValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_leValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_leValue" + p_leValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_gtValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_gtValue" + p_gtValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_geValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_geValue" + p_geValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_neValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_neValue" + p_neValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_eqValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_eqValue" + p_eqValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_ltValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_ltValueT" + p_ltValueT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_leValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_leValueT" + p_leValueT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_gtValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_gtValueT" + p_gtValueT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_geValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_geValueT" + p_geValueT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_neValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_neValueT" + p_neValueT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_eqValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THCharTensor_eqValueT" + p_eqValueT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> CChar -> IO ()) + +-- | p_ltTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_ltTensor" + p_ltTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_leTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_leTensor" + p_leTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_gtTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_gtTensor" + p_gtTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_geTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_geTensor" + p_geTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_neTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_neTensor" + p_neTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_eqTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_eqTensor" + p_eqTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_ltTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_ltTensorT" + p_ltTensorT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_leTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_leTensorT" + p_leTensorT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_gtTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_gtTensorT" + p_gtTensorT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_geTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_geTensorT" + p_geTensorT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_neTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_neTensorT" + p_neTensorT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_eqTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THCharTensor_eqTensorT" + p_eqTensorT :: FunPtr (Ptr C'THCharTensor -> Ptr C'THCharTensor -> Ptr C'THCharTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Char/TensorRandom.hs b/src/Torch/FFI/TH/Char/TensorRandom.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Char/TensorRandom.hs @@ -0,0 +1,92 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.TensorRandom where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_random : self _generator -> void +foreign import ccall "THTensorRandom.h THCharTensor_random" + c_random_ :: Ptr C'THCharTensor -> Ptr C'THGenerator -> IO () + +-- | alias of c_random_ with unused argument (for CTHState) to unify backpack signatures. +c_random :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THGenerator -> IO () +c_random = const c_random_ + +-- | c_clampedRandom : self _generator min max -> void +foreign import ccall "THTensorRandom.h THCharTensor_clampedRandom" + c_clampedRandom_ :: Ptr C'THCharTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () + +-- | alias of c_clampedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_clampedRandom :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () +c_clampedRandom = const c_clampedRandom_ + +-- | c_cappedRandom : self _generator max -> void +foreign import ccall "THTensorRandom.h THCharTensor_cappedRandom" + c_cappedRandom_ :: Ptr C'THCharTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_cappedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_cappedRandom :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_cappedRandom = const c_cappedRandom_ + +-- | c_geometric : self _generator p -> void +foreign import ccall "THTensorRandom.h THCharTensor_geometric" + c_geometric_ :: Ptr C'THCharTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_geometric_ with unused argument (for CTHState) to unify backpack signatures. +c_geometric :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_geometric = const c_geometric_ + +-- | c_bernoulli : self _generator p -> void +foreign import ccall "THTensorRandom.h THCharTensor_bernoulli" + c_bernoulli_ :: Ptr C'THCharTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_bernoulli_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_bernoulli = const c_bernoulli_ + +-- | c_bernoulli_FloatTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THCharTensor_bernoulli_FloatTensor" + c_bernoulli_FloatTensor_ :: Ptr C'THCharTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_bernoulli_FloatTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_FloatTensor :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () +c_bernoulli_FloatTensor = const c_bernoulli_FloatTensor_ + +-- | c_bernoulli_DoubleTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THCharTensor_bernoulli_DoubleTensor" + c_bernoulli_DoubleTensor_ :: Ptr C'THCharTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_bernoulli_DoubleTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_DoubleTensor :: Ptr C'THState -> Ptr C'THCharTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () +c_bernoulli_DoubleTensor = const c_bernoulli_DoubleTensor_ + +-- | p_random : Pointer to function : self _generator -> void +foreign import ccall "THTensorRandom.h &THCharTensor_random" + p_random :: FunPtr (Ptr C'THCharTensor -> Ptr C'THGenerator -> IO ()) + +-- | p_clampedRandom : Pointer to function : self _generator min max -> void +foreign import ccall "THTensorRandom.h &THCharTensor_clampedRandom" + p_clampedRandom :: FunPtr (Ptr C'THCharTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO ()) + +-- | p_cappedRandom : Pointer to function : self _generator max -> void +foreign import ccall "THTensorRandom.h &THCharTensor_cappedRandom" + p_cappedRandom :: FunPtr (Ptr C'THCharTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_geometric : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THCharTensor_geometric" + p_geometric :: FunPtr (Ptr C'THCharTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THCharTensor_bernoulli" + p_bernoulli :: FunPtr (Ptr C'THCharTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli_FloatTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THCharTensor_bernoulli_FloatTensor" + p_bernoulli_FloatTensor :: FunPtr (Ptr C'THCharTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO ()) + +-- | p_bernoulli_DoubleTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THCharTensor_bernoulli_DoubleTensor" + p_bernoulli_DoubleTensor :: FunPtr (Ptr C'THCharTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Char/Vector.hs b/src/Torch/FFI/TH/Char/Vector.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Char/Vector.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Char.Vector where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : x c n -> void +foreign import ccall "THVector.h THCharVector_fill" + c_fill_ :: Ptr CChar -> CChar -> CPtrdiff -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr CChar -> CChar -> CPtrdiff -> IO () +c_fill = const c_fill_ + +-- | c_cadd : z x y c n -> void +foreign import ccall "THVector.h THCharVector_cadd" + c_cadd_ :: Ptr CChar -> Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr CChar -> Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO () +c_cadd = const c_cadd_ + +-- | c_adds : y x c n -> void +foreign import ccall "THVector.h THCharVector_adds" + c_adds_ :: Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO () + +-- | alias of c_adds_ with unused argument (for CTHState) to unify backpack signatures. +c_adds :: Ptr C'THState -> Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO () +c_adds = const c_adds_ + +-- | c_cmul : z x y n -> void +foreign import ccall "THVector.h THCharVector_cmul" + c_cmul_ :: Ptr CChar -> Ptr CChar -> Ptr CChar -> CPtrdiff -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr CChar -> Ptr CChar -> Ptr CChar -> CPtrdiff -> IO () +c_cmul = const c_cmul_ + +-- | c_muls : y x c n -> void +foreign import ccall "THVector.h THCharVector_muls" + c_muls_ :: Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO () + +-- | alias of c_muls_ with unused argument (for CTHState) to unify backpack signatures. +c_muls :: Ptr C'THState -> Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO () +c_muls = const c_muls_ + +-- | c_cdiv : z x y n -> void +foreign import ccall "THVector.h THCharVector_cdiv" + c_cdiv_ :: Ptr CChar -> Ptr CChar -> Ptr CChar -> CPtrdiff -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr CChar -> Ptr CChar -> Ptr CChar -> CPtrdiff -> IO () +c_cdiv = const c_cdiv_ + +-- | c_divs : y x c n -> void +foreign import ccall "THVector.h THCharVector_divs" + c_divs_ :: Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO () + +-- | alias of c_divs_ with unused argument (for CTHState) to unify backpack signatures. +c_divs :: Ptr C'THState -> Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO () +c_divs = const c_divs_ + +-- | c_copy : y x n -> void +foreign import ccall "THVector.h THCharVector_copy" + c_copy_ :: Ptr CChar -> Ptr CChar -> CPtrdiff -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr CChar -> Ptr CChar -> CPtrdiff -> IO () +c_copy = const c_copy_ + +-- | c_normal_fill : data size generator mean stddev -> void +foreign import ccall "THVector.h THCharVector_normal_fill" + c_normal_fill_ :: Ptr CChar -> CLLong -> Ptr C'THGenerator -> CChar -> CChar -> IO () + +-- | alias of c_normal_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_fill :: Ptr C'THState -> Ptr CChar -> CLLong -> Ptr C'THGenerator -> CChar -> CChar -> IO () +c_normal_fill = const c_normal_fill_ + +-- | p_fill : Pointer to function : x c n -> void +foreign import ccall "THVector.h &THCharVector_fill" + p_fill :: FunPtr (Ptr CChar -> CChar -> CPtrdiff -> IO ()) + +-- | p_cadd : Pointer to function : z x y c n -> void +foreign import ccall "THVector.h &THCharVector_cadd" + p_cadd :: FunPtr (Ptr CChar -> Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO ()) + +-- | p_adds : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THCharVector_adds" + p_adds :: FunPtr (Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO ()) + +-- | p_cmul : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THCharVector_cmul" + p_cmul :: FunPtr (Ptr CChar -> Ptr CChar -> Ptr CChar -> CPtrdiff -> IO ()) + +-- | p_muls : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THCharVector_muls" + p_muls :: FunPtr (Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO ()) + +-- | p_cdiv : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THCharVector_cdiv" + p_cdiv :: FunPtr (Ptr CChar -> Ptr CChar -> Ptr CChar -> CPtrdiff -> IO ()) + +-- | p_divs : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THCharVector_divs" + p_divs :: FunPtr (Ptr CChar -> Ptr CChar -> CChar -> CPtrdiff -> IO ()) + +-- | p_copy : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THCharVector_copy" + p_copy :: FunPtr (Ptr CChar -> Ptr CChar -> CPtrdiff -> IO ()) + +-- | p_normal_fill : Pointer to function : data size generator mean stddev -> void +foreign import ccall "THVector.h &THCharVector_normal_fill" + p_normal_fill :: FunPtr (Ptr CChar -> CLLong -> Ptr C'THGenerator -> CChar -> CChar -> IO ()) diff --git a/src/Torch/FFI/TH/DiskFile.hs b/src/Torch/FFI/TH/DiskFile.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/DiskFile.hs @@ -0,0 +1,88 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.DiskFile where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_THDiskFile_new : name mode isQuiet -> THFile * +foreign import ccall "THDiskFile.h THDiskFile_new" + c_THDiskFile_new :: Ptr CChar -> Ptr CChar -> CInt -> IO (Ptr C'THFile) + +-- | c_THPipeFile_new : name mode isQuiet -> THFile * +foreign import ccall "THDiskFile.h THPipeFile_new" + c_THPipeFile_new :: Ptr CChar -> Ptr CChar -> CInt -> IO (Ptr C'THFile) + +-- | c_THDiskFile_name : self -> char * +foreign import ccall "THDiskFile.h THDiskFile_name" + c_THDiskFile_name :: Ptr C'THFile -> IO (Ptr CChar) + +-- | c_THDiskFile_isLittleEndianCPU : -> int +foreign import ccall "THDiskFile.h THDiskFile_isLittleEndianCPU" + c_THDiskFile_isLittleEndianCPU :: IO CInt + +-- | c_THDiskFile_isBigEndianCPU : -> int +foreign import ccall "THDiskFile.h THDiskFile_isBigEndianCPU" + c_THDiskFile_isBigEndianCPU :: IO CInt + +-- | c_THDiskFile_nativeEndianEncoding : self -> void +foreign import ccall "THDiskFile.h THDiskFile_nativeEndianEncoding" + c_THDiskFile_nativeEndianEncoding :: Ptr C'THFile -> IO () + +-- | c_THDiskFile_littleEndianEncoding : self -> void +foreign import ccall "THDiskFile.h THDiskFile_littleEndianEncoding" + c_THDiskFile_littleEndianEncoding :: Ptr C'THFile -> IO () + +-- | c_THDiskFile_bigEndianEncoding : self -> void +foreign import ccall "THDiskFile.h THDiskFile_bigEndianEncoding" + c_THDiskFile_bigEndianEncoding :: Ptr C'THFile -> IO () + +-- | c_THDiskFile_longSize : self size -> void +foreign import ccall "THDiskFile.h THDiskFile_longSize" + c_THDiskFile_longSize :: Ptr C'THFile -> CInt -> IO () + +-- | c_THDiskFile_noBuffer : self -> void +foreign import ccall "THDiskFile.h THDiskFile_noBuffer" + c_THDiskFile_noBuffer :: Ptr C'THFile -> IO () + +-- | p_THDiskFile_new : Pointer to function : name mode isQuiet -> THFile * +foreign import ccall "THDiskFile.h &THDiskFile_new" + p_THDiskFile_new :: FunPtr (Ptr CChar -> Ptr CChar -> CInt -> IO (Ptr C'THFile)) + +-- | p_THPipeFile_new : Pointer to function : name mode isQuiet -> THFile * +foreign import ccall "THDiskFile.h &THPipeFile_new" + p_THPipeFile_new :: FunPtr (Ptr CChar -> Ptr CChar -> CInt -> IO (Ptr C'THFile)) + +-- | p_THDiskFile_name : Pointer to function : self -> char * +foreign import ccall "THDiskFile.h &THDiskFile_name" + p_THDiskFile_name :: FunPtr (Ptr C'THFile -> IO (Ptr CChar)) + +-- | p_THDiskFile_isLittleEndianCPU : Pointer to function : -> int +foreign import ccall "THDiskFile.h &THDiskFile_isLittleEndianCPU" + p_THDiskFile_isLittleEndianCPU :: FunPtr (IO CInt) + +-- | p_THDiskFile_isBigEndianCPU : Pointer to function : -> int +foreign import ccall "THDiskFile.h &THDiskFile_isBigEndianCPU" + p_THDiskFile_isBigEndianCPU :: FunPtr (IO CInt) + +-- | p_THDiskFile_nativeEndianEncoding : Pointer to function : self -> void +foreign import ccall "THDiskFile.h &THDiskFile_nativeEndianEncoding" + p_THDiskFile_nativeEndianEncoding :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THDiskFile_littleEndianEncoding : Pointer to function : self -> void +foreign import ccall "THDiskFile.h &THDiskFile_littleEndianEncoding" + p_THDiskFile_littleEndianEncoding :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THDiskFile_bigEndianEncoding : Pointer to function : self -> void +foreign import ccall "THDiskFile.h &THDiskFile_bigEndianEncoding" + p_THDiskFile_bigEndianEncoding :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THDiskFile_longSize : Pointer to function : self size -> void +foreign import ccall "THDiskFile.h &THDiskFile_longSize" + p_THDiskFile_longSize :: FunPtr (Ptr C'THFile -> CInt -> IO ()) + +-- | p_THDiskFile_noBuffer : Pointer to function : self -> void +foreign import ccall "THDiskFile.h &THDiskFile_noBuffer" + p_THDiskFile_noBuffer :: FunPtr (Ptr C'THFile -> IO ()) diff --git a/src/Torch/FFI/TH/Double/Blas.hs b/src/Torch/FFI/TH/Double/Blas.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/Blas.hs @@ -0,0 +1,104 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.Blas where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_swap : n x incx y incy -> void +foreign import ccall "THBlas.h THDoubleBlas_swap" + c_swap_ :: CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO () +c_swap = const c_swap_ + +-- | c_scal : n a x incx -> void +foreign import ccall "THBlas.h THDoubleBlas_scal" + c_scal_ :: CLLong -> CDouble -> Ptr CDouble -> CLLong -> IO () + +-- | alias of c_scal_ with unused argument (for CTHState) to unify backpack signatures. +c_scal :: Ptr C'THState -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> IO () +c_scal = const c_scal_ + +-- | c_copy : n x incx y incy -> void +foreign import ccall "THBlas.h THDoubleBlas_copy" + c_copy_ :: CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO () +c_copy = const c_copy_ + +-- | c_axpy : n a x incx y incy -> void +foreign import ccall "THBlas.h THDoubleBlas_axpy" + c_axpy_ :: CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO () + +-- | alias of c_axpy_ with unused argument (for CTHState) to unify backpack signatures. +c_axpy :: Ptr C'THState -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO () +c_axpy = const c_axpy_ + +-- | c_dot : n x incx y incy -> real +foreign import ccall "THBlas.h THDoubleBlas_dot" + c_dot_ :: CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO CDouble + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO CDouble +c_dot = const c_dot_ + +-- | c_gemv : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h THDoubleBlas_gemv" + c_gemv_ :: CChar -> CLLong -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> IO () + +-- | alias of c_gemv_ with unused argument (for CTHState) to unify backpack signatures. +c_gemv :: Ptr C'THState -> CChar -> CLLong -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> IO () +c_gemv = const c_gemv_ + +-- | c_ger : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h THDoubleBlas_ger" + c_ger_ :: CLLong -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO () + +-- | alias of c_ger_ with unused argument (for CTHState) to unify backpack signatures. +c_ger :: Ptr C'THState -> CLLong -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO () +c_ger = const c_ger_ + +-- | c_gemm : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h THDoubleBlas_gemm" + c_gemm_ :: CChar -> CChar -> CLLong -> CLLong -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> IO () + +-- | alias of c_gemm_ with unused argument (for CTHState) to unify backpack signatures. +c_gemm :: Ptr C'THState -> CChar -> CChar -> CLLong -> CLLong -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> IO () +c_gemm = const c_gemm_ + +-- | p_swap : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THDoubleBlas_swap" + p_swap :: FunPtr (CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO ()) + +-- | p_scal : Pointer to function : n a x incx -> void +foreign import ccall "THBlas.h &THDoubleBlas_scal" + p_scal :: FunPtr (CLLong -> CDouble -> Ptr CDouble -> CLLong -> IO ()) + +-- | p_copy : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THDoubleBlas_copy" + p_copy :: FunPtr (CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO ()) + +-- | p_axpy : Pointer to function : n a x incx y incy -> void +foreign import ccall "THBlas.h &THDoubleBlas_axpy" + p_axpy :: FunPtr (CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO ()) + +-- | p_dot : Pointer to function : n x incx y incy -> real +foreign import ccall "THBlas.h &THDoubleBlas_dot" + p_dot :: FunPtr (CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO CDouble) + +-- | p_gemv : Pointer to function : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h &THDoubleBlas_gemv" + p_gemv :: FunPtr (CChar -> CLLong -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> IO ()) + +-- | p_ger : Pointer to function : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h &THDoubleBlas_ger" + p_ger :: FunPtr (CLLong -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> IO ()) + +-- | p_gemm : Pointer to function : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h &THDoubleBlas_gemm" + p_gemm :: FunPtr (CChar -> CChar -> CLLong -> CLLong -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> Ptr CDouble -> CLLong -> CDouble -> Ptr CDouble -> CLLong -> IO ()) diff --git a/src/Torch/FFI/TH/Double/Lapack.hs b/src/Torch/FFI/TH/Double/Lapack.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/Lapack.hs @@ -0,0 +1,200 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.Lapack where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_gesv : n nrhs a lda ipiv b ldb info -> void +foreign import ccall "THLapack.h THDoubleLapack_gesv" + c_gesv_ :: CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_gesv_ with unused argument (for CTHState) to unify backpack signatures. +c_gesv :: Ptr C'THState -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_gesv = const c_gesv_ + +-- | c_trtrs : uplo trans diag n nrhs a lda b ldb info -> void +foreign import ccall "THLapack.h THDoubleLapack_trtrs" + c_trtrs_ :: CChar -> CChar -> CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_trtrs_ with unused argument (for CTHState) to unify backpack signatures. +c_trtrs :: Ptr C'THState -> CChar -> CChar -> CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_trtrs = const c_trtrs_ + +-- | c_gels : trans m n nrhs a lda b ldb work lwork info -> void +foreign import ccall "THLapack.h THDoubleLapack_gels" + c_gels_ :: CChar -> CInt -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_gels_ with unused argument (for CTHState) to unify backpack signatures. +c_gels :: Ptr C'THState -> CChar -> CInt -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_gels = const c_gels_ + +-- | c_syev : jobz uplo n a lda w work lwork info -> void +foreign import ccall "THLapack.h THDoubleLapack_syev" + c_syev_ :: CChar -> CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_syev_ with unused argument (for CTHState) to unify backpack signatures. +c_syev :: Ptr C'THState -> CChar -> CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_syev = const c_syev_ + +-- | c_geev : jobvl jobvr n a lda wr wi vl ldvl vr ldvr work lwork info -> void +foreign import ccall "THLapack.h THDoubleLapack_geev" + c_geev_ :: CChar -> CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_geev_ with unused argument (for CTHState) to unify backpack signatures. +c_geev :: Ptr C'THState -> CChar -> CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_geev = const c_geev_ + +-- | c_gesvd : jobu jobvt m n a lda s u ldu vt ldvt work lwork info -> void +foreign import ccall "THLapack.h THDoubleLapack_gesvd" + c_gesvd_ :: CChar -> CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_gesvd_ with unused argument (for CTHState) to unify backpack signatures. +c_gesvd :: Ptr C'THState -> CChar -> CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_gesvd = const c_gesvd_ + +-- | c_getrf : m n a lda ipiv info -> void +foreign import ccall "THLapack.h THDoubleLapack_getrf" + c_getrf_ :: CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CInt -> IO () + +-- | alias of c_getrf_ with unused argument (for CTHState) to unify backpack signatures. +c_getrf :: Ptr C'THState -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CInt -> IO () +c_getrf = const c_getrf_ + +-- | c_getrs : trans n nrhs a lda ipiv b ldb info -> void +foreign import ccall "THLapack.h THDoubleLapack_getrs" + c_getrs_ :: CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_getrs_ with unused argument (for CTHState) to unify backpack signatures. +c_getrs :: Ptr C'THState -> CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_getrs = const c_getrs_ + +-- | c_getri : n a lda ipiv work lwork info -> void +foreign import ccall "THLapack.h THDoubleLapack_getri" + c_getri_ :: CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_getri_ with unused argument (for CTHState) to unify backpack signatures. +c_getri :: Ptr C'THState -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_getri = const c_getri_ + +-- | c_potrf : uplo n a lda info -> void +foreign import ccall "THLapack.h THDoubleLapack_potrf" + c_potrf_ :: CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_potrf_ with unused argument (for CTHState) to unify backpack signatures. +c_potrf :: Ptr C'THState -> CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_potrf = const c_potrf_ + +-- | c_potri : uplo n a lda info -> void +foreign import ccall "THLapack.h THDoubleLapack_potri" + c_potri_ :: CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_potri_ with unused argument (for CTHState) to unify backpack signatures. +c_potri :: Ptr C'THState -> CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_potri = const c_potri_ + +-- | c_potrs : uplo n nrhs a lda b ldb info -> void +foreign import ccall "THLapack.h THDoubleLapack_potrs" + c_potrs_ :: CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_potrs_ with unused argument (for CTHState) to unify backpack signatures. +c_potrs :: Ptr C'THState -> CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_potrs = const c_potrs_ + +-- | c_pstrf : uplo n a lda piv rank tol work info -> void +foreign import ccall "THLapack.h THDoubleLapack_pstrf" + c_pstrf_ :: CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CInt -> CDouble -> Ptr CDouble -> Ptr CInt -> IO () + +-- | alias of c_pstrf_ with unused argument (for CTHState) to unify backpack signatures. +c_pstrf :: Ptr C'THState -> CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CInt -> CDouble -> Ptr CDouble -> Ptr CInt -> IO () +c_pstrf = const c_pstrf_ + +-- | c_geqrf : m n a lda tau work lwork info -> void +foreign import ccall "THLapack.h THDoubleLapack_geqrf" + c_geqrf_ :: CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_geqrf_ with unused argument (for CTHState) to unify backpack signatures. +c_geqrf :: Ptr C'THState -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_geqrf = const c_geqrf_ + +-- | c_orgqr : m n k a lda tau work lwork info -> void +foreign import ccall "THLapack.h THDoubleLapack_orgqr" + c_orgqr_ :: CInt -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_orgqr_ with unused argument (for CTHState) to unify backpack signatures. +c_orgqr :: Ptr C'THState -> CInt -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_orgqr = const c_orgqr_ + +-- | c_ormqr : side trans m n k a lda tau c ldc work lwork info -> void +foreign import ccall "THLapack.h THDoubleLapack_ormqr" + c_ormqr_ :: CChar -> CChar -> CInt -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () + +-- | alias of c_ormqr_ with unused argument (for CTHState) to unify backpack signatures. +c_ormqr :: Ptr C'THState -> CChar -> CChar -> CInt -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO () +c_ormqr = const c_ormqr_ + +-- | p_gesv : Pointer to function : n nrhs a lda ipiv b ldb info -> void +foreign import ccall "THLapack.h &THDoubleLapack_gesv" + p_gesv :: FunPtr (CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_trtrs : Pointer to function : uplo trans diag n nrhs a lda b ldb info -> void +foreign import ccall "THLapack.h &THDoubleLapack_trtrs" + p_trtrs :: FunPtr (CChar -> CChar -> CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_gels : Pointer to function : trans m n nrhs a lda b ldb work lwork info -> void +foreign import ccall "THLapack.h &THDoubleLapack_gels" + p_gels :: FunPtr (CChar -> CInt -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_syev : Pointer to function : jobz uplo n a lda w work lwork info -> void +foreign import ccall "THLapack.h &THDoubleLapack_syev" + p_syev :: FunPtr (CChar -> CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_geev : Pointer to function : jobvl jobvr n a lda wr wi vl ldvl vr ldvr work lwork info -> void +foreign import ccall "THLapack.h &THDoubleLapack_geev" + p_geev :: FunPtr (CChar -> CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_gesvd : Pointer to function : jobu jobvt m n a lda s u ldu vt ldvt work lwork info -> void +foreign import ccall "THLapack.h &THDoubleLapack_gesvd" + p_gesvd :: FunPtr (CChar -> CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_getrf : Pointer to function : m n a lda ipiv info -> void +foreign import ccall "THLapack.h &THDoubleLapack_getrf" + p_getrf :: FunPtr (CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CInt -> IO ()) + +-- | p_getrs : Pointer to function : trans n nrhs a lda ipiv b ldb info -> void +foreign import ccall "THLapack.h &THDoubleLapack_getrs" + p_getrs :: FunPtr (CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_getri : Pointer to function : n a lda ipiv work lwork info -> void +foreign import ccall "THLapack.h &THDoubleLapack_getri" + p_getri :: FunPtr (CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_potrf : Pointer to function : uplo n a lda info -> void +foreign import ccall "THLapack.h &THDoubleLapack_potrf" + p_potrf :: FunPtr (CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_potri : Pointer to function : uplo n a lda info -> void +foreign import ccall "THLapack.h &THDoubleLapack_potri" + p_potri :: FunPtr (CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_potrs : Pointer to function : uplo n nrhs a lda b ldb info -> void +foreign import ccall "THLapack.h &THDoubleLapack_potrs" + p_potrs :: FunPtr (CChar -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_pstrf : Pointer to function : uplo n a lda piv rank tol work info -> void +foreign import ccall "THLapack.h &THDoubleLapack_pstrf" + p_pstrf :: FunPtr (CChar -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> Ptr CInt -> CDouble -> Ptr CDouble -> Ptr CInt -> IO ()) + +-- | p_geqrf : Pointer to function : m n a lda tau work lwork info -> void +foreign import ccall "THLapack.h &THDoubleLapack_geqrf" + p_geqrf :: FunPtr (CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_orgqr : Pointer to function : m n k a lda tau work lwork info -> void +foreign import ccall "THLapack.h &THDoubleLapack_orgqr" + p_orgqr :: FunPtr (CInt -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) + +-- | p_ormqr : Pointer to function : side trans m n k a lda tau c ldc work lwork info -> void +foreign import ccall "THLapack.h &THDoubleLapack_ormqr" + p_ormqr :: FunPtr (CChar -> CChar -> CInt -> CInt -> CInt -> Ptr CDouble -> CInt -> Ptr CDouble -> Ptr CDouble -> CInt -> Ptr CDouble -> CInt -> Ptr CInt -> IO ()) diff --git a/src/Torch/FFI/TH/Double/Storage.hs b/src/Torch/FFI/TH/Double/Storage.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/Storage.hs @@ -0,0 +1,260 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.Storage where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_data : -> real * +foreign import ccall "THStorage.h THDoubleStorage_data" + c_data_ :: Ptr C'THDoubleStorage -> IO (Ptr CDouble) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THDoubleStorage -> IO (Ptr CDouble) +c_data = const c_data_ + +-- | c_size : -> ptrdiff_t +foreign import ccall "THStorage.h THDoubleStorage_size" + c_size_ :: Ptr C'THDoubleStorage -> IO CPtrdiff + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THDoubleStorage -> IO CPtrdiff +c_size = const c_size_ + +-- | c_set : -> void +foreign import ccall "THStorage.h THDoubleStorage_set" + c_set_ :: Ptr C'THDoubleStorage -> CPtrdiff -> CDouble -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THDoubleStorage -> CPtrdiff -> CDouble -> IO () +c_set = const c_set_ + +-- | c_get : -> real +foreign import ccall "THStorage.h THDoubleStorage_get" + c_get_ :: Ptr C'THDoubleStorage -> CPtrdiff -> IO CDouble + +-- | alias of c_get_ with unused argument (for CTHState) to unify backpack signatures. +c_get :: Ptr C'THState -> Ptr C'THDoubleStorage -> CPtrdiff -> IO CDouble +c_get = const c_get_ + +-- | c_new : -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_new" + c_new_ :: IO (Ptr C'THDoubleStorage) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THDoubleStorage) +c_new = const c_new_ + +-- | c_newWithSize : size -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_newWithSize" + c_newWithSize_ :: CPtrdiff -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> CPtrdiff -> IO (Ptr C'THDoubleStorage) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1 : -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_newWithSize1" + c_newWithSize1_ :: CDouble -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_newWithSize1_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1 :: Ptr C'THState -> CDouble -> IO (Ptr C'THDoubleStorage) +c_newWithSize1 = const c_newWithSize1_ + +-- | c_newWithSize2 : -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_newWithSize2" + c_newWithSize2_ :: CDouble -> CDouble -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_newWithSize2_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2 :: Ptr C'THState -> CDouble -> CDouble -> IO (Ptr C'THDoubleStorage) +c_newWithSize2 = const c_newWithSize2_ + +-- | c_newWithSize3 : -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_newWithSize3" + c_newWithSize3_ :: CDouble -> CDouble -> CDouble -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_newWithSize3_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3 :: Ptr C'THState -> CDouble -> CDouble -> CDouble -> IO (Ptr C'THDoubleStorage) +c_newWithSize3 = const c_newWithSize3_ + +-- | c_newWithSize4 : -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_newWithSize4" + c_newWithSize4_ :: CDouble -> CDouble -> CDouble -> CDouble -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_newWithSize4_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4 :: Ptr C'THState -> CDouble -> CDouble -> CDouble -> CDouble -> IO (Ptr C'THDoubleStorage) +c_newWithSize4 = const c_newWithSize4_ + +-- | c_newWithMapping : filename size flags -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_newWithMapping" + c_newWithMapping_ :: Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_newWithMapping_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithMapping :: Ptr C'THState -> Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THDoubleStorage) +c_newWithMapping = const c_newWithMapping_ + +-- | c_newWithData : data size -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_newWithData" + c_newWithData_ :: Ptr CDouble -> CPtrdiff -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_newWithData_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithData :: Ptr C'THState -> Ptr CDouble -> CPtrdiff -> IO (Ptr C'THDoubleStorage) +c_newWithData = const c_newWithData_ + +-- | c_newWithAllocator : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_newWithAllocator" + c_newWithAllocator_ :: CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_newWithAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithAllocator :: Ptr C'THState -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THDoubleStorage) +c_newWithAllocator = const c_newWithAllocator_ + +-- | c_newWithDataAndAllocator : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THDoubleStorage_newWithDataAndAllocator" + c_newWithDataAndAllocator_ :: Ptr CDouble -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_newWithDataAndAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithDataAndAllocator :: Ptr C'THState -> Ptr CDouble -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THDoubleStorage) +c_newWithDataAndAllocator = const c_newWithDataAndAllocator_ + +-- | c_setFlag : storage flag -> void +foreign import ccall "THStorage.h THDoubleStorage_setFlag" + c_setFlag_ :: Ptr C'THDoubleStorage -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THDoubleStorage -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : storage flag -> void +foreign import ccall "THStorage.h THDoubleStorage_clearFlag" + c_clearFlag_ :: Ptr C'THDoubleStorage -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THDoubleStorage -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_retain : storage -> void +foreign import ccall "THStorage.h THDoubleStorage_retain" + c_retain_ :: Ptr C'THDoubleStorage -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THDoubleStorage -> IO () +c_retain = const c_retain_ + +-- | c_swap : storage1 storage2 -> void +foreign import ccall "THStorage.h THDoubleStorage_swap" + c_swap_ :: Ptr C'THDoubleStorage -> Ptr C'THDoubleStorage -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THDoubleStorage -> IO () +c_swap = const c_swap_ + +-- | c_free : storage -> void +foreign import ccall "THStorage.h THDoubleStorage_free" + c_free_ :: Ptr C'THDoubleStorage -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THDoubleStorage -> IO () +c_free = const c_free_ + +-- | c_resize : storage size -> void +foreign import ccall "THStorage.h THDoubleStorage_resize" + c_resize_ :: Ptr C'THDoubleStorage -> CPtrdiff -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THDoubleStorage -> CPtrdiff -> IO () +c_resize = const c_resize_ + +-- | c_fill : storage value -> void +foreign import ccall "THStorage.h THDoubleStorage_fill" + c_fill_ :: Ptr C'THDoubleStorage -> CDouble -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THDoubleStorage -> CDouble -> IO () +c_fill = const c_fill_ + +-- | p_data : Pointer to function : -> real * +foreign import ccall "THStorage.h &THDoubleStorage_data" + p_data :: FunPtr (Ptr C'THDoubleStorage -> IO (Ptr CDouble)) + +-- | p_size : Pointer to function : -> ptrdiff_t +foreign import ccall "THStorage.h &THDoubleStorage_size" + p_size :: FunPtr (Ptr C'THDoubleStorage -> IO CPtrdiff) + +-- | p_set : Pointer to function : -> void +foreign import ccall "THStorage.h &THDoubleStorage_set" + p_set :: FunPtr (Ptr C'THDoubleStorage -> CPtrdiff -> CDouble -> IO ()) + +-- | p_get : Pointer to function : -> real +foreign import ccall "THStorage.h &THDoubleStorage_get" + p_get :: FunPtr (Ptr C'THDoubleStorage -> CPtrdiff -> IO CDouble) + +-- | p_new : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_new" + p_new :: FunPtr (IO (Ptr C'THDoubleStorage)) + +-- | p_newWithSize : Pointer to function : size -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_newWithSize" + p_newWithSize :: FunPtr (CPtrdiff -> IO (Ptr C'THDoubleStorage)) + +-- | p_newWithSize1 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_newWithSize1" + p_newWithSize1 :: FunPtr (CDouble -> IO (Ptr C'THDoubleStorage)) + +-- | p_newWithSize2 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_newWithSize2" + p_newWithSize2 :: FunPtr (CDouble -> CDouble -> IO (Ptr C'THDoubleStorage)) + +-- | p_newWithSize3 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_newWithSize3" + p_newWithSize3 :: FunPtr (CDouble -> CDouble -> CDouble -> IO (Ptr C'THDoubleStorage)) + +-- | p_newWithSize4 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_newWithSize4" + p_newWithSize4 :: FunPtr (CDouble -> CDouble -> CDouble -> CDouble -> IO (Ptr C'THDoubleStorage)) + +-- | p_newWithMapping : Pointer to function : filename size flags -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_newWithMapping" + p_newWithMapping :: FunPtr (Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THDoubleStorage)) + +-- | p_newWithData : Pointer to function : data size -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_newWithData" + p_newWithData :: FunPtr (Ptr CDouble -> CPtrdiff -> IO (Ptr C'THDoubleStorage)) + +-- | p_newWithAllocator : Pointer to function : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_newWithAllocator" + p_newWithAllocator :: FunPtr (CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THDoubleStorage)) + +-- | p_newWithDataAndAllocator : Pointer to function : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THDoubleStorage_newWithDataAndAllocator" + p_newWithDataAndAllocator :: FunPtr (Ptr CDouble -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THDoubleStorage)) + +-- | p_setFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THDoubleStorage_setFlag" + p_setFlag :: FunPtr (Ptr C'THDoubleStorage -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THDoubleStorage_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THDoubleStorage -> CChar -> IO ()) + +-- | p_retain : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THDoubleStorage_retain" + p_retain :: FunPtr (Ptr C'THDoubleStorage -> IO ()) + +-- | p_swap : Pointer to function : storage1 storage2 -> void +foreign import ccall "THStorage.h &THDoubleStorage_swap" + p_swap :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THDoubleStorage -> IO ()) + +-- | p_free : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THDoubleStorage_free" + p_free :: FunPtr (Ptr C'THDoubleStorage -> IO ()) + +-- | p_resize : Pointer to function : storage size -> void +foreign import ccall "THStorage.h &THDoubleStorage_resize" + p_resize :: FunPtr (Ptr C'THDoubleStorage -> CPtrdiff -> IO ()) + +-- | p_fill : Pointer to function : storage value -> void +foreign import ccall "THStorage.h &THDoubleStorage_fill" + p_fill :: FunPtr (Ptr C'THDoubleStorage -> CDouble -> IO ()) diff --git a/src/Torch/FFI/TH/Double/StorageCopy.hs b/src/Torch/FFI/TH/Double/StorageCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/StorageCopy.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.StorageCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_rawCopy : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_rawCopy" + c_rawCopy_ :: Ptr C'THDoubleStorage -> Ptr CDouble -> IO () + +-- | alias of c_rawCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_rawCopy :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr CDouble -> IO () +c_rawCopy = const c_rawCopy_ + +-- | c_copy : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_copy" + c_copy_ :: Ptr C'THDoubleStorage -> Ptr C'THDoubleStorage -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THDoubleStorage -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_copyByte" + c_copyByte_ :: Ptr C'THDoubleStorage -> Ptr C'THByteStorage -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THByteStorage -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_copyChar" + c_copyChar_ :: Ptr C'THDoubleStorage -> Ptr C'THCharStorage -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THCharStorage -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_copyShort" + c_copyShort_ :: Ptr C'THDoubleStorage -> Ptr C'THShortStorage -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THShortStorage -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_copyInt" + c_copyInt_ :: Ptr C'THDoubleStorage -> Ptr C'THIntStorage -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THIntStorage -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_copyLong" + c_copyLong_ :: Ptr C'THDoubleStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THLongStorage -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_copyFloat" + c_copyFloat_ :: Ptr C'THDoubleStorage -> Ptr C'THFloatStorage -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THFloatStorage -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_copyDouble" + c_copyDouble_ :: Ptr C'THDoubleStorage -> Ptr C'THDoubleStorage -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THDoubleStorage -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : storage src -> void +foreign import ccall "THStorageCopy.h THDoubleStorage_copyHalf" + c_copyHalf_ :: Ptr C'THDoubleStorage -> Ptr C'THHalfStorage -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THDoubleStorage -> Ptr C'THHalfStorage -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_rawCopy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_rawCopy" + p_rawCopy :: FunPtr (Ptr C'THDoubleStorage -> Ptr CDouble -> IO ()) + +-- | p_copy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_copy" + p_copy :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THDoubleStorage -> IO ()) + +-- | p_copyByte : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_copyByte" + p_copyByte :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THByteStorage -> IO ()) + +-- | p_copyChar : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_copyChar" + p_copyChar :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THCharStorage -> IO ()) + +-- | p_copyShort : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_copyShort" + p_copyShort :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THShortStorage -> IO ()) + +-- | p_copyInt : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_copyInt" + p_copyInt :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THIntStorage -> IO ()) + +-- | p_copyLong : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_copyLong" + p_copyLong :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_copyFloat : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THFloatStorage -> IO ()) + +-- | p_copyDouble : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THDoubleStorage -> IO ()) + +-- | p_copyHalf : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THDoubleStorage_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THDoubleStorage -> Ptr C'THHalfStorage -> IO ()) diff --git a/src/Torch/FFI/TH/Double/Tensor.hs b/src/Torch/FFI/TH/Double/Tensor.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/Tensor.hs @@ -0,0 +1,872 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.Tensor where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_storage : self -> THStorage * +foreign import ccall "THTensor.h THDoubleTensor_storage" + c_storage_ :: Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleStorage) + +-- | alias of c_storage_ with unused argument (for CTHState) to unify backpack signatures. +c_storage :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleStorage) +c_storage = const c_storage_ + +-- | c_storageOffset : self -> ptrdiff_t +foreign import ccall "THTensor.h THDoubleTensor_storageOffset" + c_storageOffset_ :: Ptr C'THDoubleTensor -> IO CPtrdiff + +-- | alias of c_storageOffset_ with unused argument (for CTHState) to unify backpack signatures. +c_storageOffset :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CPtrdiff +c_storageOffset = const c_storageOffset_ + +-- | c_nDimension : self -> int +foreign import ccall "THTensor.h THDoubleTensor_nDimension" + c_nDimension_ :: Ptr C'THDoubleTensor -> IO CInt + +-- | alias of c_nDimension_ with unused argument (for CTHState) to unify backpack signatures. +c_nDimension :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CInt +c_nDimension = const c_nDimension_ + +-- | c_size : self dim -> int64_t +foreign import ccall "THTensor.h THDoubleTensor_size" + c_size_ :: Ptr C'THDoubleTensor -> CInt -> IO CLLong + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> IO CLLong +c_size = const c_size_ + +-- | c_stride : self dim -> int64_t +foreign import ccall "THTensor.h THDoubleTensor_stride" + c_stride_ :: Ptr C'THDoubleTensor -> CInt -> IO CLLong + +-- | alias of c_stride_ with unused argument (for CTHState) to unify backpack signatures. +c_stride :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> IO CLLong +c_stride = const c_stride_ + +-- | c_newSizeOf : self -> THLongStorage * +foreign import ccall "THTensor.h THDoubleTensor_newSizeOf" + c_newSizeOf_ :: Ptr C'THDoubleTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newSizeOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newSizeOf :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO (Ptr C'THLongStorage) +c_newSizeOf = const c_newSizeOf_ + +-- | c_newStrideOf : self -> THLongStorage * +foreign import ccall "THTensor.h THDoubleTensor_newStrideOf" + c_newStrideOf_ :: Ptr C'THDoubleTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newStrideOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newStrideOf :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO (Ptr C'THLongStorage) +c_newStrideOf = const c_newStrideOf_ + +-- | c_data : self -> real * +foreign import ccall "THTensor.h THDoubleTensor_data" + c_data_ :: Ptr C'THDoubleTensor -> IO (Ptr CDouble) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO (Ptr CDouble) +c_data = const c_data_ + +-- | c_setFlag : self flag -> void +foreign import ccall "THTensor.h THDoubleTensor_setFlag" + c_setFlag_ :: Ptr C'THDoubleTensor -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THDoubleTensor -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : self flag -> void +foreign import ccall "THTensor.h THDoubleTensor_clearFlag" + c_clearFlag_ :: Ptr C'THDoubleTensor -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THDoubleTensor -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_new : -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_new" + c_new_ :: IO (Ptr C'THDoubleTensor) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THDoubleTensor) +c_new = const c_new_ + +-- | c_newWithTensor : tensor -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithTensor" + c_newWithTensor_ :: Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithTensor :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleTensor) +c_newWithTensor = const c_newWithTensor_ + +-- | c_newWithStorage : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithStorage" + c_newWithStorage_ :: Ptr C'THDoubleStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage :: Ptr C'THState -> Ptr C'THDoubleStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor) +c_newWithStorage = const c_newWithStorage_ + +-- | c_newWithStorage1d : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithStorage1d" + c_newWithStorage1d_ :: Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage1d :: Ptr C'THState -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newWithStorage1d = const c_newWithStorage1d_ + +-- | c_newWithStorage2d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithStorage2d" + c_newWithStorage2d_ :: Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage2d :: Ptr C'THState -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newWithStorage2d = const c_newWithStorage2d_ + +-- | c_newWithStorage3d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithStorage3d" + c_newWithStorage3d_ :: Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage3d :: Ptr C'THState -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newWithStorage3d = const c_newWithStorage3d_ + +-- | c_newWithStorage4d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithStorage4d" + c_newWithStorage4d_ :: Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage4d :: Ptr C'THState -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newWithStorage4d = const c_newWithStorage4d_ + +-- | c_newWithSize : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithSize" + c_newWithSize_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1d : size0_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithSize1d" + c_newWithSize1d_ :: CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithSize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1d :: Ptr C'THState -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newWithSize1d = const c_newWithSize1d_ + +-- | c_newWithSize2d : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithSize2d" + c_newWithSize2d_ :: CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithSize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2d :: Ptr C'THState -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newWithSize2d = const c_newWithSize2d_ + +-- | c_newWithSize3d : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithSize3d" + c_newWithSize3d_ :: CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithSize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newWithSize3d = const c_newWithSize3d_ + +-- | c_newWithSize4d : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newWithSize4d" + c_newWithSize4d_ :: CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newWithSize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newWithSize4d = const c_newWithSize4d_ + +-- | c_newClone : self -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newClone" + c_newClone_ :: Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newClone_ with unused argument (for CTHState) to unify backpack signatures. +c_newClone :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleTensor) +c_newClone = const c_newClone_ + +-- | c_newContiguous : tensor -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newContiguous" + c_newContiguous_ :: Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_newContiguous :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleTensor) +c_newContiguous = const c_newContiguous_ + +-- | c_newSelect : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newSelect" + c_newSelect_ :: Ptr C'THDoubleTensor -> CInt -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_newSelect :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newSelect = const c_newSelect_ + +-- | c_newNarrow : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newNarrow" + c_newNarrow_ :: Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newNarrow_ with unused argument (for CTHState) to unify backpack signatures. +c_newNarrow :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newNarrow = const c_newNarrow_ + +-- | c_newTranspose : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newTranspose" + c_newTranspose_ :: Ptr C'THDoubleTensor -> CInt -> CInt -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newTranspose_ with unused argument (for CTHState) to unify backpack signatures. +c_newTranspose :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO (Ptr C'THDoubleTensor) +c_newTranspose = const c_newTranspose_ + +-- | c_newUnfold : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newUnfold" + c_newUnfold_ :: Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newUnfold_ with unused argument (for CTHState) to unify backpack signatures. +c_newUnfold :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor) +c_newUnfold = const c_newUnfold_ + +-- | c_newView : tensor size -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newView" + c_newView_ :: Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newView_ with unused argument (for CTHState) to unify backpack signatures. +c_newView :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor) +c_newView = const c_newView_ + +-- | c_newExpand : tensor size -> THTensor * +foreign import ccall "THTensor.h THDoubleTensor_newExpand" + c_newExpand_ :: Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor) + +-- | alias of c_newExpand_ with unused argument (for CTHState) to unify backpack signatures. +c_newExpand :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor) +c_newExpand = const c_newExpand_ + +-- | c_expand : r tensor size -> void +foreign import ccall "THTensor.h THDoubleTensor_expand" + c_expand_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_expand_ with unused argument (for CTHState) to unify backpack signatures. +c_expand :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO () +c_expand = const c_expand_ + +-- | c_expandNd : rets ops count -> void +foreign import ccall "THTensor.h THDoubleTensor_expandNd" + c_expandNd_ :: Ptr (Ptr C'THDoubleTensor) -> Ptr (Ptr C'THDoubleTensor) -> CInt -> IO () + +-- | alias of c_expandNd_ with unused argument (for CTHState) to unify backpack signatures. +c_expandNd :: Ptr C'THState -> Ptr (Ptr C'THDoubleTensor) -> Ptr (Ptr C'THDoubleTensor) -> CInt -> IO () +c_expandNd = const c_expandNd_ + +-- | c_resize : tensor size stride -> void +foreign import ccall "THTensor.h THDoubleTensor_resize" + c_resize_ :: Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_resize = const c_resize_ + +-- | c_resizeAs : tensor src -> void +foreign import ccall "THTensor.h THDoubleTensor_resizeAs" + c_resizeAs_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_resizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeAs :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_resizeAs = const c_resizeAs_ + +-- | c_resizeNd : tensor nDimension size stride -> void +foreign import ccall "THTensor.h THDoubleTensor_resizeNd" + c_resizeNd_ :: Ptr C'THDoubleTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_resizeNd_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeNd :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_resizeNd = const c_resizeNd_ + +-- | c_resize1d : tensor size0_ -> void +foreign import ccall "THTensor.h THDoubleTensor_resize1d" + c_resize1d_ :: Ptr C'THDoubleTensor -> CLLong -> IO () + +-- | alias of c_resize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize1d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> IO () +c_resize1d = const c_resize1d_ + +-- | c_resize2d : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h THDoubleTensor_resize2d" + c_resize2d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_resize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize2d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO () +c_resize2d = const c_resize2d_ + +-- | c_resize3d : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h THDoubleTensor_resize3d" + c_resize3d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize3d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> IO () +c_resize3d = const c_resize3d_ + +-- | c_resize4d : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h THDoubleTensor_resize4d" + c_resize4d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize4d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize4d = const c_resize4d_ + +-- | c_resize5d : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h THDoubleTensor_resize5d" + c_resize5d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize5d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize5d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize5d = const c_resize5d_ + +-- | c_set : self src -> void +foreign import ccall "THTensor.h THDoubleTensor_set" + c_set_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_set = const c_set_ + +-- | c_setStorage : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h THDoubleTensor_setStorage" + c_setStorage_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_setStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_setStorage = const c_setStorage_ + +-- | c_setStorageNd : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h THDoubleTensor_setStorageNd" + c_setStorageNd_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_setStorageNd_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorageNd :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_setStorageNd = const c_setStorageNd_ + +-- | c_setStorage1d : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h THDoubleTensor_setStorage1d" + c_setStorage1d_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage1d :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> IO () +c_setStorage1d = const c_setStorage1d_ + +-- | c_setStorage2d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h THDoubleTensor_setStorage2d" + c_setStorage2d_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage2d :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage2d = const c_setStorage2d_ + +-- | c_setStorage3d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h THDoubleTensor_setStorage3d" + c_setStorage3d_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage3d :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage3d = const c_setStorage3d_ + +-- | c_setStorage4d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h THDoubleTensor_setStorage4d" + c_setStorage4d_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage4d :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage4d = const c_setStorage4d_ + +-- | c_narrow : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h THDoubleTensor_narrow" + c_narrow_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_narrow_ with unused argument (for CTHState) to unify backpack signatures. +c_narrow :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO () +c_narrow = const c_narrow_ + +-- | c_select : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h THDoubleTensor_select" + c_select_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CLLong -> IO () + +-- | alias of c_select_ with unused argument (for CTHState) to unify backpack signatures. +c_select :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CLLong -> IO () +c_select = const c_select_ + +-- | c_transpose : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h THDoubleTensor_transpose" + c_transpose_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_transpose_ with unused argument (for CTHState) to unify backpack signatures. +c_transpose :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_transpose = const c_transpose_ + +-- | c_unfold : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h THDoubleTensor_unfold" + c_unfold_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_unfold_ with unused argument (for CTHState) to unify backpack signatures. +c_unfold :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO () +c_unfold = const c_unfold_ + +-- | c_squeeze : self src -> void +foreign import ccall "THTensor.h THDoubleTensor_squeeze" + c_squeeze_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_squeeze_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_squeeze = const c_squeeze_ + +-- | c_squeeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THDoubleTensor_squeeze1d" + c_squeeze1d_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | alias of c_squeeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze1d :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () +c_squeeze1d = const c_squeeze1d_ + +-- | c_unsqueeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THDoubleTensor_unsqueeze1d" + c_unsqueeze1d_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | alias of c_unsqueeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_unsqueeze1d :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () +c_unsqueeze1d = const c_unsqueeze1d_ + +-- | c_isContiguous : self -> int +foreign import ccall "THTensor.h THDoubleTensor_isContiguous" + c_isContiguous_ :: Ptr C'THDoubleTensor -> IO CInt + +-- | alias of c_isContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_isContiguous :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CInt +c_isContiguous = const c_isContiguous_ + +-- | c_isSameSizeAs : self src -> int +foreign import ccall "THTensor.h THDoubleTensor_isSameSizeAs" + c_isSameSizeAs_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CInt + +-- | alias of c_isSameSizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_isSameSizeAs :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CInt +c_isSameSizeAs = const c_isSameSizeAs_ + +-- | c_isSetTo : self src -> int +foreign import ccall "THTensor.h THDoubleTensor_isSetTo" + c_isSetTo_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CInt + +-- | alias of c_isSetTo_ with unused argument (for CTHState) to unify backpack signatures. +c_isSetTo :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CInt +c_isSetTo = const c_isSetTo_ + +-- | c_isSize : self dims -> int +foreign import ccall "THTensor.h THDoubleTensor_isSize" + c_isSize_ :: Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO CInt + +-- | alias of c_isSize_ with unused argument (for CTHState) to unify backpack signatures. +c_isSize :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO CInt +c_isSize = const c_isSize_ + +-- | c_nElement : self -> ptrdiff_t +foreign import ccall "THTensor.h THDoubleTensor_nElement" + c_nElement_ :: Ptr C'THDoubleTensor -> IO CPtrdiff + +-- | alias of c_nElement_ with unused argument (for CTHState) to unify backpack signatures. +c_nElement :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CPtrdiff +c_nElement = const c_nElement_ + +-- | c_retain : self -> void +foreign import ccall "THTensor.h THDoubleTensor_retain" + c_retain_ :: Ptr C'THDoubleTensor -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO () +c_retain = const c_retain_ + +-- | c_free : self -> void +foreign import ccall "THTensor.h THDoubleTensor_free" + c_free_ :: Ptr C'THDoubleTensor -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO () +c_free = const c_free_ + +-- | c_freeCopyTo : self dst -> void +foreign import ccall "THTensor.h THDoubleTensor_freeCopyTo" + c_freeCopyTo_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_freeCopyTo_ with unused argument (for CTHState) to unify backpack signatures. +c_freeCopyTo :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_freeCopyTo = const c_freeCopyTo_ + +-- | c_set1d : tensor x0 value -> void +foreign import ccall "THTensor.h THDoubleTensor_set1d" + c_set1d_ :: Ptr C'THDoubleTensor -> CLLong -> CDouble -> IO () + +-- | alias of c_set1d_ with unused argument (for CTHState) to unify backpack signatures. +c_set1d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CDouble -> IO () +c_set1d = const c_set1d_ + +-- | c_set2d : tensor x0 x1 value -> void +foreign import ccall "THTensor.h THDoubleTensor_set2d" + c_set2d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> CDouble -> IO () + +-- | alias of c_set2d_ with unused argument (for CTHState) to unify backpack signatures. +c_set2d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CDouble -> IO () +c_set2d = const c_set2d_ + +-- | c_set3d : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h THDoubleTensor_set3d" + c_set3d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CDouble -> IO () + +-- | alias of c_set3d_ with unused argument (for CTHState) to unify backpack signatures. +c_set3d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CDouble -> IO () +c_set3d = const c_set3d_ + +-- | c_set4d : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h THDoubleTensor_set4d" + c_set4d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CDouble -> IO () + +-- | alias of c_set4d_ with unused argument (for CTHState) to unify backpack signatures. +c_set4d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CDouble -> IO () +c_set4d = const c_set4d_ + +-- | c_get1d : tensor x0 -> real +foreign import ccall "THTensor.h THDoubleTensor_get1d" + c_get1d_ :: Ptr C'THDoubleTensor -> CLLong -> IO CDouble + +-- | alias of c_get1d_ with unused argument (for CTHState) to unify backpack signatures. +c_get1d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> IO CDouble +c_get1d = const c_get1d_ + +-- | c_get2d : tensor x0 x1 -> real +foreign import ccall "THTensor.h THDoubleTensor_get2d" + c_get2d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO CDouble + +-- | alias of c_get2d_ with unused argument (for CTHState) to unify backpack signatures. +c_get2d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO CDouble +c_get2d = const c_get2d_ + +-- | c_get3d : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h THDoubleTensor_get3d" + c_get3d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> IO CDouble + +-- | alias of c_get3d_ with unused argument (for CTHState) to unify backpack signatures. +c_get3d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> IO CDouble +c_get3d = const c_get3d_ + +-- | c_get4d : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h THDoubleTensor_get4d" + c_get4d_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CDouble + +-- | alias of c_get4d_ with unused argument (for CTHState) to unify backpack signatures. +c_get4d :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CDouble +c_get4d = const c_get4d_ + +-- | c_desc : tensor -> THDescBuff +foreign import ccall "THTensor.h THDoubleTensor_desc" + c_desc_ :: Ptr C'THDoubleTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_desc_ with unused argument (for CTHState) to unify backpack signatures. +c_desc :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO (Ptr C'THDescBuff) +c_desc = const c_desc_ + +-- | c_sizeDesc : tensor -> THDescBuff +foreign import ccall "THTensor.h THDoubleTensor_sizeDesc" + c_sizeDesc_ :: Ptr C'THDoubleTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_sizeDesc_ with unused argument (for CTHState) to unify backpack signatures. +c_sizeDesc :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO (Ptr C'THDescBuff) +c_sizeDesc = const c_sizeDesc_ + +-- | p_storage : Pointer to function : self -> THStorage * +foreign import ccall "THTensor.h &THDoubleTensor_storage" + p_storage :: FunPtr (Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleStorage)) + +-- | p_storageOffset : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THDoubleTensor_storageOffset" + p_storageOffset :: FunPtr (Ptr C'THDoubleTensor -> IO CPtrdiff) + +-- | p_nDimension : Pointer to function : self -> int +foreign import ccall "THTensor.h &THDoubleTensor_nDimension" + p_nDimension :: FunPtr (Ptr C'THDoubleTensor -> IO CInt) + +-- | p_size : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THDoubleTensor_size" + p_size :: FunPtr (Ptr C'THDoubleTensor -> CInt -> IO CLLong) + +-- | p_stride : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THDoubleTensor_stride" + p_stride :: FunPtr (Ptr C'THDoubleTensor -> CInt -> IO CLLong) + +-- | p_newSizeOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THDoubleTensor_newSizeOf" + p_newSizeOf :: FunPtr (Ptr C'THDoubleTensor -> IO (Ptr C'THLongStorage)) + +-- | p_newStrideOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THDoubleTensor_newStrideOf" + p_newStrideOf :: FunPtr (Ptr C'THDoubleTensor -> IO (Ptr C'THLongStorage)) + +-- | p_data : Pointer to function : self -> real * +foreign import ccall "THTensor.h &THDoubleTensor_data" + p_data :: FunPtr (Ptr C'THDoubleTensor -> IO (Ptr CDouble)) + +-- | p_setFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THDoubleTensor_setFlag" + p_setFlag :: FunPtr (Ptr C'THDoubleTensor -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THDoubleTensor_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THDoubleTensor -> CChar -> IO ()) + +-- | p_new : Pointer to function : -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_new" + p_new :: FunPtr (IO (Ptr C'THDoubleTensor)) + +-- | p_newWithTensor : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithTensor" + p_newWithTensor :: FunPtr (Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithStorage : Pointer to function : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithStorage" + p_newWithStorage :: FunPtr (Ptr C'THDoubleStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithStorage1d : Pointer to function : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithStorage1d" + p_newWithStorage1d :: FunPtr (Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithStorage2d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithStorage2d" + p_newWithStorage2d :: FunPtr (Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithStorage3d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithStorage3d" + p_newWithStorage3d :: FunPtr (Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithStorage4d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithStorage4d" + p_newWithStorage4d :: FunPtr (Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithSize : Pointer to function : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithSize" + p_newWithSize :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithSize1d : Pointer to function : size0_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithSize1d" + p_newWithSize1d :: FunPtr (CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithSize2d : Pointer to function : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithSize2d" + p_newWithSize2d :: FunPtr (CLLong -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithSize3d : Pointer to function : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithSize3d" + p_newWithSize3d :: FunPtr (CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newWithSize4d : Pointer to function : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newWithSize4d" + p_newWithSize4d :: FunPtr (CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newClone : Pointer to function : self -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newClone" + p_newClone :: FunPtr (Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleTensor)) + +-- | p_newContiguous : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newContiguous" + p_newContiguous :: FunPtr (Ptr C'THDoubleTensor -> IO (Ptr C'THDoubleTensor)) + +-- | p_newSelect : Pointer to function : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newSelect" + p_newSelect :: FunPtr (Ptr C'THDoubleTensor -> CInt -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newNarrow : Pointer to function : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newNarrow" + p_newNarrow :: FunPtr (Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newTranspose : Pointer to function : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newTranspose" + p_newTranspose :: FunPtr (Ptr C'THDoubleTensor -> CInt -> CInt -> IO (Ptr C'THDoubleTensor)) + +-- | p_newUnfold : Pointer to function : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newUnfold" + p_newUnfold :: FunPtr (Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THDoubleTensor)) + +-- | p_newView : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newView" + p_newView :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor)) + +-- | p_newExpand : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THDoubleTensor_newExpand" + p_newExpand :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO (Ptr C'THDoubleTensor)) + +-- | p_expand : Pointer to function : r tensor size -> void +foreign import ccall "THTensor.h &THDoubleTensor_expand" + p_expand :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_expandNd : Pointer to function : rets ops count -> void +foreign import ccall "THTensor.h &THDoubleTensor_expandNd" + p_expandNd :: FunPtr (Ptr (Ptr C'THDoubleTensor) -> Ptr (Ptr C'THDoubleTensor) -> CInt -> IO ()) + +-- | p_resize : Pointer to function : tensor size stride -> void +foreign import ccall "THTensor.h &THDoubleTensor_resize" + p_resize :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_resizeAs : Pointer to function : tensor src -> void +foreign import ccall "THTensor.h &THDoubleTensor_resizeAs" + p_resizeAs :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_resizeNd : Pointer to function : tensor nDimension size stride -> void +foreign import ccall "THTensor.h &THDoubleTensor_resizeNd" + p_resizeNd :: FunPtr (Ptr C'THDoubleTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_resize1d : Pointer to function : tensor size0_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_resize1d" + p_resize1d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> IO ()) + +-- | p_resize2d : Pointer to function : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_resize2d" + p_resize2d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO ()) + +-- | p_resize3d : Pointer to function : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_resize3d" + p_resize3d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize4d : Pointer to function : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_resize4d" + p_resize4d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize5d : Pointer to function : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_resize5d" + p_resize5d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_set : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THDoubleTensor_set" + p_set :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_setStorage : Pointer to function : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_setStorage" + p_setStorage :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_setStorageNd : Pointer to function : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h &THDoubleTensor_setStorageNd" + p_setStorageNd :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_setStorage1d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_setStorage1d" + p_setStorage1d :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage2d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_setStorage2d" + p_setStorage2d :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage3d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_setStorage3d" + p_setStorage3d :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage4d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_setStorage4d" + p_setStorage4d :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_narrow : Pointer to function : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_narrow" + p_narrow :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_select : Pointer to function : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_select" + p_select :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CLLong -> IO ()) + +-- | p_transpose : Pointer to function : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_transpose" + p_transpose :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_unfold : Pointer to function : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_unfold" + p_unfold :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_squeeze : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THDoubleTensor_squeeze" + p_squeeze :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_squeeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_squeeze1d" + p_squeeze1d :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_unsqueeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THDoubleTensor_unsqueeze1d" + p_unsqueeze1d :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_isContiguous : Pointer to function : self -> int +foreign import ccall "THTensor.h &THDoubleTensor_isContiguous" + p_isContiguous :: FunPtr (Ptr C'THDoubleTensor -> IO CInt) + +-- | p_isSameSizeAs : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THDoubleTensor_isSameSizeAs" + p_isSameSizeAs :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CInt) + +-- | p_isSetTo : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THDoubleTensor_isSetTo" + p_isSetTo :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CInt) + +-- | p_isSize : Pointer to function : self dims -> int +foreign import ccall "THTensor.h &THDoubleTensor_isSize" + p_isSize :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO CInt) + +-- | p_nElement : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THDoubleTensor_nElement" + p_nElement :: FunPtr (Ptr C'THDoubleTensor -> IO CPtrdiff) + +-- | p_retain : Pointer to function : self -> void +foreign import ccall "THTensor.h &THDoubleTensor_retain" + p_retain :: FunPtr (Ptr C'THDoubleTensor -> IO ()) + +-- | p_free : Pointer to function : self -> void +foreign import ccall "THTensor.h &THDoubleTensor_free" + p_free :: FunPtr (Ptr C'THDoubleTensor -> IO ()) + +-- | p_freeCopyTo : Pointer to function : self dst -> void +foreign import ccall "THTensor.h &THDoubleTensor_freeCopyTo" + p_freeCopyTo :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_set1d : Pointer to function : tensor x0 value -> void +foreign import ccall "THTensor.h &THDoubleTensor_set1d" + p_set1d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CDouble -> IO ()) + +-- | p_set2d : Pointer to function : tensor x0 x1 value -> void +foreign import ccall "THTensor.h &THDoubleTensor_set2d" + p_set2d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> CDouble -> IO ()) + +-- | p_set3d : Pointer to function : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h &THDoubleTensor_set3d" + p_set3d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CDouble -> IO ()) + +-- | p_set4d : Pointer to function : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h &THDoubleTensor_set4d" + p_set4d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CDouble -> IO ()) + +-- | p_get1d : Pointer to function : tensor x0 -> real +foreign import ccall "THTensor.h &THDoubleTensor_get1d" + p_get1d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> IO CDouble) + +-- | p_get2d : Pointer to function : tensor x0 x1 -> real +foreign import ccall "THTensor.h &THDoubleTensor_get2d" + p_get2d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO CDouble) + +-- | p_get3d : Pointer to function : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h &THDoubleTensor_get3d" + p_get3d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> IO CDouble) + +-- | p_get4d : Pointer to function : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h &THDoubleTensor_get4d" + p_get4d :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CDouble) + +-- | p_desc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THDoubleTensor_desc" + p_desc :: FunPtr (Ptr C'THDoubleTensor -> IO (Ptr C'THDescBuff)) + +-- | p_sizeDesc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THDoubleTensor_sizeDesc" + p_sizeDesc :: FunPtr (Ptr C'THDoubleTensor -> IO (Ptr C'THDescBuff)) diff --git a/src/Torch/FFI/TH/Double/TensorConv.hs b/src/Torch/FFI/TH/Double/TensorConv.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/TensorConv.hs @@ -0,0 +1,272 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.TensorConv where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_validXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_validXCorr2Dptr" + c_validXCorr2Dptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2Dptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2Dptr = const c_validXCorr2Dptr_ + +-- | c_validConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_validConv2Dptr" + c_validConv2Dptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv2Dptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv2Dptr = const c_validConv2Dptr_ + +-- | c_fullXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_fullXCorr2Dptr" + c_fullXCorr2Dptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr2Dptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr2Dptr = const c_fullXCorr2Dptr_ + +-- | c_fullConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_fullConv2Dptr" + c_fullConv2Dptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv2Dptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv2Dptr = const c_fullConv2Dptr_ + +-- | c_validXCorr2DRevptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_validXCorr2DRevptr" + c_validXCorr2DRevptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2DRevptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2DRevptr = const c_validXCorr2DRevptr_ + +-- | c_conv2DRevger : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv2DRevger" + c_conv2DRevger_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevger :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO () +c_conv2DRevger = const c_conv2DRevger_ + +-- | c_conv2DRevgerm : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv2DRevgerm" + c_conv2DRevgerm_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevgerm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevgerm :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO () +c_conv2DRevgerm = const c_conv2DRevgerm_ + +-- | c_conv2Dger : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv2Dger" + c_conv2Dger_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dger :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dger = const c_conv2Dger_ + +-- | c_conv2Dmv : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv2Dmv" + c_conv2Dmv_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmv :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmv = const c_conv2Dmv_ + +-- | c_conv2Dmm : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv2Dmm" + c_conv2Dmm_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmm :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmm = const c_conv2Dmm_ + +-- | c_conv2Dmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv2Dmul" + c_conv2Dmul_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmul :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmul = const c_conv2Dmul_ + +-- | c_conv2Dcmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv2Dcmul" + c_conv2Dcmul_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dcmul :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dcmul = const c_conv2Dcmul_ + +-- | c_validXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_validXCorr3Dptr" + c_validXCorr3Dptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3Dptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3Dptr = const c_validXCorr3Dptr_ + +-- | c_validConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_validConv3Dptr" + c_validConv3Dptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv3Dptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv3Dptr = const c_validConv3Dptr_ + +-- | c_fullXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_fullXCorr3Dptr" + c_fullXCorr3Dptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr3Dptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr3Dptr = const c_fullXCorr3Dptr_ + +-- | c_fullConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_fullConv3Dptr" + c_fullConv3Dptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv3Dptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv3Dptr = const c_fullConv3Dptr_ + +-- | c_validXCorr3DRevptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_validXCorr3DRevptr" + c_validXCorr3DRevptr_ :: Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3DRevptr :: Ptr C'THState -> Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3DRevptr = const c_validXCorr3DRevptr_ + +-- | c_conv3DRevger : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv3DRevger" + c_conv3DRevger_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_conv3DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3DRevger :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> IO () +c_conv3DRevger = const c_conv3DRevger_ + +-- | c_conv3Dger : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv3Dger" + c_conv3Dger_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dger :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dger = const c_conv3Dger_ + +-- | c_conv3Dmv : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv3Dmv" + c_conv3Dmv_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmv :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmv = const c_conv3Dmv_ + +-- | c_conv3Dmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv3Dmul" + c_conv3Dmul_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmul :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmul = const c_conv3Dmul_ + +-- | c_conv3Dcmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THDoubleTensor_conv3Dcmul" + c_conv3Dcmul_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dcmul :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dcmul = const c_conv3Dcmul_ + +-- | p_validXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_validXCorr2Dptr" + p_validXCorr2Dptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_validConv2Dptr" + p_validConv2Dptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_fullXCorr2Dptr" + p_fullXCorr2Dptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_fullConv2Dptr" + p_fullConv2Dptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr2DRevptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_validXCorr2DRevptr" + p_validXCorr2DRevptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevger : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv2DRevger" + p_conv2DRevger :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevgerm : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv2DRevgerm" + p_conv2DRevgerm :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2Dger : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv2Dger" + p_conv2Dger :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmv : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv2Dmv" + p_conv2Dmv :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmm : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv2Dmm" + p_conv2Dmm :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv2Dmul" + p_conv2Dmul :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dcmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv2Dcmul" + p_conv2Dcmul :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_validXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_validXCorr3Dptr" + p_validXCorr3Dptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_validConv3Dptr" + p_validConv3Dptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_fullXCorr3Dptr" + p_fullXCorr3Dptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_fullConv3Dptr" + p_fullConv3Dptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr3DRevptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_validXCorr3DRevptr" + p_validXCorr3DRevptr :: FunPtr (Ptr CDouble -> CDouble -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> Ptr CDouble -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3DRevger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv3DRevger" + p_conv3DRevger :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3Dger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv3Dger" + p_conv3Dger :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmv : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv3Dmv" + p_conv3Dmv :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv3Dmul" + p_conv3Dmul :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dcmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THDoubleTensor_conv3Dcmul" + p_conv3Dcmul :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) diff --git a/src/Torch/FFI/TH/Double/TensorCopy.hs b/src/Torch/FFI/TH/Double/TensorCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/TensorCopy.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.TensorCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_copy : tensor src -> void +foreign import ccall "THTensorCopy.h THDoubleTensor_copy" + c_copy_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : tensor src -> void +foreign import ccall "THTensorCopy.h THDoubleTensor_copyByte" + c_copyByte_ :: Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : tensor src -> void +foreign import ccall "THTensorCopy.h THDoubleTensor_copyChar" + c_copyChar_ :: Ptr C'THDoubleTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THCharTensor -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : tensor src -> void +foreign import ccall "THTensorCopy.h THDoubleTensor_copyShort" + c_copyShort_ :: Ptr C'THDoubleTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THShortTensor -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : tensor src -> void +foreign import ccall "THTensorCopy.h THDoubleTensor_copyInt" + c_copyInt_ :: Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : tensor src -> void +foreign import ccall "THTensorCopy.h THDoubleTensor_copyLong" + c_copyLong_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : tensor src -> void +foreign import ccall "THTensorCopy.h THDoubleTensor_copyFloat" + c_copyFloat_ :: Ptr C'THDoubleTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THFloatTensor -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : tensor src -> void +foreign import ccall "THTensorCopy.h THDoubleTensor_copyDouble" + c_copyDouble_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : tensor src -> void +foreign import ccall "THTensorCopy.h THDoubleTensor_copyHalf" + c_copyHalf_ :: Ptr C'THDoubleTensor -> Ptr C'THHalfTensor -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THHalfTensor -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_copy : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THDoubleTensor_copy" + p_copy :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_copyByte : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THDoubleTensor_copyByte" + p_copyByte :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_copyChar : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THDoubleTensor_copyChar" + p_copyChar :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_copyShort : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THDoubleTensor_copyShort" + p_copyShort :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_copyInt : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THDoubleTensor_copyInt" + p_copyInt :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_copyLong : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THDoubleTensor_copyLong" + p_copyLong :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_copyFloat : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THDoubleTensor_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_copyDouble : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THDoubleTensor_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_copyHalf : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THDoubleTensor_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THHalfTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Double/TensorLapack.hs b/src/Torch/FFI/TH/Double/TensorLapack.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/TensorLapack.hs @@ -0,0 +1,224 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.TensorLapack where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_gesv : rb_ ra_ b_ a_ -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_gesv" + c_gesv_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_gesv_ with unused argument (for CTHState) to unify backpack signatures. +c_gesv :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_gesv = const c_gesv_ + +-- | c_trtrs : rb_ ra_ b_ a_ uplo trans diag -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_trtrs" + c_trtrs_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_trtrs_ with unused argument (for CTHState) to unify backpack signatures. +c_trtrs :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> Ptr CChar -> Ptr CChar -> IO () +c_trtrs = const c_trtrs_ + +-- | c_gels : rb_ ra_ b_ a_ -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_gels" + c_gels_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_gels_ with unused argument (for CTHState) to unify backpack signatures. +c_gels :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_gels = const c_gels_ + +-- | c_syev : re_ rv_ a_ jobz uplo -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_syev" + c_syev_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_syev_ with unused argument (for CTHState) to unify backpack signatures. +c_syev :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> Ptr CChar -> IO () +c_syev = const c_syev_ + +-- | c_geev : re_ rv_ a_ jobvr -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_geev" + c_geev_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () + +-- | alias of c_geev_ with unused argument (for CTHState) to unify backpack signatures. +c_geev :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () +c_geev = const c_geev_ + +-- | c_gesvd : ru_ rs_ rv_ a jobu -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_gesvd" + c_gesvd_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () + +-- | alias of c_gesvd_ with unused argument (for CTHState) to unify backpack signatures. +c_gesvd :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () +c_gesvd = const c_gesvd_ + +-- | c_gesvd2 : ru_ rs_ rv_ ra_ a jobu -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_gesvd2" + c_gesvd2_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () + +-- | alias of c_gesvd2_ with unused argument (for CTHState) to unify backpack signatures. +c_gesvd2 :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () +c_gesvd2 = const c_gesvd2_ + +-- | c_getri : ra_ a -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_getri" + c_getri_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_getri_ with unused argument (for CTHState) to unify backpack signatures. +c_getri :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_getri = const c_getri_ + +-- | c_potrf : ra_ a uplo -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_potrf" + c_potrf_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () + +-- | alias of c_potrf_ with unused argument (for CTHState) to unify backpack signatures. +c_potrf :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () +c_potrf = const c_potrf_ + +-- | c_potrs : rb_ b_ a_ uplo -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_potrs" + c_potrs_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () + +-- | alias of c_potrs_ with unused argument (for CTHState) to unify backpack signatures. +c_potrs :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () +c_potrs = const c_potrs_ + +-- | c_potri : ra_ a uplo -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_potri" + c_potri_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () + +-- | alias of c_potri_ with unused argument (for CTHState) to unify backpack signatures. +c_potri :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO () +c_potri = const c_potri_ + +-- | c_qr : rq_ rr_ a -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_qr" + c_qr_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_qr_ with unused argument (for CTHState) to unify backpack signatures. +c_qr :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_qr = const c_qr_ + +-- | c_geqrf : ra_ rtau_ a -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_geqrf" + c_geqrf_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_geqrf_ with unused argument (for CTHState) to unify backpack signatures. +c_geqrf :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_geqrf = const c_geqrf_ + +-- | c_orgqr : ra_ a tau -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_orgqr" + c_orgqr_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_orgqr_ with unused argument (for CTHState) to unify backpack signatures. +c_orgqr :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_orgqr = const c_orgqr_ + +-- | c_ormqr : ra_ a tau c side trans -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_ormqr" + c_ormqr_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_ormqr_ with unused argument (for CTHState) to unify backpack signatures. +c_ormqr :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> Ptr CChar -> IO () +c_ormqr = const c_ormqr_ + +-- | c_pstrf : ra_ rpiv_ a uplo tol -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_pstrf" + c_pstrf_ :: Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> CDouble -> IO () + +-- | alias of c_pstrf_ with unused argument (for CTHState) to unify backpack signatures. +c_pstrf :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> CDouble -> IO () +c_pstrf = const c_pstrf_ + +-- | c_btrifact : ra_ rpivots_ rinfo_ pivot a -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_btrifact" + c_btrifact_ :: Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_btrifact_ with unused argument (for CTHState) to unify backpack signatures. +c_btrifact :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THDoubleTensor -> IO () +c_btrifact = const c_btrifact_ + +-- | c_btrisolve : rb_ b atf pivots -> void +foreign import ccall "THTensorLapack.h THDoubleTensor_btrisolve" + c_btrisolve_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_btrisolve_ with unused argument (for CTHState) to unify backpack signatures. +c_btrisolve :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> IO () +c_btrisolve = const c_btrisolve_ + +-- | p_gesv : Pointer to function : rb_ ra_ b_ a_ -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_gesv" + p_gesv :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_trtrs : Pointer to function : rb_ ra_ b_ a_ uplo trans diag -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_trtrs" + p_trtrs :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_gels : Pointer to function : rb_ ra_ b_ a_ -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_gels" + p_gels :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_syev : Pointer to function : re_ rv_ a_ jobz uplo -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_syev" + p_syev :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_geev : Pointer to function : re_ rv_ a_ jobvr -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_geev" + p_geev :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO ()) + +-- | p_gesvd : Pointer to function : ru_ rs_ rv_ a jobu -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_gesvd" + p_gesvd :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO ()) + +-- | p_gesvd2 : Pointer to function : ru_ rs_ rv_ ra_ a jobu -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_gesvd2" + p_gesvd2 :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO ()) + +-- | p_getri : Pointer to function : ra_ a -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_getri" + p_getri :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_potrf : Pointer to function : ra_ a uplo -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_potrf" + p_potrf :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO ()) + +-- | p_potrs : Pointer to function : rb_ b_ a_ uplo -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_potrs" + p_potrs :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO ()) + +-- | p_potri : Pointer to function : ra_ a uplo -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_potri" + p_potri :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> IO ()) + +-- | p_qr : Pointer to function : rq_ rr_ a -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_qr" + p_qr :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_geqrf : Pointer to function : ra_ rtau_ a -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_geqrf" + p_geqrf :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_orgqr : Pointer to function : ra_ a tau -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_orgqr" + p_orgqr :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_ormqr : Pointer to function : ra_ a tau c side trans -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_ormqr" + p_ormqr :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_pstrf : Pointer to function : ra_ rpiv_ a uplo tol -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_pstrf" + p_pstrf :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> Ptr C'THDoubleTensor -> Ptr CChar -> CDouble -> IO ()) + +-- | p_btrifact : Pointer to function : ra_ rpivots_ rinfo_ pivot a -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_btrifact" + p_btrifact :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_btrisolve : Pointer to function : rb_ b atf pivots -> void +foreign import ccall "THTensorLapack.h &THDoubleTensor_btrisolve" + p_btrisolve :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THIntTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Double/TensorMath.hs b/src/Torch/FFI/TH/Double/TensorMath.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/TensorMath.hs @@ -0,0 +1,2000 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.TensorMath where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : r_ value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_fill" + c_fill_ :: Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_fill = const c_fill_ + +-- | c_zero : r_ -> void +foreign import ccall "THTensorMath.h THDoubleTensor_zero" + c_zero_ :: Ptr C'THDoubleTensor -> IO () + +-- | alias of c_zero_ with unused argument (for CTHState) to unify backpack signatures. +c_zero :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO () +c_zero = const c_zero_ + +-- | c_maskedFill : tensor mask value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_maskedFill" + c_maskedFill_ :: Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> CDouble -> IO () + +-- | alias of c_maskedFill_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedFill :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> CDouble -> IO () +c_maskedFill = const c_maskedFill_ + +-- | c_maskedCopy : tensor mask src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_maskedCopy" + c_maskedCopy_ :: Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_maskedCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedCopy :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> IO () +c_maskedCopy = const c_maskedCopy_ + +-- | c_maskedSelect : tensor src mask -> void +foreign import ccall "THTensorMath.h THDoubleTensor_maskedSelect" + c_maskedSelect_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_maskedSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedSelect :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> IO () +c_maskedSelect = const c_maskedSelect_ + +-- | c_nonzero : subscript tensor -> void +foreign import ccall "THTensorMath.h THDoubleTensor_nonzero" + c_nonzero_ :: Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_nonzero_ with unused argument (for CTHState) to unify backpack signatures. +c_nonzero :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () +c_nonzero = const c_nonzero_ + +-- | c_indexSelect : tensor src dim index -> void +foreign import ccall "THTensorMath.h THDoubleTensor_indexSelect" + c_indexSelect_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_indexSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_indexSelect :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_indexSelect = const c_indexSelect_ + +-- | c_indexCopy : tensor dim index src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_indexCopy" + c_indexCopy_ :: Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_indexCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_indexCopy :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () +c_indexCopy = const c_indexCopy_ + +-- | c_indexAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_indexAdd" + c_indexAdd_ :: Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_indexAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_indexAdd :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () +c_indexAdd = const c_indexAdd_ + +-- | c_indexFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THDoubleTensor_indexFill" + c_indexFill_ :: Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> CDouble -> IO () + +-- | alias of c_indexFill_ with unused argument (for CTHState) to unify backpack signatures. +c_indexFill :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> CDouble -> IO () +c_indexFill = const c_indexFill_ + +-- | c_take : tensor src index -> void +foreign import ccall "THTensorMath.h THDoubleTensor_take" + c_take_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_take_ with unused argument (for CTHState) to unify backpack signatures. +c_take :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> IO () +c_take = const c_take_ + +-- | c_put : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h THDoubleTensor_put" + c_put_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | alias of c_put_ with unused argument (for CTHState) to unify backpack signatures. +c_put :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> IO () +c_put = const c_put_ + +-- | c_gather : tensor src dim index -> void +foreign import ccall "THTensorMath.h THDoubleTensor_gather" + c_gather_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_gather_ with unused argument (for CTHState) to unify backpack signatures. +c_gather :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_gather = const c_gather_ + +-- | c_scatter : tensor dim index src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_scatter" + c_scatter_ :: Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_scatter_ with unused argument (for CTHState) to unify backpack signatures. +c_scatter :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () +c_scatter = const c_scatter_ + +-- | c_scatterAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_scatterAdd" + c_scatterAdd_ :: Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_scatterAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterAdd :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () +c_scatterAdd = const c_scatterAdd_ + +-- | c_scatterFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THDoubleTensor_scatterFill" + c_scatterFill_ :: Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> CDouble -> IO () + +-- | alias of c_scatterFill_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterFill :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> CDouble -> IO () +c_scatterFill = const c_scatterFill_ + +-- | c_dot : t src -> accreal +foreign import ccall "THTensorMath.h THDoubleTensor_dot" + c_dot_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CDouble + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CDouble +c_dot = const c_dot_ + +-- | c_minall : t -> real +foreign import ccall "THTensorMath.h THDoubleTensor_minall" + c_minall_ :: Ptr C'THDoubleTensor -> IO CDouble + +-- | alias of c_minall_ with unused argument (for CTHState) to unify backpack signatures. +c_minall :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CDouble +c_minall = const c_minall_ + +-- | c_maxall : t -> real +foreign import ccall "THTensorMath.h THDoubleTensor_maxall" + c_maxall_ :: Ptr C'THDoubleTensor -> IO CDouble + +-- | alias of c_maxall_ with unused argument (for CTHState) to unify backpack signatures. +c_maxall :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CDouble +c_maxall = const c_maxall_ + +-- | c_medianall : t -> real +foreign import ccall "THTensorMath.h THDoubleTensor_medianall" + c_medianall_ :: Ptr C'THDoubleTensor -> IO CDouble + +-- | alias of c_medianall_ with unused argument (for CTHState) to unify backpack signatures. +c_medianall :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CDouble +c_medianall = const c_medianall_ + +-- | c_sumall : t -> accreal +foreign import ccall "THTensorMath.h THDoubleTensor_sumall" + c_sumall_ :: Ptr C'THDoubleTensor -> IO CDouble + +-- | alias of c_sumall_ with unused argument (for CTHState) to unify backpack signatures. +c_sumall :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CDouble +c_sumall = const c_sumall_ + +-- | c_prodall : t -> accreal +foreign import ccall "THTensorMath.h THDoubleTensor_prodall" + c_prodall_ :: Ptr C'THDoubleTensor -> IO CDouble + +-- | alias of c_prodall_ with unused argument (for CTHState) to unify backpack signatures. +c_prodall :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CDouble +c_prodall = const c_prodall_ + +-- | c_neg : self src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_neg" + c_neg_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_neg = const c_neg_ + +-- | c_cinv : self src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cinv" + c_cinv_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cinv_ with unused argument (for CTHState) to unify backpack signatures. +c_cinv :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cinv = const c_cinv_ + +-- | c_add : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_add" + c_add_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_add_ with unused argument (for CTHState) to unify backpack signatures. +c_add :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_add = const c_add_ + +-- | c_sub : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_sub" + c_sub_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_sub_ with unused argument (for CTHState) to unify backpack signatures. +c_sub :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_sub = const c_sub_ + +-- | c_add_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THDoubleTensor_add_scaled" + c_add_scaled_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | alias of c_add_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_add_scaled :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () +c_add_scaled = const c_add_scaled_ + +-- | c_sub_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THDoubleTensor_sub_scaled" + c_sub_scaled_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | alias of c_sub_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_sub_scaled :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () +c_sub_scaled = const c_sub_scaled_ + +-- | c_mul : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_mul" + c_mul_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_mul_ with unused argument (for CTHState) to unify backpack signatures. +c_mul :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_mul = const c_mul_ + +-- | c_div : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_div" + c_div_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_div_ with unused argument (for CTHState) to unify backpack signatures. +c_div :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_div = const c_div_ + +-- | c_lshift : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_lshift" + c_lshift_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_lshift_ with unused argument (for CTHState) to unify backpack signatures. +c_lshift :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_lshift = const c_lshift_ + +-- | c_rshift : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_rshift" + c_rshift_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_rshift_ with unused argument (for CTHState) to unify backpack signatures. +c_rshift :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_rshift = const c_rshift_ + +-- | c_fmod : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_fmod" + c_fmod_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_fmod_ with unused argument (for CTHState) to unify backpack signatures. +c_fmod :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_fmod = const c_fmod_ + +-- | c_remainder : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_remainder" + c_remainder_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_remainder_ with unused argument (for CTHState) to unify backpack signatures. +c_remainder :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_remainder = const c_remainder_ + +-- | c_clamp : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_clamp" + c_clamp_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () + +-- | alias of c_clamp_ with unused argument (for CTHState) to unify backpack signatures. +c_clamp :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO () +c_clamp = const c_clamp_ + +-- | c_bitand : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_bitand" + c_bitand_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_bitand_ with unused argument (for CTHState) to unify backpack signatures. +c_bitand :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_bitand = const c_bitand_ + +-- | c_bitor : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_bitor" + c_bitor_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_bitor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitor :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_bitor = const c_bitor_ + +-- | c_bitxor : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_bitxor" + c_bitxor_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_bitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitxor :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_bitxor = const c_bitxor_ + +-- | c_cadd : r_ t value src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cadd" + c_cadd_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> IO () +c_cadd = const c_cadd_ + +-- | c_csub : self src1 value src2 -> void +foreign import ccall "THTensorMath.h THDoubleTensor_csub" + c_csub_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_csub_ with unused argument (for CTHState) to unify backpack signatures. +c_csub :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> IO () +c_csub = const c_csub_ + +-- | c_cmul : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cmul" + c_cmul_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cmul = const c_cmul_ + +-- | c_cpow : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cpow" + c_cpow_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cpow_ with unused argument (for CTHState) to unify backpack signatures. +c_cpow :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cpow = const c_cpow_ + +-- | c_cdiv : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cdiv" + c_cdiv_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cdiv = const c_cdiv_ + +-- | c_clshift : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_clshift" + c_clshift_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_clshift_ with unused argument (for CTHState) to unify backpack signatures. +c_clshift :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_clshift = const c_clshift_ + +-- | c_crshift : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_crshift" + c_crshift_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_crshift_ with unused argument (for CTHState) to unify backpack signatures. +c_crshift :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_crshift = const c_crshift_ + +-- | c_cfmod : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cfmod" + c_cfmod_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cfmod_ with unused argument (for CTHState) to unify backpack signatures. +c_cfmod :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cfmod = const c_cfmod_ + +-- | c_cremainder : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cremainder" + c_cremainder_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cremainder_ with unused argument (for CTHState) to unify backpack signatures. +c_cremainder :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cremainder = const c_cremainder_ + +-- | c_cbitand : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cbitand" + c_cbitand_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cbitand_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitand :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cbitand = const c_cbitand_ + +-- | c_cbitor : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cbitor" + c_cbitor_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cbitor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitor :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cbitor = const c_cbitor_ + +-- | c_cbitxor : r_ t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cbitxor" + c_cbitxor_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cbitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitxor :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cbitxor = const c_cbitxor_ + +-- | c_addcmul : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THDoubleTensor_addcmul" + c_addcmul_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_addcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_addcmul :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_addcmul = const c_addcmul_ + +-- | c_addcdiv : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THDoubleTensor_addcdiv" + c_addcdiv_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_addcdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_addcdiv :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_addcdiv = const c_addcdiv_ + +-- | c_addmv : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h THDoubleTensor_addmv" + c_addmv_ :: Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_addmv_ with unused argument (for CTHState) to unify backpack signatures. +c_addmv :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_addmv = const c_addmv_ + +-- | c_addmm : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h THDoubleTensor_addmm" + c_addmm_ :: Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_addmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addmm :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_addmm = const c_addmm_ + +-- | c_addr : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h THDoubleTensor_addr" + c_addr_ :: Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_addr_ with unused argument (for CTHState) to unify backpack signatures. +c_addr :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_addr = const c_addr_ + +-- | c_addbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THDoubleTensor_addbmm" + c_addbmm_ :: Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_addbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addbmm :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_addbmm = const c_addbmm_ + +-- | c_baddbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THDoubleTensor_baddbmm" + c_baddbmm_ :: Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_baddbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_baddbmm :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_baddbmm = const c_baddbmm_ + +-- | c_match : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h THDoubleTensor_match" + c_match_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_match_ with unused argument (for CTHState) to unify backpack signatures. +c_match :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_match = const c_match_ + +-- | c_numel : t -> ptrdiff_t +foreign import ccall "THTensorMath.h THDoubleTensor_numel" + c_numel_ :: Ptr C'THDoubleTensor -> IO CPtrdiff + +-- | alias of c_numel_ with unused argument (for CTHState) to unify backpack signatures. +c_numel :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CPtrdiff +c_numel = const c_numel_ + +-- | c_preserveReduceDimSemantics : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_preserveReduceDimSemantics" + c_preserveReduceDimSemantics_ :: Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_preserveReduceDimSemantics_ with unused argument (for CTHState) to unify backpack signatures. +c_preserveReduceDimSemantics :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO () +c_preserveReduceDimSemantics = const c_preserveReduceDimSemantics_ + +-- | c_max : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_max" + c_max_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_max_ with unused argument (for CTHState) to unify backpack signatures. +c_max :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_max = const c_max_ + +-- | c_min : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_min" + c_min_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_min_ with unused argument (for CTHState) to unify backpack signatures. +c_min :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_min = const c_min_ + +-- | c_kthvalue : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_kthvalue" + c_kthvalue_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CLLong -> CInt -> CInt -> IO () + +-- | alias of c_kthvalue_ with unused argument (for CTHState) to unify backpack signatures. +c_kthvalue :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CLLong -> CInt -> CInt -> IO () +c_kthvalue = const c_kthvalue_ + +-- | c_mode : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_mode" + c_mode_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_mode_ with unused argument (for CTHState) to unify backpack signatures. +c_mode :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_mode = const c_mode_ + +-- | c_median : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_median" + c_median_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_median_ with unused argument (for CTHState) to unify backpack signatures. +c_median :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_median = const c_median_ + +-- | c_sum : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_sum" + c_sum_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_sum_ with unused argument (for CTHState) to unify backpack signatures. +c_sum :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_sum = const c_sum_ + +-- | c_prod : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_prod" + c_prod_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_prod_ with unused argument (for CTHState) to unify backpack signatures. +c_prod :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_prod = const c_prod_ + +-- | c_cumsum : r_ t dimension -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cumsum" + c_cumsum_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | alias of c_cumsum_ with unused argument (for CTHState) to unify backpack signatures. +c_cumsum :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () +c_cumsum = const c_cumsum_ + +-- | c_cumprod : r_ t dimension -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cumprod" + c_cumprod_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | alias of c_cumprod_ with unused argument (for CTHState) to unify backpack signatures. +c_cumprod :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () +c_cumprod = const c_cumprod_ + +-- | c_sign : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_sign" + c_sign_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_sign_ with unused argument (for CTHState) to unify backpack signatures. +c_sign :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_sign = const c_sign_ + +-- | c_trace : t -> accreal +foreign import ccall "THTensorMath.h THDoubleTensor_trace" + c_trace_ :: Ptr C'THDoubleTensor -> IO CDouble + +-- | alias of c_trace_ with unused argument (for CTHState) to unify backpack signatures. +c_trace :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CDouble +c_trace = const c_trace_ + +-- | c_cross : r_ a b dimension -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cross" + c_cross_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | alias of c_cross_ with unused argument (for CTHState) to unify backpack signatures. +c_cross :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () +c_cross = const c_cross_ + +-- | c_cmax : r t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cmax" + c_cmax_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cmax_ with unused argument (for CTHState) to unify backpack signatures. +c_cmax :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cmax = const c_cmax_ + +-- | c_cmin : r t src -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cmin" + c_cmin_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cmin_ with unused argument (for CTHState) to unify backpack signatures. +c_cmin :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cmin = const c_cmin_ + +-- | c_cmaxValue : r t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cmaxValue" + c_cmaxValue_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_cmaxValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cmaxValue :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_cmaxValue = const c_cmaxValue_ + +-- | c_cminValue : r t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cminValue" + c_cminValue_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_cminValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cminValue :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_cminValue = const c_cminValue_ + +-- | c_zeros : r_ size -> void +foreign import ccall "THTensorMath.h THDoubleTensor_zeros" + c_zeros_ :: Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_zeros_ with unused argument (for CTHState) to unify backpack signatures. +c_zeros :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO () +c_zeros = const c_zeros_ + +-- | c_zerosLike : r_ input -> void +foreign import ccall "THTensorMath.h THDoubleTensor_zerosLike" + c_zerosLike_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_zerosLike_ with unused argument (for CTHState) to unify backpack signatures. +c_zerosLike :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_zerosLike = const c_zerosLike_ + +-- | c_ones : r_ size -> void +foreign import ccall "THTensorMath.h THDoubleTensor_ones" + c_ones_ :: Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_ones_ with unused argument (for CTHState) to unify backpack signatures. +c_ones :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO () +c_ones = const c_ones_ + +-- | c_onesLike : r_ input -> void +foreign import ccall "THTensorMath.h THDoubleTensor_onesLike" + c_onesLike_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_onesLike_ with unused argument (for CTHState) to unify backpack signatures. +c_onesLike :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_onesLike = const c_onesLike_ + +-- | c_diag : r_ t k -> void +foreign import ccall "THTensorMath.h THDoubleTensor_diag" + c_diag_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | alias of c_diag_ with unused argument (for CTHState) to unify backpack signatures. +c_diag :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () +c_diag = const c_diag_ + +-- | c_eye : r_ n m -> void +foreign import ccall "THTensorMath.h THDoubleTensor_eye" + c_eye_ :: Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_eye_ with unused argument (for CTHState) to unify backpack signatures. +c_eye :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO () +c_eye = const c_eye_ + +-- | c_arange : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THDoubleTensor_arange" + c_arange_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> CDouble -> IO () + +-- | alias of c_arange_ with unused argument (for CTHState) to unify backpack signatures. +c_arange :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CDouble -> IO () +c_arange = const c_arange_ + +-- | c_range : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THDoubleTensor_range" + c_range_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> CDouble -> IO () + +-- | alias of c_range_ with unused argument (for CTHState) to unify backpack signatures. +c_range :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CDouble -> IO () +c_range = const c_range_ + +-- | c_randperm : r_ _generator n -> void +foreign import ccall "THTensorMath.h THDoubleTensor_randperm" + c_randperm_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_randperm_ with unused argument (for CTHState) to unify backpack signatures. +c_randperm :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_randperm = const c_randperm_ + +-- | c_reshape : r_ t size -> void +foreign import ccall "THTensorMath.h THDoubleTensor_reshape" + c_reshape_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_reshape_ with unused argument (for CTHState) to unify backpack signatures. +c_reshape :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO () +c_reshape = const c_reshape_ + +-- | c_sort : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h THDoubleTensor_sort" + c_sort_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_sort_ with unused argument (for CTHState) to unify backpack signatures. +c_sort :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_sort = const c_sort_ + +-- | c_topk : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h THDoubleTensor_topk" + c_topk_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CLLong -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_topk_ with unused argument (for CTHState) to unify backpack signatures. +c_topk :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CLLong -> CInt -> CInt -> CInt -> IO () +c_topk = const c_topk_ + +-- | c_tril : r_ t k -> void +foreign import ccall "THTensorMath.h THDoubleTensor_tril" + c_tril_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO () + +-- | alias of c_tril_ with unused argument (for CTHState) to unify backpack signatures. +c_tril :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO () +c_tril = const c_tril_ + +-- | c_triu : r_ t k -> void +foreign import ccall "THTensorMath.h THDoubleTensor_triu" + c_triu_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO () + +-- | alias of c_triu_ with unused argument (for CTHState) to unify backpack signatures. +c_triu :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO () +c_triu = const c_triu_ + +-- | c_cat : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cat" + c_cat_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () + +-- | alias of c_cat_ with unused argument (for CTHState) to unify backpack signatures. +c_cat :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO () +c_cat = const c_cat_ + +-- | c_catArray : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h THDoubleTensor_catArray" + c_catArray_ :: Ptr C'THDoubleTensor -> Ptr (Ptr C'THDoubleTensor) -> CInt -> CInt -> IO () + +-- | alias of c_catArray_ with unused argument (for CTHState) to unify backpack signatures. +c_catArray :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr (Ptr C'THDoubleTensor) -> CInt -> CInt -> IO () +c_catArray = const c_catArray_ + +-- | c_equal : ta tb -> int +foreign import ccall "THTensorMath.h THDoubleTensor_equal" + c_equal_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CInt + +-- | alias of c_equal_ with unused argument (for CTHState) to unify backpack signatures. +c_equal :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CInt +c_equal = const c_equal_ + +-- | c_ltValue : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_ltValue" + c_ltValue_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_ltValue_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_ltValue = const c_ltValue_ + +-- | c_leValue : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_leValue" + c_leValue_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_leValue_ with unused argument (for CTHState) to unify backpack signatures. +c_leValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_leValue = const c_leValue_ + +-- | c_gtValue : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_gtValue" + c_gtValue_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_gtValue_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_gtValue = const c_gtValue_ + +-- | c_geValue : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_geValue" + c_geValue_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_geValue_ with unused argument (for CTHState) to unify backpack signatures. +c_geValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_geValue = const c_geValue_ + +-- | c_neValue : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_neValue" + c_neValue_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_neValue_ with unused argument (for CTHState) to unify backpack signatures. +c_neValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_neValue = const c_neValue_ + +-- | c_eqValue : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_eqValue" + c_eqValue_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_eqValue_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_eqValue = const c_eqValue_ + +-- | c_ltValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_ltValueT" + c_ltValueT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_ltValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValueT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_ltValueT = const c_ltValueT_ + +-- | c_leValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_leValueT" + c_leValueT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_leValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_leValueT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_leValueT = const c_leValueT_ + +-- | c_gtValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_gtValueT" + c_gtValueT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_gtValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValueT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_gtValueT = const c_gtValueT_ + +-- | c_geValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_geValueT" + c_geValueT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_geValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_geValueT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_geValueT = const c_geValueT_ + +-- | c_neValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_neValueT" + c_neValueT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_neValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_neValueT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_neValueT = const c_neValueT_ + +-- | c_eqValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_eqValueT" + c_eqValueT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_eqValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValueT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_eqValueT = const c_eqValueT_ + +-- | c_ltTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_ltTensor" + c_ltTensor_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_ltTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_ltTensor = const c_ltTensor_ + +-- | c_leTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_leTensor" + c_leTensor_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_leTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_leTensor = const c_leTensor_ + +-- | c_gtTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_gtTensor" + c_gtTensor_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_gtTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_gtTensor = const c_gtTensor_ + +-- | c_geTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_geTensor" + c_geTensor_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_geTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_geTensor = const c_geTensor_ + +-- | c_neTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_neTensor" + c_neTensor_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_neTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_neTensor = const c_neTensor_ + +-- | c_eqTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_eqTensor" + c_eqTensor_ :: Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_eqTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_eqTensor = const c_eqTensor_ + +-- | c_ltTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_ltTensorT" + c_ltTensorT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_ltTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensorT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_ltTensorT = const c_ltTensorT_ + +-- | c_leTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_leTensorT" + c_leTensorT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_leTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensorT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_leTensorT = const c_leTensorT_ + +-- | c_gtTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_gtTensorT" + c_gtTensorT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_gtTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensorT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_gtTensorT = const c_gtTensorT_ + +-- | c_geTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_geTensorT" + c_geTensorT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_geTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensorT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_geTensorT = const c_geTensorT_ + +-- | c_neTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_neTensorT" + c_neTensorT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_neTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensorT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_neTensorT = const c_neTensorT_ + +-- | c_eqTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THDoubleTensor_eqTensorT" + c_eqTensorT_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_eqTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensorT :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_eqTensorT = const c_eqTensorT_ + +-- | c_abs : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_abs" + c_abs_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_abs = const c_abs_ + +-- | c_sigmoid : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_sigmoid" + c_sigmoid_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_sigmoid_ with unused argument (for CTHState) to unify backpack signatures. +c_sigmoid :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_sigmoid = const c_sigmoid_ + +-- | c_log : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_log" + c_log_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_log_ with unused argument (for CTHState) to unify backpack signatures. +c_log :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_log = const c_log_ + +-- | c_lgamma : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_lgamma" + c_lgamma_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_lgamma_ with unused argument (for CTHState) to unify backpack signatures. +c_lgamma :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_lgamma = const c_lgamma_ + +-- | c_digamma : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_digamma" + c_digamma_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_digamma_ with unused argument (for CTHState) to unify backpack signatures. +c_digamma :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_digamma = const c_digamma_ + +-- | c_trigamma : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_trigamma" + c_trigamma_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_trigamma_ with unused argument (for CTHState) to unify backpack signatures. +c_trigamma :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_trigamma = const c_trigamma_ + +-- | c_polygamma : r_ n t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_polygamma" + c_polygamma_ :: Ptr C'THDoubleTensor -> CLLong -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_polygamma_ with unused argument (for CTHState) to unify backpack signatures. +c_polygamma :: Ptr C'THState -> Ptr C'THDoubleTensor -> CLLong -> Ptr C'THDoubleTensor -> IO () +c_polygamma = const c_polygamma_ + +-- | c_log1p : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_log1p" + c_log1p_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_log1p_ with unused argument (for CTHState) to unify backpack signatures. +c_log1p :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_log1p = const c_log1p_ + +-- | c_exp : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_exp" + c_exp_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_exp_ with unused argument (for CTHState) to unify backpack signatures. +c_exp :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_exp = const c_exp_ + +-- | c_expm1 : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_expm1" + c_expm1_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_expm1_ with unused argument (for CTHState) to unify backpack signatures. +c_expm1 :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_expm1 = const c_expm1_ + +-- | c_cos : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cos" + c_cos_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cos_ with unused argument (for CTHState) to unify backpack signatures. +c_cos :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cos = const c_cos_ + +-- | c_acos : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_acos" + c_acos_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_acos_ with unused argument (for CTHState) to unify backpack signatures. +c_acos :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_acos = const c_acos_ + +-- | c_cosh : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_cosh" + c_cosh_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_cosh_ with unused argument (for CTHState) to unify backpack signatures. +c_cosh :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_cosh = const c_cosh_ + +-- | c_sin : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_sin" + c_sin_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_sin_ with unused argument (for CTHState) to unify backpack signatures. +c_sin :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_sin = const c_sin_ + +-- | c_asin : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_asin" + c_asin_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_asin_ with unused argument (for CTHState) to unify backpack signatures. +c_asin :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_asin = const c_asin_ + +-- | c_sinh : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_sinh" + c_sinh_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_sinh_ with unused argument (for CTHState) to unify backpack signatures. +c_sinh :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_sinh = const c_sinh_ + +-- | c_tan : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_tan" + c_tan_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_tan_ with unused argument (for CTHState) to unify backpack signatures. +c_tan :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_tan = const c_tan_ + +-- | c_atan : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_atan" + c_atan_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_atan_ with unused argument (for CTHState) to unify backpack signatures. +c_atan :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_atan = const c_atan_ + +-- | c_atan2 : r_ tx ty -> void +foreign import ccall "THTensorMath.h THDoubleTensor_atan2" + c_atan2_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_atan2_ with unused argument (for CTHState) to unify backpack signatures. +c_atan2 :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_atan2 = const c_atan2_ + +-- | c_tanh : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_tanh" + c_tanh_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_tanh_ with unused argument (for CTHState) to unify backpack signatures. +c_tanh :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_tanh = const c_tanh_ + +-- | c_erf : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_erf" + c_erf_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_erf_ with unused argument (for CTHState) to unify backpack signatures. +c_erf :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_erf = const c_erf_ + +-- | c_erfinv : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_erfinv" + c_erfinv_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_erfinv_ with unused argument (for CTHState) to unify backpack signatures. +c_erfinv :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_erfinv = const c_erfinv_ + +-- | c_pow : r_ t value -> void +foreign import ccall "THTensorMath.h THDoubleTensor_pow" + c_pow_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_pow_ with unused argument (for CTHState) to unify backpack signatures. +c_pow :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_pow = const c_pow_ + +-- | c_tpow : r_ value t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_tpow" + c_tpow_ :: Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_tpow_ with unused argument (for CTHState) to unify backpack signatures. +c_tpow :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> IO () +c_tpow = const c_tpow_ + +-- | c_sqrt : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_sqrt" + c_sqrt_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_sqrt_ with unused argument (for CTHState) to unify backpack signatures. +c_sqrt :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_sqrt = const c_sqrt_ + +-- | c_rsqrt : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_rsqrt" + c_rsqrt_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_rsqrt_ with unused argument (for CTHState) to unify backpack signatures. +c_rsqrt :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_rsqrt = const c_rsqrt_ + +-- | c_ceil : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_ceil" + c_ceil_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_ceil_ with unused argument (for CTHState) to unify backpack signatures. +c_ceil :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_ceil = const c_ceil_ + +-- | c_floor : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_floor" + c_floor_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_floor_ with unused argument (for CTHState) to unify backpack signatures. +c_floor :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_floor = const c_floor_ + +-- | c_round : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_round" + c_round_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_round_ with unused argument (for CTHState) to unify backpack signatures. +c_round :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_round = const c_round_ + +-- | c_trunc : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_trunc" + c_trunc_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_trunc_ with unused argument (for CTHState) to unify backpack signatures. +c_trunc :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_trunc = const c_trunc_ + +-- | c_frac : r_ t -> void +foreign import ccall "THTensorMath.h THDoubleTensor_frac" + c_frac_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_frac_ with unused argument (for CTHState) to unify backpack signatures. +c_frac :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_frac = const c_frac_ + +-- | c_lerp : r_ a b weight -> void +foreign import ccall "THTensorMath.h THDoubleTensor_lerp" + c_lerp_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_lerp_ with unused argument (for CTHState) to unify backpack signatures. +c_lerp :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_lerp = const c_lerp_ + +-- | c_mean : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_mean" + c_mean_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_mean_ with unused argument (for CTHState) to unify backpack signatures. +c_mean :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_mean = const c_mean_ + +-- | c_std : r_ t dimension biased keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_std" + c_std_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_std_ with unused argument (for CTHState) to unify backpack signatures. +c_std :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO () +c_std = const c_std_ + +-- | c_var : r_ t dimension biased keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_var" + c_var_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_var_ with unused argument (for CTHState) to unify backpack signatures. +c_var :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO () +c_var = const c_var_ + +-- | c_norm : r_ t value dimension keepdim -> void +foreign import ccall "THTensorMath.h THDoubleTensor_norm" + c_norm_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CInt -> IO () + +-- | alias of c_norm_ with unused argument (for CTHState) to unify backpack signatures. +c_norm :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CInt -> IO () +c_norm = const c_norm_ + +-- | c_renorm : r_ t value dimension maxnorm -> void +foreign import ccall "THTensorMath.h THDoubleTensor_renorm" + c_renorm_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CDouble -> IO () + +-- | alias of c_renorm_ with unused argument (for CTHState) to unify backpack signatures. +c_renorm :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CDouble -> IO () +c_renorm = const c_renorm_ + +-- | c_dist : a b value -> accreal +foreign import ccall "THTensorMath.h THDoubleTensor_dist" + c_dist_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO CDouble + +-- | alias of c_dist_ with unused argument (for CTHState) to unify backpack signatures. +c_dist :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO CDouble +c_dist = const c_dist_ + +-- | c_histc : hist tensor nbins minvalue maxvalue -> void +foreign import ccall "THTensorMath.h THDoubleTensor_histc" + c_histc_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CDouble -> CDouble -> IO () + +-- | alias of c_histc_ with unused argument (for CTHState) to unify backpack signatures. +c_histc :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CDouble -> CDouble -> IO () +c_histc = const c_histc_ + +-- | c_bhistc : hist tensor nbins minvalue maxvalue -> void +foreign import ccall "THTensorMath.h THDoubleTensor_bhistc" + c_bhistc_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CDouble -> CDouble -> IO () + +-- | alias of c_bhistc_ with unused argument (for CTHState) to unify backpack signatures. +c_bhistc :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CDouble -> CDouble -> IO () +c_bhistc = const c_bhistc_ + +-- | c_meanall : self -> accreal +foreign import ccall "THTensorMath.h THDoubleTensor_meanall" + c_meanall_ :: Ptr C'THDoubleTensor -> IO CDouble + +-- | alias of c_meanall_ with unused argument (for CTHState) to unify backpack signatures. +c_meanall :: Ptr C'THState -> Ptr C'THDoubleTensor -> IO CDouble +c_meanall = const c_meanall_ + +-- | c_varall : self biased -> accreal +foreign import ccall "THTensorMath.h THDoubleTensor_varall" + c_varall_ :: Ptr C'THDoubleTensor -> CInt -> IO CDouble + +-- | alias of c_varall_ with unused argument (for CTHState) to unify backpack signatures. +c_varall :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> IO CDouble +c_varall = const c_varall_ + +-- | c_stdall : self biased -> accreal +foreign import ccall "THTensorMath.h THDoubleTensor_stdall" + c_stdall_ :: Ptr C'THDoubleTensor -> CInt -> IO CDouble + +-- | alias of c_stdall_ with unused argument (for CTHState) to unify backpack signatures. +c_stdall :: Ptr C'THState -> Ptr C'THDoubleTensor -> CInt -> IO CDouble +c_stdall = const c_stdall_ + +-- | c_normall : t value -> accreal +foreign import ccall "THTensorMath.h THDoubleTensor_normall" + c_normall_ :: Ptr C'THDoubleTensor -> CDouble -> IO CDouble + +-- | alias of c_normall_ with unused argument (for CTHState) to unify backpack signatures. +c_normall :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> IO CDouble +c_normall = const c_normall_ + +-- | c_linspace : r_ a b n -> void +foreign import ccall "THTensorMath.h THDoubleTensor_linspace" + c_linspace_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> CLLong -> IO () + +-- | alias of c_linspace_ with unused argument (for CTHState) to unify backpack signatures. +c_linspace :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CLLong -> IO () +c_linspace = const c_linspace_ + +-- | c_logspace : r_ a b n -> void +foreign import ccall "THTensorMath.h THDoubleTensor_logspace" + c_logspace_ :: Ptr C'THDoubleTensor -> CDouble -> CDouble -> CLLong -> IO () + +-- | alias of c_logspace_ with unused argument (for CTHState) to unify backpack signatures. +c_logspace :: Ptr C'THState -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> CLLong -> IO () +c_logspace = const c_logspace_ + +-- | c_rand : r_ _generator size -> void +foreign import ccall "THTensorMath.h THDoubleTensor_rand" + c_rand_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO () + +-- | alias of c_rand_ with unused argument (for CTHState) to unify backpack signatures. +c_rand :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO () +c_rand = const c_rand_ + +-- | c_randn : r_ _generator size -> void +foreign import ccall "THTensorMath.h THDoubleTensor_randn" + c_randn_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO () + +-- | alias of c_randn_ with unused argument (for CTHState) to unify backpack signatures. +c_randn :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO () +c_randn = const c_randn_ + +-- | c_dirichlet_grad : self x alpha total -> void +foreign import ccall "THTensorMath.h THDoubleTensor_dirichlet_grad" + c_dirichlet_grad_ :: Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_dirichlet_grad_ with unused argument (for CTHState) to unify backpack signatures. +c_dirichlet_grad :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_dirichlet_grad = const c_dirichlet_grad_ + +-- | p_fill : Pointer to function : r_ value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_fill" + p_fill :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_zero : Pointer to function : r_ -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_zero" + p_zero :: FunPtr (Ptr C'THDoubleTensor -> IO ()) + +-- | p_maskedFill : Pointer to function : tensor mask value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_maskedFill" + p_maskedFill :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> CDouble -> IO ()) + +-- | p_maskedCopy : Pointer to function : tensor mask src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_maskedCopy" + p_maskedCopy :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_maskedSelect : Pointer to function : tensor src mask -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_maskedSelect" + p_maskedSelect :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_nonzero : Pointer to function : subscript tensor -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_nonzero" + p_nonzero :: FunPtr (Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_indexSelect : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_indexSelect" + p_indexSelect :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexCopy : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_indexCopy" + p_indexCopy :: FunPtr (Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_indexAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_indexAdd" + p_indexAdd :: FunPtr (Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_indexFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_indexFill" + p_indexFill :: FunPtr (Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> CDouble -> IO ()) + +-- | p_take : Pointer to function : tensor src index -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_take" + p_take :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_put : Pointer to function : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_put" + p_put :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_gather : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_gather" + p_gather :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_scatter : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_scatter" + p_scatter :: FunPtr (Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_scatterAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_scatterAdd" + p_scatterAdd :: FunPtr (Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_scatterFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_scatterFill" + p_scatterFill :: FunPtr (Ptr C'THDoubleTensor -> CInt -> Ptr C'THLongTensor -> CDouble -> IO ()) + +-- | p_dot : Pointer to function : t src -> accreal +foreign import ccall "THTensorMath.h &THDoubleTensor_dot" + p_dot :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CDouble) + +-- | p_minall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THDoubleTensor_minall" + p_minall :: FunPtr (Ptr C'THDoubleTensor -> IO CDouble) + +-- | p_maxall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THDoubleTensor_maxall" + p_maxall :: FunPtr (Ptr C'THDoubleTensor -> IO CDouble) + +-- | p_medianall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THDoubleTensor_medianall" + p_medianall :: FunPtr (Ptr C'THDoubleTensor -> IO CDouble) + +-- | p_sumall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THDoubleTensor_sumall" + p_sumall :: FunPtr (Ptr C'THDoubleTensor -> IO CDouble) + +-- | p_prodall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THDoubleTensor_prodall" + p_prodall :: FunPtr (Ptr C'THDoubleTensor -> IO CDouble) + +-- | p_neg : Pointer to function : self src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_neg" + p_neg :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cinv : Pointer to function : self src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cinv" + p_cinv :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_add : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_add" + p_add :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_sub : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_sub" + p_sub :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_add_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_add_scaled" + p_add_scaled :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_sub_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_sub_scaled" + p_sub_scaled :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_mul : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_mul" + p_mul :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_div : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_div" + p_div :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_lshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_lshift" + p_lshift :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_rshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_rshift" + p_rshift :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_fmod : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_fmod" + p_fmod :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_remainder : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_remainder" + p_remainder :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_clamp : Pointer to function : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_clamp" + p_clamp :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CDouble -> IO ()) + +-- | p_bitand : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_bitand" + p_bitand :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_bitor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_bitor" + p_bitor :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_bitxor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_bitxor" + p_bitxor :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_cadd : Pointer to function : r_ t value src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cadd" + p_cadd :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_csub : Pointer to function : self src1 value src2 -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_csub" + p_csub :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cmul : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cmul" + p_cmul :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cpow : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cpow" + p_cpow :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cdiv : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cdiv" + p_cdiv :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_clshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_clshift" + p_clshift :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_crshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_crshift" + p_crshift :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cfmod : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cfmod" + p_cfmod :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cremainder : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cremainder" + p_cremainder :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cbitand : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cbitand" + p_cbitand :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cbitor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cbitor" + p_cbitor :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cbitxor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cbitxor" + p_cbitxor :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_addcmul : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_addcmul" + p_addcmul :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_addcdiv : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_addcdiv" + p_addcdiv :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_addmv : Pointer to function : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_addmv" + p_addmv :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_addmm : Pointer to function : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_addmm" + p_addmm :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_addr : Pointer to function : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_addr" + p_addr :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_addbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_addbmm" + p_addbmm :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_baddbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_baddbmm" + p_baddbmm :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_match : Pointer to function : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_match" + p_match :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_numel : Pointer to function : t -> ptrdiff_t +foreign import ccall "THTensorMath.h &THDoubleTensor_numel" + p_numel :: FunPtr (Ptr C'THDoubleTensor -> IO CPtrdiff) + +-- | p_preserveReduceDimSemantics : Pointer to function : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_preserveReduceDimSemantics" + p_preserveReduceDimSemantics :: FunPtr (Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_max : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_max" + p_max :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_min : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_min" + p_min :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_kthvalue : Pointer to function : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_kthvalue" + p_kthvalue :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CLLong -> CInt -> CInt -> IO ()) + +-- | p_mode : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_mode" + p_mode :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_median : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_median" + p_median :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_sum : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_sum" + p_sum :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_prod : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_prod" + p_prod :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_cumsum : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cumsum" + p_cumsum :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_cumprod : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cumprod" + p_cumprod :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_sign : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_sign" + p_sign :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_trace : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THDoubleTensor_trace" + p_trace :: FunPtr (Ptr C'THDoubleTensor -> IO CDouble) + +-- | p_cross : Pointer to function : r_ a b dimension -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cross" + p_cross :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_cmax : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cmax" + p_cmax :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cmin : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cmin" + p_cmin :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cmaxValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cmaxValue" + p_cmaxValue :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_cminValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cminValue" + p_cminValue :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_zeros : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_zeros" + p_zeros :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_zerosLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_zerosLike" + p_zerosLike :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_ones : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_ones" + p_ones :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_onesLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_onesLike" + p_onesLike :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_diag : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_diag" + p_diag :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_eye : Pointer to function : r_ n m -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_eye" + p_eye :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> CLLong -> IO ()) + +-- | p_arange : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_arange" + p_arange :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> CDouble -> IO ()) + +-- | p_range : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_range" + p_range :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> CDouble -> IO ()) + +-- | p_randperm : Pointer to function : r_ _generator n -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_randperm" + p_randperm :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_reshape : Pointer to function : r_ t size -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_reshape" + p_reshape :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_sort : Pointer to function : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_sort" + p_sort :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_topk : Pointer to function : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_topk" + p_topk :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> CLLong -> CInt -> CInt -> CInt -> IO ()) + +-- | p_tril : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_tril" + p_tril :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO ()) + +-- | p_triu : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_triu" + p_triu :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> IO ()) + +-- | p_cat : Pointer to function : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cat" + p_cat :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> IO ()) + +-- | p_catArray : Pointer to function : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_catArray" + p_catArray :: FunPtr (Ptr C'THDoubleTensor -> Ptr (Ptr C'THDoubleTensor) -> CInt -> CInt -> IO ()) + +-- | p_equal : Pointer to function : ta tb -> int +foreign import ccall "THTensorMath.h &THDoubleTensor_equal" + p_equal :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO CInt) + +-- | p_ltValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_ltValue" + p_ltValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_leValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_leValue" + p_leValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_gtValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_gtValue" + p_gtValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_geValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_geValue" + p_geValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_neValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_neValue" + p_neValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_eqValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_eqValue" + p_eqValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_ltValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_ltValueT" + p_ltValueT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_leValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_leValueT" + p_leValueT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_gtValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_gtValueT" + p_gtValueT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_geValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_geValueT" + p_geValueT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_neValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_neValueT" + p_neValueT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_eqValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_eqValueT" + p_eqValueT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_ltTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_ltTensor" + p_ltTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_leTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_leTensor" + p_leTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_gtTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_gtTensor" + p_gtTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_geTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_geTensor" + p_geTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_neTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_neTensor" + p_neTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_eqTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_eqTensor" + p_eqTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_ltTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_ltTensorT" + p_ltTensorT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_leTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_leTensorT" + p_leTensorT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_gtTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_gtTensorT" + p_gtTensorT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_geTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_geTensorT" + p_geTensorT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_neTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_neTensorT" + p_neTensorT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_eqTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_eqTensorT" + p_eqTensorT :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_abs : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_abs" + p_abs :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_sigmoid : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_sigmoid" + p_sigmoid :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_log : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_log" + p_log :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_lgamma : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_lgamma" + p_lgamma :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_digamma : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_digamma" + p_digamma :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_trigamma : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_trigamma" + p_trigamma :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_polygamma : Pointer to function : r_ n t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_polygamma" + p_polygamma :: FunPtr (Ptr C'THDoubleTensor -> CLLong -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_log1p : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_log1p" + p_log1p :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_exp : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_exp" + p_exp :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_expm1 : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_expm1" + p_expm1 :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cos : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cos" + p_cos :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_acos : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_acos" + p_acos :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cosh : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_cosh" + p_cosh :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_sin : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_sin" + p_sin :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_asin : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_asin" + p_asin :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_sinh : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_sinh" + p_sinh :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_tan : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_tan" + p_tan :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_atan : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_atan" + p_atan :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_atan2 : Pointer to function : r_ tx ty -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_atan2" + p_atan2 :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_tanh : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_tanh" + p_tanh :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_erf : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_erf" + p_erf :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_erfinv : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_erfinv" + p_erfinv :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_pow : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_pow" + p_pow :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_tpow : Pointer to function : r_ value t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_tpow" + p_tpow :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_sqrt : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_sqrt" + p_sqrt :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_rsqrt : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_rsqrt" + p_rsqrt :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_ceil : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_ceil" + p_ceil :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_floor : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_floor" + p_floor :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_round : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_round" + p_round :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_trunc : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_trunc" + p_trunc :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_frac : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_frac" + p_frac :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_lerp : Pointer to function : r_ a b weight -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_lerp" + p_lerp :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_mean : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_mean" + p_mean :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_std : Pointer to function : r_ t dimension biased keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_std" + p_std :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_var : Pointer to function : r_ t dimension biased keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_var" + p_var :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_norm : Pointer to function : r_ t value dimension keepdim -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_norm" + p_norm :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CInt -> IO ()) + +-- | p_renorm : Pointer to function : r_ t value dimension maxnorm -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_renorm" + p_renorm :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> CInt -> CDouble -> IO ()) + +-- | p_dist : Pointer to function : a b value -> accreal +foreign import ccall "THTensorMath.h &THDoubleTensor_dist" + p_dist :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CDouble -> IO CDouble) + +-- | p_histc : Pointer to function : hist tensor nbins minvalue maxvalue -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_histc" + p_histc :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CDouble -> CDouble -> IO ()) + +-- | p_bhistc : Pointer to function : hist tensor nbins minvalue maxvalue -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_bhistc" + p_bhistc :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> CLLong -> CDouble -> CDouble -> IO ()) + +-- | p_meanall : Pointer to function : self -> accreal +foreign import ccall "THTensorMath.h &THDoubleTensor_meanall" + p_meanall :: FunPtr (Ptr C'THDoubleTensor -> IO CDouble) + +-- | p_varall : Pointer to function : self biased -> accreal +foreign import ccall "THTensorMath.h &THDoubleTensor_varall" + p_varall :: FunPtr (Ptr C'THDoubleTensor -> CInt -> IO CDouble) + +-- | p_stdall : Pointer to function : self biased -> accreal +foreign import ccall "THTensorMath.h &THDoubleTensor_stdall" + p_stdall :: FunPtr (Ptr C'THDoubleTensor -> CInt -> IO CDouble) + +-- | p_normall : Pointer to function : t value -> accreal +foreign import ccall "THTensorMath.h &THDoubleTensor_normall" + p_normall :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> IO CDouble) + +-- | p_linspace : Pointer to function : r_ a b n -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_linspace" + p_linspace :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> CLLong -> IO ()) + +-- | p_logspace : Pointer to function : r_ a b n -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_logspace" + p_logspace :: FunPtr (Ptr C'THDoubleTensor -> CDouble -> CDouble -> CLLong -> IO ()) + +-- | p_rand : Pointer to function : r_ _generator size -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_rand" + p_rand :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO ()) + +-- | p_randn : Pointer to function : r_ _generator size -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_randn" + p_randn :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO ()) + +-- | p_dirichlet_grad : Pointer to function : self x alpha total -> void +foreign import ccall "THTensorMath.h &THDoubleTensor_dirichlet_grad" + p_dirichlet_grad :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Double/TensorRandom.hs b/src/Torch/FFI/TH/Double/TensorRandom.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/TensorRandom.hs @@ -0,0 +1,236 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.TensorRandom where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_random : self _generator -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_random" + c_random_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> IO () + +-- | alias of c_random_ with unused argument (for CTHState) to unify backpack signatures. +c_random :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> IO () +c_random = const c_random_ + +-- | c_clampedRandom : self _generator min max -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_clampedRandom" + c_clampedRandom_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () + +-- | alias of c_clampedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_clampedRandom :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () +c_clampedRandom = const c_clampedRandom_ + +-- | c_cappedRandom : self _generator max -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_cappedRandom" + c_cappedRandom_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_cappedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_cappedRandom :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_cappedRandom = const c_cappedRandom_ + +-- | c_geometric : self _generator p -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_geometric" + c_geometric_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_geometric_ with unused argument (for CTHState) to unify backpack signatures. +c_geometric :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_geometric = const c_geometric_ + +-- | c_bernoulli : self _generator p -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_bernoulli" + c_bernoulli_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_bernoulli_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_bernoulli = const c_bernoulli_ + +-- | c_bernoulli_FloatTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_bernoulli_FloatTensor" + c_bernoulli_FloatTensor_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_bernoulli_FloatTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_FloatTensor :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () +c_bernoulli_FloatTensor = const c_bernoulli_FloatTensor_ + +-- | c_bernoulli_DoubleTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_bernoulli_DoubleTensor" + c_bernoulli_DoubleTensor_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_bernoulli_DoubleTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_DoubleTensor :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () +c_bernoulli_DoubleTensor = const c_bernoulli_DoubleTensor_ + +-- | c_uniform : self _generator a b -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_uniform" + c_uniform_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () + +-- | alias of c_uniform_ with unused argument (for CTHState) to unify backpack signatures. +c_uniform :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () +c_uniform = const c_uniform_ + +-- | c_normal : self _generator mean stdv -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_normal" + c_normal_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () + +-- | alias of c_normal_ with unused argument (for CTHState) to unify backpack signatures. +c_normal :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () +c_normal = const c_normal_ + +-- | c_normal_means : self gen means stddev -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_normal_means" + c_normal_means_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> CDouble -> IO () + +-- | alias of c_normal_means_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_means :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> CDouble -> IO () +c_normal_means = const c_normal_means_ + +-- | c_normal_stddevs : self gen mean stddevs -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_normal_stddevs" + c_normal_stddevs_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_normal_stddevs_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_stddevs :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> Ptr C'THDoubleTensor -> IO () +c_normal_stddevs = const c_normal_stddevs_ + +-- | c_normal_means_stddevs : self gen means stddevs -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_normal_means_stddevs" + c_normal_means_stddevs_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_normal_means_stddevs_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_means_stddevs :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO () +c_normal_means_stddevs = const c_normal_means_stddevs_ + +-- | c_exponential : self _generator lambda -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_exponential" + c_exponential_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_exponential_ with unused argument (for CTHState) to unify backpack signatures. +c_exponential :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_exponential = const c_exponential_ + +-- | c_standard_gamma : self _generator alpha -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_standard_gamma" + c_standard_gamma_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_standard_gamma_ with unused argument (for CTHState) to unify backpack signatures. +c_standard_gamma :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () +c_standard_gamma = const c_standard_gamma_ + +-- | c_cauchy : self _generator median sigma -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_cauchy" + c_cauchy_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () + +-- | alias of c_cauchy_ with unused argument (for CTHState) to unify backpack signatures. +c_cauchy :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () +c_cauchy = const c_cauchy_ + +-- | c_logNormal : self _generator mean stdv -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_logNormal" + c_logNormal_ :: Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () + +-- | alias of c_logNormal_ with unused argument (for CTHState) to unify backpack signatures. +c_logNormal :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () +c_logNormal = const c_logNormal_ + +-- | c_multinomial : self _generator prob_dist n_sample with_replacement -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_multinomial" + c_multinomial_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () + +-- | alias of c_multinomial_ with unused argument (for CTHState) to unify backpack signatures. +c_multinomial :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO () +c_multinomial = const c_multinomial_ + +-- | c_multinomialAliasSetup : prob_dist J q -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_multinomialAliasSetup" + c_multinomialAliasSetup_ :: Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_multinomialAliasSetup_ with unused argument (for CTHState) to unify backpack signatures. +c_multinomialAliasSetup :: Ptr C'THState -> Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () +c_multinomialAliasSetup = const c_multinomialAliasSetup_ + +-- | c_multinomialAliasDraw : self _generator J q -> void +foreign import ccall "THTensorRandom.h THDoubleTensor_multinomialAliasDraw" + c_multinomialAliasDraw_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_multinomialAliasDraw_ with unused argument (for CTHState) to unify backpack signatures. +c_multinomialAliasDraw :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () +c_multinomialAliasDraw = const c_multinomialAliasDraw_ + +-- | p_random : Pointer to function : self _generator -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_random" + p_random :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> IO ()) + +-- | p_clampedRandom : Pointer to function : self _generator min max -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_clampedRandom" + p_clampedRandom :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO ()) + +-- | p_cappedRandom : Pointer to function : self _generator max -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_cappedRandom" + p_cappedRandom :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_geometric : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_geometric" + p_geometric :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_bernoulli" + p_bernoulli :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli_FloatTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_bernoulli_FloatTensor" + p_bernoulli_FloatTensor :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO ()) + +-- | p_bernoulli_DoubleTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_bernoulli_DoubleTensor" + p_bernoulli_DoubleTensor :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_uniform : Pointer to function : self _generator a b -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_uniform" + p_uniform :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO ()) + +-- | p_normal : Pointer to function : self _generator mean stdv -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_normal" + p_normal :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO ()) + +-- | p_normal_means : Pointer to function : self gen means stddev -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_normal_means" + p_normal_means :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> CDouble -> IO ()) + +-- | p_normal_stddevs : Pointer to function : self gen mean stddevs -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_normal_stddevs" + p_normal_stddevs :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_normal_means_stddevs : Pointer to function : self gen means stddevs -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_normal_means_stddevs" + p_normal_means_stddevs :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_exponential : Pointer to function : self _generator lambda -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_exponential" + p_exponential :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_standard_gamma : Pointer to function : self _generator alpha -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_standard_gamma" + p_standard_gamma :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_cauchy : Pointer to function : self _generator median sigma -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_cauchy" + p_cauchy :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO ()) + +-- | p_logNormal : Pointer to function : self _generator mean stdv -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_logNormal" + p_logNormal :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO ()) + +-- | p_multinomial : Pointer to function : self _generator prob_dist n_sample with_replacement -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_multinomial" + p_multinomial :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> CInt -> CInt -> IO ()) + +-- | p_multinomialAliasSetup : Pointer to function : prob_dist J q -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_multinomialAliasSetup" + p_multinomialAliasSetup :: FunPtr (Ptr C'THDoubleTensor -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_multinomialAliasDraw : Pointer to function : self _generator J q -> void +foreign import ccall "THTensorRandom.h &THDoubleTensor_multinomialAliasDraw" + p_multinomialAliasDraw :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Double/Vector.hs b/src/Torch/FFI/TH/Double/Vector.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Double/Vector.hs @@ -0,0 +1,476 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Double.Vector where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : x c n -> void +foreign import ccall "THVector.h THDoubleVector_fill" + c_fill_ :: Ptr CDouble -> CDouble -> CPtrdiff -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () +c_fill = const c_fill_ + +-- | c_cadd : z x y c n -> void +foreign import ccall "THVector.h THDoubleVector_cadd" + c_cadd_ :: Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () +c_cadd = const c_cadd_ + +-- | c_adds : y x c n -> void +foreign import ccall "THVector.h THDoubleVector_adds" + c_adds_ :: Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () + +-- | alias of c_adds_ with unused argument (for CTHState) to unify backpack signatures. +c_adds :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () +c_adds = const c_adds_ + +-- | c_cmul : z x y n -> void +foreign import ccall "THVector.h THDoubleVector_cmul" + c_cmul_ :: Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_cmul = const c_cmul_ + +-- | c_muls : y x c n -> void +foreign import ccall "THVector.h THDoubleVector_muls" + c_muls_ :: Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () + +-- | alias of c_muls_ with unused argument (for CTHState) to unify backpack signatures. +c_muls :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () +c_muls = const c_muls_ + +-- | c_cdiv : z x y n -> void +foreign import ccall "THVector.h THDoubleVector_cdiv" + c_cdiv_ :: Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_cdiv = const c_cdiv_ + +-- | c_divs : y x c n -> void +foreign import ccall "THVector.h THDoubleVector_divs" + c_divs_ :: Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () + +-- | alias of c_divs_ with unused argument (for CTHState) to unify backpack signatures. +c_divs :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () +c_divs = const c_divs_ + +-- | c_copy : y x n -> void +foreign import ccall "THVector.h THDoubleVector_copy" + c_copy_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_copy = const c_copy_ + +-- | c_neg : y x n -> void +foreign import ccall "THVector.h THDoubleVector_neg" + c_neg_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_neg = const c_neg_ + +-- | c_normal_fill : data size generator mean stddev -> void +foreign import ccall "THVector.h THDoubleVector_normal_fill" + c_normal_fill_ :: Ptr CDouble -> CLLong -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () + +-- | alias of c_normal_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_fill :: Ptr C'THState -> Ptr CDouble -> CLLong -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () +c_normal_fill = const c_normal_fill_ + +-- | c_abs : y x n -> void +foreign import ccall "THVector.h THDoubleVector_abs" + c_abs_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_abs = const c_abs_ + +-- | c_log : y x n -> void +foreign import ccall "THVector.h THDoubleVector_log" + c_log_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_log_ with unused argument (for CTHState) to unify backpack signatures. +c_log :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_log = const c_log_ + +-- | c_lgamma : y x n -> void +foreign import ccall "THVector.h THDoubleVector_lgamma" + c_lgamma_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_lgamma_ with unused argument (for CTHState) to unify backpack signatures. +c_lgamma :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_lgamma = const c_lgamma_ + +-- | c_digamma : y x n -> void +foreign import ccall "THVector.h THDoubleVector_digamma" + c_digamma_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_digamma_ with unused argument (for CTHState) to unify backpack signatures. +c_digamma :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_digamma = const c_digamma_ + +-- | c_trigamma : y x n -> void +foreign import ccall "THVector.h THDoubleVector_trigamma" + c_trigamma_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_trigamma_ with unused argument (for CTHState) to unify backpack signatures. +c_trigamma :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_trigamma = const c_trigamma_ + +-- | c_log1p : y x n -> void +foreign import ccall "THVector.h THDoubleVector_log1p" + c_log1p_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_log1p_ with unused argument (for CTHState) to unify backpack signatures. +c_log1p :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_log1p = const c_log1p_ + +-- | c_sigmoid : y x n -> void +foreign import ccall "THVector.h THDoubleVector_sigmoid" + c_sigmoid_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_sigmoid_ with unused argument (for CTHState) to unify backpack signatures. +c_sigmoid :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_sigmoid = const c_sigmoid_ + +-- | c_exp : y x n -> void +foreign import ccall "THVector.h THDoubleVector_exp" + c_exp_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_exp_ with unused argument (for CTHState) to unify backpack signatures. +c_exp :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_exp = const c_exp_ + +-- | c_expm1 : y x n -> void +foreign import ccall "THVector.h THDoubleVector_expm1" + c_expm1_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_expm1_ with unused argument (for CTHState) to unify backpack signatures. +c_expm1 :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_expm1 = const c_expm1_ + +-- | c_erf : y x n -> void +foreign import ccall "THVector.h THDoubleVector_erf" + c_erf_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_erf_ with unused argument (for CTHState) to unify backpack signatures. +c_erf :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_erf = const c_erf_ + +-- | c_erfinv : y x n -> void +foreign import ccall "THVector.h THDoubleVector_erfinv" + c_erfinv_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_erfinv_ with unused argument (for CTHState) to unify backpack signatures. +c_erfinv :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_erfinv = const c_erfinv_ + +-- | c_cos : y x n -> void +foreign import ccall "THVector.h THDoubleVector_cos" + c_cos_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_cos_ with unused argument (for CTHState) to unify backpack signatures. +c_cos :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_cos = const c_cos_ + +-- | c_acos : y x n -> void +foreign import ccall "THVector.h THDoubleVector_acos" + c_acos_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_acos_ with unused argument (for CTHState) to unify backpack signatures. +c_acos :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_acos = const c_acos_ + +-- | c_cosh : y x n -> void +foreign import ccall "THVector.h THDoubleVector_cosh" + c_cosh_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_cosh_ with unused argument (for CTHState) to unify backpack signatures. +c_cosh :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_cosh = const c_cosh_ + +-- | c_sin : y x n -> void +foreign import ccall "THVector.h THDoubleVector_sin" + c_sin_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_sin_ with unused argument (for CTHState) to unify backpack signatures. +c_sin :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_sin = const c_sin_ + +-- | c_asin : y x n -> void +foreign import ccall "THVector.h THDoubleVector_asin" + c_asin_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_asin_ with unused argument (for CTHState) to unify backpack signatures. +c_asin :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_asin = const c_asin_ + +-- | c_sinh : y x n -> void +foreign import ccall "THVector.h THDoubleVector_sinh" + c_sinh_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_sinh_ with unused argument (for CTHState) to unify backpack signatures. +c_sinh :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_sinh = const c_sinh_ + +-- | c_tan : y x n -> void +foreign import ccall "THVector.h THDoubleVector_tan" + c_tan_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_tan_ with unused argument (for CTHState) to unify backpack signatures. +c_tan :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_tan = const c_tan_ + +-- | c_atan : y x n -> void +foreign import ccall "THVector.h THDoubleVector_atan" + c_atan_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_atan_ with unused argument (for CTHState) to unify backpack signatures. +c_atan :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_atan = const c_atan_ + +-- | c_tanh : y x n -> void +foreign import ccall "THVector.h THDoubleVector_tanh" + c_tanh_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_tanh_ with unused argument (for CTHState) to unify backpack signatures. +c_tanh :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_tanh = const c_tanh_ + +-- | c_pow : y x c n -> void +foreign import ccall "THVector.h THDoubleVector_pow" + c_pow_ :: Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () + +-- | alias of c_pow_ with unused argument (for CTHState) to unify backpack signatures. +c_pow :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO () +c_pow = const c_pow_ + +-- | c_sqrt : y x n -> void +foreign import ccall "THVector.h THDoubleVector_sqrt" + c_sqrt_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_sqrt_ with unused argument (for CTHState) to unify backpack signatures. +c_sqrt :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_sqrt = const c_sqrt_ + +-- | c_rsqrt : y x n -> void +foreign import ccall "THVector.h THDoubleVector_rsqrt" + c_rsqrt_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_rsqrt_ with unused argument (for CTHState) to unify backpack signatures. +c_rsqrt :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_rsqrt = const c_rsqrt_ + +-- | c_ceil : y x n -> void +foreign import ccall "THVector.h THDoubleVector_ceil" + c_ceil_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_ceil_ with unused argument (for CTHState) to unify backpack signatures. +c_ceil :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_ceil = const c_ceil_ + +-- | c_floor : y x n -> void +foreign import ccall "THVector.h THDoubleVector_floor" + c_floor_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_floor_ with unused argument (for CTHState) to unify backpack signatures. +c_floor :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_floor = const c_floor_ + +-- | c_round : y x n -> void +foreign import ccall "THVector.h THDoubleVector_round" + c_round_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_round_ with unused argument (for CTHState) to unify backpack signatures. +c_round :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_round = const c_round_ + +-- | c_trunc : y x n -> void +foreign import ccall "THVector.h THDoubleVector_trunc" + c_trunc_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_trunc_ with unused argument (for CTHState) to unify backpack signatures. +c_trunc :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_trunc = const c_trunc_ + +-- | c_frac : y x n -> void +foreign import ccall "THVector.h THDoubleVector_frac" + c_frac_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_frac_ with unused argument (for CTHState) to unify backpack signatures. +c_frac :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_frac = const c_frac_ + +-- | c_cinv : y x n -> void +foreign import ccall "THVector.h THDoubleVector_cinv" + c_cinv_ :: Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () + +-- | alias of c_cinv_ with unused argument (for CTHState) to unify backpack signatures. +c_cinv :: Ptr C'THState -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO () +c_cinv = const c_cinv_ + +-- | p_fill : Pointer to function : x c n -> void +foreign import ccall "THVector.h &THDoubleVector_fill" + p_fill :: FunPtr (Ptr CDouble -> CDouble -> CPtrdiff -> IO ()) + +-- | p_cadd : Pointer to function : z x y c n -> void +foreign import ccall "THVector.h &THDoubleVector_cadd" + p_cadd :: FunPtr (Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO ()) + +-- | p_adds : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THDoubleVector_adds" + p_adds :: FunPtr (Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO ()) + +-- | p_cmul : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THDoubleVector_cmul" + p_cmul :: FunPtr (Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_muls : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THDoubleVector_muls" + p_muls :: FunPtr (Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO ()) + +-- | p_cdiv : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THDoubleVector_cdiv" + p_cdiv :: FunPtr (Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_divs : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THDoubleVector_divs" + p_divs :: FunPtr (Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO ()) + +-- | p_copy : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_copy" + p_copy :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_neg : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_neg" + p_neg :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_normal_fill : Pointer to function : data size generator mean stddev -> void +foreign import ccall "THVector.h &THDoubleVector_normal_fill" + p_normal_fill :: FunPtr (Ptr CDouble -> CLLong -> Ptr C'THGenerator -> CDouble -> CDouble -> IO ()) + +-- | p_abs : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_abs" + p_abs :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_log : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_log" + p_log :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_lgamma : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_lgamma" + p_lgamma :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_digamma : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_digamma" + p_digamma :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_trigamma : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_trigamma" + p_trigamma :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_log1p : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_log1p" + p_log1p :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_sigmoid : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_sigmoid" + p_sigmoid :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_exp : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_exp" + p_exp :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_expm1 : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_expm1" + p_expm1 :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_erf : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_erf" + p_erf :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_erfinv : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_erfinv" + p_erfinv :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_cos : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_cos" + p_cos :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_acos : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_acos" + p_acos :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_cosh : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_cosh" + p_cosh :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_sin : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_sin" + p_sin :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_asin : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_asin" + p_asin :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_sinh : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_sinh" + p_sinh :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_tan : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_tan" + p_tan :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_atan : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_atan" + p_atan :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_tanh : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_tanh" + p_tanh :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_pow : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THDoubleVector_pow" + p_pow :: FunPtr (Ptr CDouble -> Ptr CDouble -> CDouble -> CPtrdiff -> IO ()) + +-- | p_sqrt : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_sqrt" + p_sqrt :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_rsqrt : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_rsqrt" + p_rsqrt :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_ceil : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_ceil" + p_ceil :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_floor : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_floor" + p_floor :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_round : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_round" + p_round :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_trunc : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_trunc" + p_trunc :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_frac : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_frac" + p_frac :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) + +-- | p_cinv : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THDoubleVector_cinv" + p_cinv :: FunPtr (Ptr CDouble -> Ptr CDouble -> CPtrdiff -> IO ()) diff --git a/src/Torch/FFI/TH/File.hs b/src/Torch/FFI/TH/File.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/File.hs @@ -0,0 +1,568 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.File where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_THFile_isOpened : self -> int +foreign import ccall "THFile.h THFile_isOpened" + c_THFile_isOpened :: Ptr C'THFile -> IO CInt + +-- | c_THFile_isQuiet : self -> int +foreign import ccall "THFile.h THFile_isQuiet" + c_THFile_isQuiet :: Ptr C'THFile -> IO CInt + +-- | c_THFile_isReadable : self -> int +foreign import ccall "THFile.h THFile_isReadable" + c_THFile_isReadable :: Ptr C'THFile -> IO CInt + +-- | c_THFile_isWritable : self -> int +foreign import ccall "THFile.h THFile_isWritable" + c_THFile_isWritable :: Ptr C'THFile -> IO CInt + +-- | c_THFile_isBinary : self -> int +foreign import ccall "THFile.h THFile_isBinary" + c_THFile_isBinary :: Ptr C'THFile -> IO CInt + +-- | c_THFile_isAutoSpacing : self -> int +foreign import ccall "THFile.h THFile_isAutoSpacing" + c_THFile_isAutoSpacing :: Ptr C'THFile -> IO CInt + +-- | c_THFile_hasError : self -> int +foreign import ccall "THFile.h THFile_hasError" + c_THFile_hasError :: Ptr C'THFile -> IO CInt + +-- | c_THFile_binary : self -> void +foreign import ccall "THFile.h THFile_binary" + c_THFile_binary :: Ptr C'THFile -> IO () + +-- | c_THFile_ascii : self -> void +foreign import ccall "THFile.h THFile_ascii" + c_THFile_ascii :: Ptr C'THFile -> IO () + +-- | c_THFile_autoSpacing : self -> void +foreign import ccall "THFile.h THFile_autoSpacing" + c_THFile_autoSpacing :: Ptr C'THFile -> IO () + +-- | c_THFile_noAutoSpacing : self -> void +foreign import ccall "THFile.h THFile_noAutoSpacing" + c_THFile_noAutoSpacing :: Ptr C'THFile -> IO () + +-- | c_THFile_quiet : self -> void +foreign import ccall "THFile.h THFile_quiet" + c_THFile_quiet :: Ptr C'THFile -> IO () + +-- | c_THFile_pedantic : self -> void +foreign import ccall "THFile.h THFile_pedantic" + c_THFile_pedantic :: Ptr C'THFile -> IO () + +-- | c_THFile_clearError : self -> void +foreign import ccall "THFile.h THFile_clearError" + c_THFile_clearError :: Ptr C'THFile -> IO () + +-- | c_THFile_readByteScalar : self -> uint8_t +foreign import ccall "THFile.h THFile_readByteScalar" + c_THFile_readByteScalar :: Ptr C'THFile -> IO CUChar + +-- | c_THFile_readCharScalar : self -> int8_t +foreign import ccall "THFile.h THFile_readCharScalar" + c_THFile_readCharScalar :: Ptr C'THFile -> IO CSChar + +-- | c_THFile_readShortScalar : self -> int16_t +foreign import ccall "THFile.h THFile_readShortScalar" + c_THFile_readShortScalar :: Ptr C'THFile -> IO CShort + +-- | c_THFile_readIntScalar : self -> int32_t +foreign import ccall "THFile.h THFile_readIntScalar" + c_THFile_readIntScalar :: Ptr C'THFile -> IO CInt + +-- | c_THFile_readLongScalar : self -> int64_t +foreign import ccall "THFile.h THFile_readLongScalar" + c_THFile_readLongScalar :: Ptr C'THFile -> IO CLLong + +-- | c_THFile_readFloatScalar : self -> float +foreign import ccall "THFile.h THFile_readFloatScalar" + c_THFile_readFloatScalar :: Ptr C'THFile -> IO CFloat + +-- | c_THFile_readDoubleScalar : self -> double +foreign import ccall "THFile.h THFile_readDoubleScalar" + c_THFile_readDoubleScalar :: Ptr C'THFile -> IO CDouble + +-- | c_THFile_writeByteScalar : self scalar -> void +foreign import ccall "THFile.h THFile_writeByteScalar" + c_THFile_writeByteScalar :: Ptr C'THFile -> CUChar -> IO () + +-- | c_THFile_writeCharScalar : self scalar -> void +foreign import ccall "THFile.h THFile_writeCharScalar" + c_THFile_writeCharScalar :: Ptr C'THFile -> CSChar -> IO () + +-- | c_THFile_writeShortScalar : self scalar -> void +foreign import ccall "THFile.h THFile_writeShortScalar" + c_THFile_writeShortScalar :: Ptr C'THFile -> CShort -> IO () + +-- | c_THFile_writeIntScalar : self scalar -> void +foreign import ccall "THFile.h THFile_writeIntScalar" + c_THFile_writeIntScalar :: Ptr C'THFile -> CInt -> IO () + +-- | c_THFile_writeLongScalar : self scalar -> void +foreign import ccall "THFile.h THFile_writeLongScalar" + c_THFile_writeLongScalar :: Ptr C'THFile -> CLLong -> IO () + +-- | c_THFile_writeFloatScalar : self scalar -> void +foreign import ccall "THFile.h THFile_writeFloatScalar" + c_THFile_writeFloatScalar :: Ptr C'THFile -> CFloat -> IO () + +-- | c_THFile_writeDoubleScalar : self scalar -> void +foreign import ccall "THFile.h THFile_writeDoubleScalar" + c_THFile_writeDoubleScalar :: Ptr C'THFile -> CDouble -> IO () + +-- | c_THFile_readByte : self storage -> size_t +foreign import ccall "THFile.h THFile_readByte" + c_THFile_readByte :: Ptr C'THFile -> Ptr C'THByteStorage -> IO CSize + +-- | c_THFile_readChar : self storage -> size_t +foreign import ccall "THFile.h THFile_readChar" + c_THFile_readChar :: Ptr C'THFile -> Ptr C'THCharStorage -> IO CSize + +-- | c_THFile_readShort : self storage -> size_t +foreign import ccall "THFile.h THFile_readShort" + c_THFile_readShort :: Ptr C'THFile -> Ptr C'THShortStorage -> IO CSize + +-- | c_THFile_readInt : self storage -> size_t +foreign import ccall "THFile.h THFile_readInt" + c_THFile_readInt :: Ptr C'THFile -> Ptr C'THIntStorage -> IO CSize + +-- | c_THFile_readLong : self storage -> size_t +foreign import ccall "THFile.h THFile_readLong" + c_THFile_readLong :: Ptr C'THFile -> Ptr C'THLongStorage -> IO CSize + +-- | c_THFile_readFloat : self storage -> size_t +foreign import ccall "THFile.h THFile_readFloat" + c_THFile_readFloat :: Ptr C'THFile -> Ptr C'THFloatStorage -> IO CSize + +-- | c_THFile_readDouble : self storage -> size_t +foreign import ccall "THFile.h THFile_readDouble" + c_THFile_readDouble :: Ptr C'THFile -> Ptr C'THDoubleStorage -> IO CSize + +-- | c_THFile_writeByte : self storage -> size_t +foreign import ccall "THFile.h THFile_writeByte" + c_THFile_writeByte :: Ptr C'THFile -> Ptr C'THByteStorage -> IO CSize + +-- | c_THFile_writeChar : self storage -> size_t +foreign import ccall "THFile.h THFile_writeChar" + c_THFile_writeChar :: Ptr C'THFile -> Ptr C'THCharStorage -> IO CSize + +-- | c_THFile_writeShort : self storage -> size_t +foreign import ccall "THFile.h THFile_writeShort" + c_THFile_writeShort :: Ptr C'THFile -> Ptr C'THShortStorage -> IO CSize + +-- | c_THFile_writeInt : self storage -> size_t +foreign import ccall "THFile.h THFile_writeInt" + c_THFile_writeInt :: Ptr C'THFile -> Ptr C'THIntStorage -> IO CSize + +-- | c_THFile_writeLong : self storage -> size_t +foreign import ccall "THFile.h THFile_writeLong" + c_THFile_writeLong :: Ptr C'THFile -> Ptr C'THLongStorage -> IO CSize + +-- | c_THFile_writeFloat : self storage -> size_t +foreign import ccall "THFile.h THFile_writeFloat" + c_THFile_writeFloat :: Ptr C'THFile -> Ptr C'THFloatStorage -> IO CSize + +-- | c_THFile_writeDouble : self storage -> size_t +foreign import ccall "THFile.h THFile_writeDouble" + c_THFile_writeDouble :: Ptr C'THFile -> Ptr C'THDoubleStorage -> IO CSize + +-- | c_THFile_readByteRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_readByteRaw" + c_THFile_readByteRaw :: Ptr C'THFile -> Ptr CUChar -> CSize -> IO CSize + +-- | c_THFile_readCharRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_readCharRaw" + c_THFile_readCharRaw :: Ptr C'THFile -> Ptr CSChar -> CSize -> IO CSize + +-- | c_THFile_readShortRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_readShortRaw" + c_THFile_readShortRaw :: Ptr C'THFile -> Ptr CShort -> CSize -> IO CSize + +-- | c_THFile_readIntRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_readIntRaw" + c_THFile_readIntRaw :: Ptr C'THFile -> Ptr CInt -> CSize -> IO CSize + +-- | c_THFile_readLongRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_readLongRaw" + c_THFile_readLongRaw :: Ptr C'THFile -> Ptr CLLong -> CSize -> IO CSize + +-- | c_THFile_readFloatRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_readFloatRaw" + c_THFile_readFloatRaw :: Ptr C'THFile -> Ptr CFloat -> CSize -> IO CSize + +-- | c_THFile_readDoubleRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_readDoubleRaw" + c_THFile_readDoubleRaw :: Ptr C'THFile -> Ptr CDouble -> CSize -> IO CSize + +-- | c_THFile_readStringRaw : self format str_ -> size_t +foreign import ccall "THFile.h THFile_readStringRaw" + c_THFile_readStringRaw :: Ptr C'THFile -> Ptr CChar -> Ptr (Ptr CChar) -> IO CSize + +-- | c_THFile_writeByteRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_writeByteRaw" + c_THFile_writeByteRaw :: Ptr C'THFile -> Ptr CUChar -> CSize -> IO CSize + +-- | c_THFile_writeCharRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_writeCharRaw" + c_THFile_writeCharRaw :: Ptr C'THFile -> Ptr CSChar -> CSize -> IO CSize + +-- | c_THFile_writeShortRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_writeShortRaw" + c_THFile_writeShortRaw :: Ptr C'THFile -> Ptr CShort -> CSize -> IO CSize + +-- | c_THFile_writeIntRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_writeIntRaw" + c_THFile_writeIntRaw :: Ptr C'THFile -> Ptr CInt -> CSize -> IO CSize + +-- | c_THFile_writeLongRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_writeLongRaw" + c_THFile_writeLongRaw :: Ptr C'THFile -> Ptr CLLong -> CSize -> IO CSize + +-- | c_THFile_writeFloatRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_writeFloatRaw" + c_THFile_writeFloatRaw :: Ptr C'THFile -> Ptr CFloat -> CSize -> IO CSize + +-- | c_THFile_writeDoubleRaw : self data n -> size_t +foreign import ccall "THFile.h THFile_writeDoubleRaw" + c_THFile_writeDoubleRaw :: Ptr C'THFile -> Ptr CDouble -> CSize -> IO CSize + +-- | c_THFile_writeStringRaw : self str size -> size_t +foreign import ccall "THFile.h THFile_writeStringRaw" + c_THFile_writeStringRaw :: Ptr C'THFile -> Ptr CChar -> CSize -> IO CSize + +-- | c_THFile_readHalfScalar : self -> THHalf +foreign import ccall "THFile.h THFile_readHalfScalar" + c_THFile_readHalfScalar :: Ptr C'THFile -> IO C'THHalf + +-- | c_THFile_writeHalfScalar : self scalar -> void +foreign import ccall "THFile.h THFile_writeHalfScalar" + c_THFile_writeHalfScalar :: Ptr C'THFile -> C'THHalf -> IO () + +-- | c_THFile_readHalf : self storage -> size_t +foreign import ccall "THFile.h THFile_readHalf" + c_THFile_readHalf :: Ptr C'THFile -> Ptr C'THHalfStorage -> IO CSize + +-- | c_THFile_writeHalf : self storage -> size_t +foreign import ccall "THFile.h THFile_writeHalf" + c_THFile_writeHalf :: Ptr C'THFile -> Ptr C'THHalfStorage -> IO CSize + +-- | c_THFile_readHalfRaw : self data size -> size_t +foreign import ccall "THFile.h THFile_readHalfRaw" + c_THFile_readHalfRaw :: Ptr C'THFile -> Ptr C'THHalf -> CSize -> IO CSize + +-- | c_THFile_writeHalfRaw : self data size -> size_t +foreign import ccall "THFile.h THFile_writeHalfRaw" + c_THFile_writeHalfRaw :: Ptr C'THFile -> Ptr C'THHalf -> CSize -> IO CSize + +-- | c_THFile_synchronize : self -> void +foreign import ccall "THFile.h THFile_synchronize" + c_THFile_synchronize :: Ptr C'THFile -> IO () + +-- | c_THFile_seek : self position -> void +foreign import ccall "THFile.h THFile_seek" + c_THFile_seek :: Ptr C'THFile -> CSize -> IO () + +-- | c_THFile_seekEnd : self -> void +foreign import ccall "THFile.h THFile_seekEnd" + c_THFile_seekEnd :: Ptr C'THFile -> IO () + +-- | c_THFile_position : self -> size_t +foreign import ccall "THFile.h THFile_position" + c_THFile_position :: Ptr C'THFile -> IO CSize + +-- | c_THFile_close : self -> void +foreign import ccall "THFile.h THFile_close" + c_THFile_close :: Ptr C'THFile -> IO () + +-- | c_THFile_free : self -> void +foreign import ccall "THFile.h THFile_free" + c_THFile_free :: Ptr C'THFile -> IO () + +-- | p_THFile_isOpened : Pointer to function : self -> int +foreign import ccall "THFile.h &THFile_isOpened" + p_THFile_isOpened :: FunPtr (Ptr C'THFile -> IO CInt) + +-- | p_THFile_isQuiet : Pointer to function : self -> int +foreign import ccall "THFile.h &THFile_isQuiet" + p_THFile_isQuiet :: FunPtr (Ptr C'THFile -> IO CInt) + +-- | p_THFile_isReadable : Pointer to function : self -> int +foreign import ccall "THFile.h &THFile_isReadable" + p_THFile_isReadable :: FunPtr (Ptr C'THFile -> IO CInt) + +-- | p_THFile_isWritable : Pointer to function : self -> int +foreign import ccall "THFile.h &THFile_isWritable" + p_THFile_isWritable :: FunPtr (Ptr C'THFile -> IO CInt) + +-- | p_THFile_isBinary : Pointer to function : self -> int +foreign import ccall "THFile.h &THFile_isBinary" + p_THFile_isBinary :: FunPtr (Ptr C'THFile -> IO CInt) + +-- | p_THFile_isAutoSpacing : Pointer to function : self -> int +foreign import ccall "THFile.h &THFile_isAutoSpacing" + p_THFile_isAutoSpacing :: FunPtr (Ptr C'THFile -> IO CInt) + +-- | p_THFile_hasError : Pointer to function : self -> int +foreign import ccall "THFile.h &THFile_hasError" + p_THFile_hasError :: FunPtr (Ptr C'THFile -> IO CInt) + +-- | p_THFile_binary : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_binary" + p_THFile_binary :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_ascii : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_ascii" + p_THFile_ascii :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_autoSpacing : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_autoSpacing" + p_THFile_autoSpacing :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_noAutoSpacing : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_noAutoSpacing" + p_THFile_noAutoSpacing :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_quiet : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_quiet" + p_THFile_quiet :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_pedantic : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_pedantic" + p_THFile_pedantic :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_clearError : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_clearError" + p_THFile_clearError :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_readByteScalar : Pointer to function : self -> uint8_t +foreign import ccall "THFile.h &THFile_readByteScalar" + p_THFile_readByteScalar :: FunPtr (Ptr C'THFile -> IO CUChar) + +-- | p_THFile_readCharScalar : Pointer to function : self -> int8_t +foreign import ccall "THFile.h &THFile_readCharScalar" + p_THFile_readCharScalar :: FunPtr (Ptr C'THFile -> IO CSChar) + +-- | p_THFile_readShortScalar : Pointer to function : self -> int16_t +foreign import ccall "THFile.h &THFile_readShortScalar" + p_THFile_readShortScalar :: FunPtr (Ptr C'THFile -> IO CShort) + +-- | p_THFile_readIntScalar : Pointer to function : self -> int32_t +foreign import ccall "THFile.h &THFile_readIntScalar" + p_THFile_readIntScalar :: FunPtr (Ptr C'THFile -> IO CInt) + +-- | p_THFile_readLongScalar : Pointer to function : self -> int64_t +foreign import ccall "THFile.h &THFile_readLongScalar" + p_THFile_readLongScalar :: FunPtr (Ptr C'THFile -> IO CLLong) + +-- | p_THFile_readFloatScalar : Pointer to function : self -> float +foreign import ccall "THFile.h &THFile_readFloatScalar" + p_THFile_readFloatScalar :: FunPtr (Ptr C'THFile -> IO CFloat) + +-- | p_THFile_readDoubleScalar : Pointer to function : self -> double +foreign import ccall "THFile.h &THFile_readDoubleScalar" + p_THFile_readDoubleScalar :: FunPtr (Ptr C'THFile -> IO CDouble) + +-- | p_THFile_writeByteScalar : Pointer to function : self scalar -> void +foreign import ccall "THFile.h &THFile_writeByteScalar" + p_THFile_writeByteScalar :: FunPtr (Ptr C'THFile -> CUChar -> IO ()) + +-- | p_THFile_writeCharScalar : Pointer to function : self scalar -> void +foreign import ccall "THFile.h &THFile_writeCharScalar" + p_THFile_writeCharScalar :: FunPtr (Ptr C'THFile -> CSChar -> IO ()) + +-- | p_THFile_writeShortScalar : Pointer to function : self scalar -> void +foreign import ccall "THFile.h &THFile_writeShortScalar" + p_THFile_writeShortScalar :: FunPtr (Ptr C'THFile -> CShort -> IO ()) + +-- | p_THFile_writeIntScalar : Pointer to function : self scalar -> void +foreign import ccall "THFile.h &THFile_writeIntScalar" + p_THFile_writeIntScalar :: FunPtr (Ptr C'THFile -> CInt -> IO ()) + +-- | p_THFile_writeLongScalar : Pointer to function : self scalar -> void +foreign import ccall "THFile.h &THFile_writeLongScalar" + p_THFile_writeLongScalar :: FunPtr (Ptr C'THFile -> CLLong -> IO ()) + +-- | p_THFile_writeFloatScalar : Pointer to function : self scalar -> void +foreign import ccall "THFile.h &THFile_writeFloatScalar" + p_THFile_writeFloatScalar :: FunPtr (Ptr C'THFile -> CFloat -> IO ()) + +-- | p_THFile_writeDoubleScalar : Pointer to function : self scalar -> void +foreign import ccall "THFile.h &THFile_writeDoubleScalar" + p_THFile_writeDoubleScalar :: FunPtr (Ptr C'THFile -> CDouble -> IO ()) + +-- | p_THFile_readByte : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_readByte" + p_THFile_readByte :: FunPtr (Ptr C'THFile -> Ptr C'THByteStorage -> IO CSize) + +-- | p_THFile_readChar : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_readChar" + p_THFile_readChar :: FunPtr (Ptr C'THFile -> Ptr C'THCharStorage -> IO CSize) + +-- | p_THFile_readShort : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_readShort" + p_THFile_readShort :: FunPtr (Ptr C'THFile -> Ptr C'THShortStorage -> IO CSize) + +-- | p_THFile_readInt : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_readInt" + p_THFile_readInt :: FunPtr (Ptr C'THFile -> Ptr C'THIntStorage -> IO CSize) + +-- | p_THFile_readLong : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_readLong" + p_THFile_readLong :: FunPtr (Ptr C'THFile -> Ptr C'THLongStorage -> IO CSize) + +-- | p_THFile_readFloat : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_readFloat" + p_THFile_readFloat :: FunPtr (Ptr C'THFile -> Ptr C'THFloatStorage -> IO CSize) + +-- | p_THFile_readDouble : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_readDouble" + p_THFile_readDouble :: FunPtr (Ptr C'THFile -> Ptr C'THDoubleStorage -> IO CSize) + +-- | p_THFile_writeByte : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_writeByte" + p_THFile_writeByte :: FunPtr (Ptr C'THFile -> Ptr C'THByteStorage -> IO CSize) + +-- | p_THFile_writeChar : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_writeChar" + p_THFile_writeChar :: FunPtr (Ptr C'THFile -> Ptr C'THCharStorage -> IO CSize) + +-- | p_THFile_writeShort : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_writeShort" + p_THFile_writeShort :: FunPtr (Ptr C'THFile -> Ptr C'THShortStorage -> IO CSize) + +-- | p_THFile_writeInt : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_writeInt" + p_THFile_writeInt :: FunPtr (Ptr C'THFile -> Ptr C'THIntStorage -> IO CSize) + +-- | p_THFile_writeLong : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_writeLong" + p_THFile_writeLong :: FunPtr (Ptr C'THFile -> Ptr C'THLongStorage -> IO CSize) + +-- | p_THFile_writeFloat : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_writeFloat" + p_THFile_writeFloat :: FunPtr (Ptr C'THFile -> Ptr C'THFloatStorage -> IO CSize) + +-- | p_THFile_writeDouble : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_writeDouble" + p_THFile_writeDouble :: FunPtr (Ptr C'THFile -> Ptr C'THDoubleStorage -> IO CSize) + +-- | p_THFile_readByteRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_readByteRaw" + p_THFile_readByteRaw :: FunPtr (Ptr C'THFile -> Ptr CUChar -> CSize -> IO CSize) + +-- | p_THFile_readCharRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_readCharRaw" + p_THFile_readCharRaw :: FunPtr (Ptr C'THFile -> Ptr CSChar -> CSize -> IO CSize) + +-- | p_THFile_readShortRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_readShortRaw" + p_THFile_readShortRaw :: FunPtr (Ptr C'THFile -> Ptr CShort -> CSize -> IO CSize) + +-- | p_THFile_readIntRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_readIntRaw" + p_THFile_readIntRaw :: FunPtr (Ptr C'THFile -> Ptr CInt -> CSize -> IO CSize) + +-- | p_THFile_readLongRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_readLongRaw" + p_THFile_readLongRaw :: FunPtr (Ptr C'THFile -> Ptr CLLong -> CSize -> IO CSize) + +-- | p_THFile_readFloatRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_readFloatRaw" + p_THFile_readFloatRaw :: FunPtr (Ptr C'THFile -> Ptr CFloat -> CSize -> IO CSize) + +-- | p_THFile_readDoubleRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_readDoubleRaw" + p_THFile_readDoubleRaw :: FunPtr (Ptr C'THFile -> Ptr CDouble -> CSize -> IO CSize) + +-- | p_THFile_readStringRaw : Pointer to function : self format str_ -> size_t +foreign import ccall "THFile.h &THFile_readStringRaw" + p_THFile_readStringRaw :: FunPtr (Ptr C'THFile -> Ptr CChar -> Ptr (Ptr CChar) -> IO CSize) + +-- | p_THFile_writeByteRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_writeByteRaw" + p_THFile_writeByteRaw :: FunPtr (Ptr C'THFile -> Ptr CUChar -> CSize -> IO CSize) + +-- | p_THFile_writeCharRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_writeCharRaw" + p_THFile_writeCharRaw :: FunPtr (Ptr C'THFile -> Ptr CSChar -> CSize -> IO CSize) + +-- | p_THFile_writeShortRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_writeShortRaw" + p_THFile_writeShortRaw :: FunPtr (Ptr C'THFile -> Ptr CShort -> CSize -> IO CSize) + +-- | p_THFile_writeIntRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_writeIntRaw" + p_THFile_writeIntRaw :: FunPtr (Ptr C'THFile -> Ptr CInt -> CSize -> IO CSize) + +-- | p_THFile_writeLongRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_writeLongRaw" + p_THFile_writeLongRaw :: FunPtr (Ptr C'THFile -> Ptr CLLong -> CSize -> IO CSize) + +-- | p_THFile_writeFloatRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_writeFloatRaw" + p_THFile_writeFloatRaw :: FunPtr (Ptr C'THFile -> Ptr CFloat -> CSize -> IO CSize) + +-- | p_THFile_writeDoubleRaw : Pointer to function : self data n -> size_t +foreign import ccall "THFile.h &THFile_writeDoubleRaw" + p_THFile_writeDoubleRaw :: FunPtr (Ptr C'THFile -> Ptr CDouble -> CSize -> IO CSize) + +-- | p_THFile_writeStringRaw : Pointer to function : self str size -> size_t +foreign import ccall "THFile.h &THFile_writeStringRaw" + p_THFile_writeStringRaw :: FunPtr (Ptr C'THFile -> Ptr CChar -> CSize -> IO CSize) + +-- | p_THFile_readHalfScalar : Pointer to function : self -> THHalf +foreign import ccall "THFile.h &THFile_readHalfScalar" + p_THFile_readHalfScalar :: FunPtr (Ptr C'THFile -> IO C'THHalf) + +-- | p_THFile_writeHalfScalar : Pointer to function : self scalar -> void +foreign import ccall "THFile.h &THFile_writeHalfScalar" + p_THFile_writeHalfScalar :: FunPtr (Ptr C'THFile -> C'THHalf -> IO ()) + +-- | p_THFile_readHalf : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_readHalf" + p_THFile_readHalf :: FunPtr (Ptr C'THFile -> Ptr C'THHalfStorage -> IO CSize) + +-- | p_THFile_writeHalf : Pointer to function : self storage -> size_t +foreign import ccall "THFile.h &THFile_writeHalf" + p_THFile_writeHalf :: FunPtr (Ptr C'THFile -> Ptr C'THHalfStorage -> IO CSize) + +-- | p_THFile_readHalfRaw : Pointer to function : self data size -> size_t +foreign import ccall "THFile.h &THFile_readHalfRaw" + p_THFile_readHalfRaw :: FunPtr (Ptr C'THFile -> Ptr C'THHalf -> CSize -> IO CSize) + +-- | p_THFile_writeHalfRaw : Pointer to function : self data size -> size_t +foreign import ccall "THFile.h &THFile_writeHalfRaw" + p_THFile_writeHalfRaw :: FunPtr (Ptr C'THFile -> Ptr C'THHalf -> CSize -> IO CSize) + +-- | p_THFile_synchronize : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_synchronize" + p_THFile_synchronize :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_seek : Pointer to function : self position -> void +foreign import ccall "THFile.h &THFile_seek" + p_THFile_seek :: FunPtr (Ptr C'THFile -> CSize -> IO ()) + +-- | p_THFile_seekEnd : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_seekEnd" + p_THFile_seekEnd :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_position : Pointer to function : self -> size_t +foreign import ccall "THFile.h &THFile_position" + p_THFile_position :: FunPtr (Ptr C'THFile -> IO CSize) + +-- | p_THFile_close : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_close" + p_THFile_close :: FunPtr (Ptr C'THFile -> IO ()) + +-- | p_THFile_free : Pointer to function : self -> void +foreign import ccall "THFile.h &THFile_free" + p_THFile_free :: FunPtr (Ptr C'THFile -> IO ()) diff --git a/src/Torch/FFI/TH/Float/Blas.hs b/src/Torch/FFI/TH/Float/Blas.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/Blas.hs @@ -0,0 +1,104 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.Blas where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_swap : n x incx y incy -> void +foreign import ccall "THBlas.h THFloatBlas_swap" + c_swap_ :: CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO () +c_swap = const c_swap_ + +-- | c_scal : n a x incx -> void +foreign import ccall "THBlas.h THFloatBlas_scal" + c_scal_ :: CLLong -> CFloat -> Ptr CFloat -> CLLong -> IO () + +-- | alias of c_scal_ with unused argument (for CTHState) to unify backpack signatures. +c_scal :: Ptr C'THState -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> IO () +c_scal = const c_scal_ + +-- | c_copy : n x incx y incy -> void +foreign import ccall "THBlas.h THFloatBlas_copy" + c_copy_ :: CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO () +c_copy = const c_copy_ + +-- | c_axpy : n a x incx y incy -> void +foreign import ccall "THBlas.h THFloatBlas_axpy" + c_axpy_ :: CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO () + +-- | alias of c_axpy_ with unused argument (for CTHState) to unify backpack signatures. +c_axpy :: Ptr C'THState -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO () +c_axpy = const c_axpy_ + +-- | c_dot : n x incx y incy -> real +foreign import ccall "THBlas.h THFloatBlas_dot" + c_dot_ :: CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO CFloat + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO CFloat +c_dot = const c_dot_ + +-- | c_gemv : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h THFloatBlas_gemv" + c_gemv_ :: CChar -> CLLong -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> IO () + +-- | alias of c_gemv_ with unused argument (for CTHState) to unify backpack signatures. +c_gemv :: Ptr C'THState -> CChar -> CLLong -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> IO () +c_gemv = const c_gemv_ + +-- | c_ger : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h THFloatBlas_ger" + c_ger_ :: CLLong -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO () + +-- | alias of c_ger_ with unused argument (for CTHState) to unify backpack signatures. +c_ger :: Ptr C'THState -> CLLong -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO () +c_ger = const c_ger_ + +-- | c_gemm : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h THFloatBlas_gemm" + c_gemm_ :: CChar -> CChar -> CLLong -> CLLong -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> IO () + +-- | alias of c_gemm_ with unused argument (for CTHState) to unify backpack signatures. +c_gemm :: Ptr C'THState -> CChar -> CChar -> CLLong -> CLLong -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> IO () +c_gemm = const c_gemm_ + +-- | p_swap : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THFloatBlas_swap" + p_swap :: FunPtr (CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO ()) + +-- | p_scal : Pointer to function : n a x incx -> void +foreign import ccall "THBlas.h &THFloatBlas_scal" + p_scal :: FunPtr (CLLong -> CFloat -> Ptr CFloat -> CLLong -> IO ()) + +-- | p_copy : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THFloatBlas_copy" + p_copy :: FunPtr (CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO ()) + +-- | p_axpy : Pointer to function : n a x incx y incy -> void +foreign import ccall "THBlas.h &THFloatBlas_axpy" + p_axpy :: FunPtr (CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO ()) + +-- | p_dot : Pointer to function : n x incx y incy -> real +foreign import ccall "THBlas.h &THFloatBlas_dot" + p_dot :: FunPtr (CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO CFloat) + +-- | p_gemv : Pointer to function : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h &THFloatBlas_gemv" + p_gemv :: FunPtr (CChar -> CLLong -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> IO ()) + +-- | p_ger : Pointer to function : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h &THFloatBlas_ger" + p_ger :: FunPtr (CLLong -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> IO ()) + +-- | p_gemm : Pointer to function : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h &THFloatBlas_gemm" + p_gemm :: FunPtr (CChar -> CChar -> CLLong -> CLLong -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> Ptr CFloat -> CLLong -> CFloat -> Ptr CFloat -> CLLong -> IO ()) diff --git a/src/Torch/FFI/TH/Float/Lapack.hs b/src/Torch/FFI/TH/Float/Lapack.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/Lapack.hs @@ -0,0 +1,200 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.Lapack where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_gesv : n nrhs a lda ipiv b ldb info -> void +foreign import ccall "THLapack.h THFloatLapack_gesv" + c_gesv_ :: CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_gesv_ with unused argument (for CTHState) to unify backpack signatures. +c_gesv :: Ptr C'THState -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_gesv = const c_gesv_ + +-- | c_trtrs : uplo trans diag n nrhs a lda b ldb info -> void +foreign import ccall "THLapack.h THFloatLapack_trtrs" + c_trtrs_ :: CChar -> CChar -> CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_trtrs_ with unused argument (for CTHState) to unify backpack signatures. +c_trtrs :: Ptr C'THState -> CChar -> CChar -> CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_trtrs = const c_trtrs_ + +-- | c_gels : trans m n nrhs a lda b ldb work lwork info -> void +foreign import ccall "THLapack.h THFloatLapack_gels" + c_gels_ :: CChar -> CInt -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_gels_ with unused argument (for CTHState) to unify backpack signatures. +c_gels :: Ptr C'THState -> CChar -> CInt -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_gels = const c_gels_ + +-- | c_syev : jobz uplo n a lda w work lwork info -> void +foreign import ccall "THLapack.h THFloatLapack_syev" + c_syev_ :: CChar -> CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_syev_ with unused argument (for CTHState) to unify backpack signatures. +c_syev :: Ptr C'THState -> CChar -> CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_syev = const c_syev_ + +-- | c_geev : jobvl jobvr n a lda wr wi vl ldvl vr ldvr work lwork info -> void +foreign import ccall "THLapack.h THFloatLapack_geev" + c_geev_ :: CChar -> CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_geev_ with unused argument (for CTHState) to unify backpack signatures. +c_geev :: Ptr C'THState -> CChar -> CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_geev = const c_geev_ + +-- | c_gesvd : jobu jobvt m n a lda s u ldu vt ldvt work lwork info -> void +foreign import ccall "THLapack.h THFloatLapack_gesvd" + c_gesvd_ :: CChar -> CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_gesvd_ with unused argument (for CTHState) to unify backpack signatures. +c_gesvd :: Ptr C'THState -> CChar -> CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_gesvd = const c_gesvd_ + +-- | c_getrf : m n a lda ipiv info -> void +foreign import ccall "THLapack.h THFloatLapack_getrf" + c_getrf_ :: CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CInt -> IO () + +-- | alias of c_getrf_ with unused argument (for CTHState) to unify backpack signatures. +c_getrf :: Ptr C'THState -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CInt -> IO () +c_getrf = const c_getrf_ + +-- | c_getrs : trans n nrhs a lda ipiv b ldb info -> void +foreign import ccall "THLapack.h THFloatLapack_getrs" + c_getrs_ :: CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_getrs_ with unused argument (for CTHState) to unify backpack signatures. +c_getrs :: Ptr C'THState -> CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_getrs = const c_getrs_ + +-- | c_getri : n a lda ipiv work lwork info -> void +foreign import ccall "THLapack.h THFloatLapack_getri" + c_getri_ :: CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_getri_ with unused argument (for CTHState) to unify backpack signatures. +c_getri :: Ptr C'THState -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_getri = const c_getri_ + +-- | c_potrf : uplo n a lda info -> void +foreign import ccall "THLapack.h THFloatLapack_potrf" + c_potrf_ :: CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_potrf_ with unused argument (for CTHState) to unify backpack signatures. +c_potrf :: Ptr C'THState -> CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_potrf = const c_potrf_ + +-- | c_potri : uplo n a lda info -> void +foreign import ccall "THLapack.h THFloatLapack_potri" + c_potri_ :: CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_potri_ with unused argument (for CTHState) to unify backpack signatures. +c_potri :: Ptr C'THState -> CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_potri = const c_potri_ + +-- | c_potrs : uplo n nrhs a lda b ldb info -> void +foreign import ccall "THLapack.h THFloatLapack_potrs" + c_potrs_ :: CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_potrs_ with unused argument (for CTHState) to unify backpack signatures. +c_potrs :: Ptr C'THState -> CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_potrs = const c_potrs_ + +-- | c_pstrf : uplo n a lda piv rank tol work info -> void +foreign import ccall "THLapack.h THFloatLapack_pstrf" + c_pstrf_ :: CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CInt -> CFloat -> Ptr CFloat -> Ptr CInt -> IO () + +-- | alias of c_pstrf_ with unused argument (for CTHState) to unify backpack signatures. +c_pstrf :: Ptr C'THState -> CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CInt -> CFloat -> Ptr CFloat -> Ptr CInt -> IO () +c_pstrf = const c_pstrf_ + +-- | c_geqrf : m n a lda tau work lwork info -> void +foreign import ccall "THLapack.h THFloatLapack_geqrf" + c_geqrf_ :: CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_geqrf_ with unused argument (for CTHState) to unify backpack signatures. +c_geqrf :: Ptr C'THState -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_geqrf = const c_geqrf_ + +-- | c_orgqr : m n k a lda tau work lwork info -> void +foreign import ccall "THLapack.h THFloatLapack_orgqr" + c_orgqr_ :: CInt -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_orgqr_ with unused argument (for CTHState) to unify backpack signatures. +c_orgqr :: Ptr C'THState -> CInt -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_orgqr = const c_orgqr_ + +-- | c_ormqr : side trans m n k a lda tau c ldc work lwork info -> void +foreign import ccall "THLapack.h THFloatLapack_ormqr" + c_ormqr_ :: CChar -> CChar -> CInt -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () + +-- | alias of c_ormqr_ with unused argument (for CTHState) to unify backpack signatures. +c_ormqr :: Ptr C'THState -> CChar -> CChar -> CInt -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO () +c_ormqr = const c_ormqr_ + +-- | p_gesv : Pointer to function : n nrhs a lda ipiv b ldb info -> void +foreign import ccall "THLapack.h &THFloatLapack_gesv" + p_gesv :: FunPtr (CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_trtrs : Pointer to function : uplo trans diag n nrhs a lda b ldb info -> void +foreign import ccall "THLapack.h &THFloatLapack_trtrs" + p_trtrs :: FunPtr (CChar -> CChar -> CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_gels : Pointer to function : trans m n nrhs a lda b ldb work lwork info -> void +foreign import ccall "THLapack.h &THFloatLapack_gels" + p_gels :: FunPtr (CChar -> CInt -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_syev : Pointer to function : jobz uplo n a lda w work lwork info -> void +foreign import ccall "THLapack.h &THFloatLapack_syev" + p_syev :: FunPtr (CChar -> CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_geev : Pointer to function : jobvl jobvr n a lda wr wi vl ldvl vr ldvr work lwork info -> void +foreign import ccall "THLapack.h &THFloatLapack_geev" + p_geev :: FunPtr (CChar -> CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_gesvd : Pointer to function : jobu jobvt m n a lda s u ldu vt ldvt work lwork info -> void +foreign import ccall "THLapack.h &THFloatLapack_gesvd" + p_gesvd :: FunPtr (CChar -> CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_getrf : Pointer to function : m n a lda ipiv info -> void +foreign import ccall "THLapack.h &THFloatLapack_getrf" + p_getrf :: FunPtr (CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CInt -> IO ()) + +-- | p_getrs : Pointer to function : trans n nrhs a lda ipiv b ldb info -> void +foreign import ccall "THLapack.h &THFloatLapack_getrs" + p_getrs :: FunPtr (CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_getri : Pointer to function : n a lda ipiv work lwork info -> void +foreign import ccall "THLapack.h &THFloatLapack_getri" + p_getri :: FunPtr (CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_potrf : Pointer to function : uplo n a lda info -> void +foreign import ccall "THLapack.h &THFloatLapack_potrf" + p_potrf :: FunPtr (CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_potri : Pointer to function : uplo n a lda info -> void +foreign import ccall "THLapack.h &THFloatLapack_potri" + p_potri :: FunPtr (CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_potrs : Pointer to function : uplo n nrhs a lda b ldb info -> void +foreign import ccall "THLapack.h &THFloatLapack_potrs" + p_potrs :: FunPtr (CChar -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_pstrf : Pointer to function : uplo n a lda piv rank tol work info -> void +foreign import ccall "THLapack.h &THFloatLapack_pstrf" + p_pstrf :: FunPtr (CChar -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> Ptr CInt -> CFloat -> Ptr CFloat -> Ptr CInt -> IO ()) + +-- | p_geqrf : Pointer to function : m n a lda tau work lwork info -> void +foreign import ccall "THLapack.h &THFloatLapack_geqrf" + p_geqrf :: FunPtr (CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_orgqr : Pointer to function : m n k a lda tau work lwork info -> void +foreign import ccall "THLapack.h &THFloatLapack_orgqr" + p_orgqr :: FunPtr (CInt -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) + +-- | p_ormqr : Pointer to function : side trans m n k a lda tau c ldc work lwork info -> void +foreign import ccall "THLapack.h &THFloatLapack_ormqr" + p_ormqr :: FunPtr (CChar -> CChar -> CInt -> CInt -> CInt -> Ptr CFloat -> CInt -> Ptr CFloat -> Ptr CFloat -> CInt -> Ptr CFloat -> CInt -> Ptr CInt -> IO ()) diff --git a/src/Torch/FFI/TH/Float/Storage.hs b/src/Torch/FFI/TH/Float/Storage.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/Storage.hs @@ -0,0 +1,260 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.Storage where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_data : -> real * +foreign import ccall "THStorage.h THFloatStorage_data" + c_data_ :: Ptr C'THFloatStorage -> IO (Ptr CFloat) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THFloatStorage -> IO (Ptr CFloat) +c_data = const c_data_ + +-- | c_size : -> ptrdiff_t +foreign import ccall "THStorage.h THFloatStorage_size" + c_size_ :: Ptr C'THFloatStorage -> IO CPtrdiff + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THFloatStorage -> IO CPtrdiff +c_size = const c_size_ + +-- | c_set : -> void +foreign import ccall "THStorage.h THFloatStorage_set" + c_set_ :: Ptr C'THFloatStorage -> CPtrdiff -> CFloat -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THFloatStorage -> CPtrdiff -> CFloat -> IO () +c_set = const c_set_ + +-- | c_get : -> real +foreign import ccall "THStorage.h THFloatStorage_get" + c_get_ :: Ptr C'THFloatStorage -> CPtrdiff -> IO CFloat + +-- | alias of c_get_ with unused argument (for CTHState) to unify backpack signatures. +c_get :: Ptr C'THState -> Ptr C'THFloatStorage -> CPtrdiff -> IO CFloat +c_get = const c_get_ + +-- | c_new : -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_new" + c_new_ :: IO (Ptr C'THFloatStorage) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THFloatStorage) +c_new = const c_new_ + +-- | c_newWithSize : size -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_newWithSize" + c_newWithSize_ :: CPtrdiff -> IO (Ptr C'THFloatStorage) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> CPtrdiff -> IO (Ptr C'THFloatStorage) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1 : -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_newWithSize1" + c_newWithSize1_ :: CFloat -> IO (Ptr C'THFloatStorage) + +-- | alias of c_newWithSize1_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1 :: Ptr C'THState -> CFloat -> IO (Ptr C'THFloatStorage) +c_newWithSize1 = const c_newWithSize1_ + +-- | c_newWithSize2 : -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_newWithSize2" + c_newWithSize2_ :: CFloat -> CFloat -> IO (Ptr C'THFloatStorage) + +-- | alias of c_newWithSize2_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2 :: Ptr C'THState -> CFloat -> CFloat -> IO (Ptr C'THFloatStorage) +c_newWithSize2 = const c_newWithSize2_ + +-- | c_newWithSize3 : -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_newWithSize3" + c_newWithSize3_ :: CFloat -> CFloat -> CFloat -> IO (Ptr C'THFloatStorage) + +-- | alias of c_newWithSize3_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3 :: Ptr C'THState -> CFloat -> CFloat -> CFloat -> IO (Ptr C'THFloatStorage) +c_newWithSize3 = const c_newWithSize3_ + +-- | c_newWithSize4 : -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_newWithSize4" + c_newWithSize4_ :: CFloat -> CFloat -> CFloat -> CFloat -> IO (Ptr C'THFloatStorage) + +-- | alias of c_newWithSize4_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4 :: Ptr C'THState -> CFloat -> CFloat -> CFloat -> CFloat -> IO (Ptr C'THFloatStorage) +c_newWithSize4 = const c_newWithSize4_ + +-- | c_newWithMapping : filename size flags -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_newWithMapping" + c_newWithMapping_ :: Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THFloatStorage) + +-- | alias of c_newWithMapping_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithMapping :: Ptr C'THState -> Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THFloatStorage) +c_newWithMapping = const c_newWithMapping_ + +-- | c_newWithData : data size -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_newWithData" + c_newWithData_ :: Ptr CFloat -> CPtrdiff -> IO (Ptr C'THFloatStorage) + +-- | alias of c_newWithData_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithData :: Ptr C'THState -> Ptr CFloat -> CPtrdiff -> IO (Ptr C'THFloatStorage) +c_newWithData = const c_newWithData_ + +-- | c_newWithAllocator : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_newWithAllocator" + c_newWithAllocator_ :: CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THFloatStorage) + +-- | alias of c_newWithAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithAllocator :: Ptr C'THState -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THFloatStorage) +c_newWithAllocator = const c_newWithAllocator_ + +-- | c_newWithDataAndAllocator : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THFloatStorage_newWithDataAndAllocator" + c_newWithDataAndAllocator_ :: Ptr CFloat -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THFloatStorage) + +-- | alias of c_newWithDataAndAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithDataAndAllocator :: Ptr C'THState -> Ptr CFloat -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THFloatStorage) +c_newWithDataAndAllocator = const c_newWithDataAndAllocator_ + +-- | c_setFlag : storage flag -> void +foreign import ccall "THStorage.h THFloatStorage_setFlag" + c_setFlag_ :: Ptr C'THFloatStorage -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THFloatStorage -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : storage flag -> void +foreign import ccall "THStorage.h THFloatStorage_clearFlag" + c_clearFlag_ :: Ptr C'THFloatStorage -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THFloatStorage -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_retain : storage -> void +foreign import ccall "THStorage.h THFloatStorage_retain" + c_retain_ :: Ptr C'THFloatStorage -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THFloatStorage -> IO () +c_retain = const c_retain_ + +-- | c_swap : storage1 storage2 -> void +foreign import ccall "THStorage.h THFloatStorage_swap" + c_swap_ :: Ptr C'THFloatStorage -> Ptr C'THFloatStorage -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THFloatStorage -> IO () +c_swap = const c_swap_ + +-- | c_free : storage -> void +foreign import ccall "THStorage.h THFloatStorage_free" + c_free_ :: Ptr C'THFloatStorage -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THFloatStorage -> IO () +c_free = const c_free_ + +-- | c_resize : storage size -> void +foreign import ccall "THStorage.h THFloatStorage_resize" + c_resize_ :: Ptr C'THFloatStorage -> CPtrdiff -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THFloatStorage -> CPtrdiff -> IO () +c_resize = const c_resize_ + +-- | c_fill : storage value -> void +foreign import ccall "THStorage.h THFloatStorage_fill" + c_fill_ :: Ptr C'THFloatStorage -> CFloat -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THFloatStorage -> CFloat -> IO () +c_fill = const c_fill_ + +-- | p_data : Pointer to function : -> real * +foreign import ccall "THStorage.h &THFloatStorage_data" + p_data :: FunPtr (Ptr C'THFloatStorage -> IO (Ptr CFloat)) + +-- | p_size : Pointer to function : -> ptrdiff_t +foreign import ccall "THStorage.h &THFloatStorage_size" + p_size :: FunPtr (Ptr C'THFloatStorage -> IO CPtrdiff) + +-- | p_set : Pointer to function : -> void +foreign import ccall "THStorage.h &THFloatStorage_set" + p_set :: FunPtr (Ptr C'THFloatStorage -> CPtrdiff -> CFloat -> IO ()) + +-- | p_get : Pointer to function : -> real +foreign import ccall "THStorage.h &THFloatStorage_get" + p_get :: FunPtr (Ptr C'THFloatStorage -> CPtrdiff -> IO CFloat) + +-- | p_new : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_new" + p_new :: FunPtr (IO (Ptr C'THFloatStorage)) + +-- | p_newWithSize : Pointer to function : size -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_newWithSize" + p_newWithSize :: FunPtr (CPtrdiff -> IO (Ptr C'THFloatStorage)) + +-- | p_newWithSize1 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_newWithSize1" + p_newWithSize1 :: FunPtr (CFloat -> IO (Ptr C'THFloatStorage)) + +-- | p_newWithSize2 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_newWithSize2" + p_newWithSize2 :: FunPtr (CFloat -> CFloat -> IO (Ptr C'THFloatStorage)) + +-- | p_newWithSize3 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_newWithSize3" + p_newWithSize3 :: FunPtr (CFloat -> CFloat -> CFloat -> IO (Ptr C'THFloatStorage)) + +-- | p_newWithSize4 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_newWithSize4" + p_newWithSize4 :: FunPtr (CFloat -> CFloat -> CFloat -> CFloat -> IO (Ptr C'THFloatStorage)) + +-- | p_newWithMapping : Pointer to function : filename size flags -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_newWithMapping" + p_newWithMapping :: FunPtr (Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THFloatStorage)) + +-- | p_newWithData : Pointer to function : data size -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_newWithData" + p_newWithData :: FunPtr (Ptr CFloat -> CPtrdiff -> IO (Ptr C'THFloatStorage)) + +-- | p_newWithAllocator : Pointer to function : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_newWithAllocator" + p_newWithAllocator :: FunPtr (CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THFloatStorage)) + +-- | p_newWithDataAndAllocator : Pointer to function : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THFloatStorage_newWithDataAndAllocator" + p_newWithDataAndAllocator :: FunPtr (Ptr CFloat -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THFloatStorage)) + +-- | p_setFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THFloatStorage_setFlag" + p_setFlag :: FunPtr (Ptr C'THFloatStorage -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THFloatStorage_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THFloatStorage -> CChar -> IO ()) + +-- | p_retain : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THFloatStorage_retain" + p_retain :: FunPtr (Ptr C'THFloatStorage -> IO ()) + +-- | p_swap : Pointer to function : storage1 storage2 -> void +foreign import ccall "THStorage.h &THFloatStorage_swap" + p_swap :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THFloatStorage -> IO ()) + +-- | p_free : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THFloatStorage_free" + p_free :: FunPtr (Ptr C'THFloatStorage -> IO ()) + +-- | p_resize : Pointer to function : storage size -> void +foreign import ccall "THStorage.h &THFloatStorage_resize" + p_resize :: FunPtr (Ptr C'THFloatStorage -> CPtrdiff -> IO ()) + +-- | p_fill : Pointer to function : storage value -> void +foreign import ccall "THStorage.h &THFloatStorage_fill" + p_fill :: FunPtr (Ptr C'THFloatStorage -> CFloat -> IO ()) diff --git a/src/Torch/FFI/TH/Float/StorageCopy.hs b/src/Torch/FFI/TH/Float/StorageCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/StorageCopy.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.StorageCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_rawCopy : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_rawCopy" + c_rawCopy_ :: Ptr C'THFloatStorage -> Ptr CFloat -> IO () + +-- | alias of c_rawCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_rawCopy :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr CFloat -> IO () +c_rawCopy = const c_rawCopy_ + +-- | c_copy : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_copy" + c_copy_ :: Ptr C'THFloatStorage -> Ptr C'THFloatStorage -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THFloatStorage -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_copyByte" + c_copyByte_ :: Ptr C'THFloatStorage -> Ptr C'THByteStorage -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THByteStorage -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_copyChar" + c_copyChar_ :: Ptr C'THFloatStorage -> Ptr C'THCharStorage -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THCharStorage -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_copyShort" + c_copyShort_ :: Ptr C'THFloatStorage -> Ptr C'THShortStorage -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THShortStorage -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_copyInt" + c_copyInt_ :: Ptr C'THFloatStorage -> Ptr C'THIntStorage -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THIntStorage -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_copyLong" + c_copyLong_ :: Ptr C'THFloatStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THLongStorage -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_copyFloat" + c_copyFloat_ :: Ptr C'THFloatStorage -> Ptr C'THFloatStorage -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THFloatStorage -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_copyDouble" + c_copyDouble_ :: Ptr C'THFloatStorage -> Ptr C'THDoubleStorage -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THDoubleStorage -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : storage src -> void +foreign import ccall "THStorageCopy.h THFloatStorage_copyHalf" + c_copyHalf_ :: Ptr C'THFloatStorage -> Ptr C'THHalfStorage -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THFloatStorage -> Ptr C'THHalfStorage -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_rawCopy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_rawCopy" + p_rawCopy :: FunPtr (Ptr C'THFloatStorage -> Ptr CFloat -> IO ()) + +-- | p_copy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_copy" + p_copy :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THFloatStorage -> IO ()) + +-- | p_copyByte : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_copyByte" + p_copyByte :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THByteStorage -> IO ()) + +-- | p_copyChar : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_copyChar" + p_copyChar :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THCharStorage -> IO ()) + +-- | p_copyShort : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_copyShort" + p_copyShort :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THShortStorage -> IO ()) + +-- | p_copyInt : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_copyInt" + p_copyInt :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THIntStorage -> IO ()) + +-- | p_copyLong : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_copyLong" + p_copyLong :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_copyFloat : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THFloatStorage -> IO ()) + +-- | p_copyDouble : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THDoubleStorage -> IO ()) + +-- | p_copyHalf : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THFloatStorage_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THFloatStorage -> Ptr C'THHalfStorage -> IO ()) diff --git a/src/Torch/FFI/TH/Float/Tensor.hs b/src/Torch/FFI/TH/Float/Tensor.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/Tensor.hs @@ -0,0 +1,872 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.Tensor where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_storage : self -> THStorage * +foreign import ccall "THTensor.h THFloatTensor_storage" + c_storage_ :: Ptr C'THFloatTensor -> IO (Ptr C'THFloatStorage) + +-- | alias of c_storage_ with unused argument (for CTHState) to unify backpack signatures. +c_storage :: Ptr C'THState -> Ptr C'THFloatTensor -> IO (Ptr C'THFloatStorage) +c_storage = const c_storage_ + +-- | c_storageOffset : self -> ptrdiff_t +foreign import ccall "THTensor.h THFloatTensor_storageOffset" + c_storageOffset_ :: Ptr C'THFloatTensor -> IO CPtrdiff + +-- | alias of c_storageOffset_ with unused argument (for CTHState) to unify backpack signatures. +c_storageOffset :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CPtrdiff +c_storageOffset = const c_storageOffset_ + +-- | c_nDimension : self -> int +foreign import ccall "THTensor.h THFloatTensor_nDimension" + c_nDimension_ :: Ptr C'THFloatTensor -> IO CInt + +-- | alias of c_nDimension_ with unused argument (for CTHState) to unify backpack signatures. +c_nDimension :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CInt +c_nDimension = const c_nDimension_ + +-- | c_size : self dim -> int64_t +foreign import ccall "THTensor.h THFloatTensor_size" + c_size_ :: Ptr C'THFloatTensor -> CInt -> IO CLLong + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> IO CLLong +c_size = const c_size_ + +-- | c_stride : self dim -> int64_t +foreign import ccall "THTensor.h THFloatTensor_stride" + c_stride_ :: Ptr C'THFloatTensor -> CInt -> IO CLLong + +-- | alias of c_stride_ with unused argument (for CTHState) to unify backpack signatures. +c_stride :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> IO CLLong +c_stride = const c_stride_ + +-- | c_newSizeOf : self -> THLongStorage * +foreign import ccall "THTensor.h THFloatTensor_newSizeOf" + c_newSizeOf_ :: Ptr C'THFloatTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newSizeOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newSizeOf :: Ptr C'THState -> Ptr C'THFloatTensor -> IO (Ptr C'THLongStorage) +c_newSizeOf = const c_newSizeOf_ + +-- | c_newStrideOf : self -> THLongStorage * +foreign import ccall "THTensor.h THFloatTensor_newStrideOf" + c_newStrideOf_ :: Ptr C'THFloatTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newStrideOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newStrideOf :: Ptr C'THState -> Ptr C'THFloatTensor -> IO (Ptr C'THLongStorage) +c_newStrideOf = const c_newStrideOf_ + +-- | c_data : self -> real * +foreign import ccall "THTensor.h THFloatTensor_data" + c_data_ :: Ptr C'THFloatTensor -> IO (Ptr CFloat) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THFloatTensor -> IO (Ptr CFloat) +c_data = const c_data_ + +-- | c_setFlag : self flag -> void +foreign import ccall "THTensor.h THFloatTensor_setFlag" + c_setFlag_ :: Ptr C'THFloatTensor -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THFloatTensor -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : self flag -> void +foreign import ccall "THTensor.h THFloatTensor_clearFlag" + c_clearFlag_ :: Ptr C'THFloatTensor -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THFloatTensor -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_new : -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_new" + c_new_ :: IO (Ptr C'THFloatTensor) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THFloatTensor) +c_new = const c_new_ + +-- | c_newWithTensor : tensor -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithTensor" + c_newWithTensor_ :: Ptr C'THFloatTensor -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithTensor :: Ptr C'THState -> Ptr C'THFloatTensor -> IO (Ptr C'THFloatTensor) +c_newWithTensor = const c_newWithTensor_ + +-- | c_newWithStorage : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithStorage" + c_newWithStorage_ :: Ptr C'THFloatStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage :: Ptr C'THState -> Ptr C'THFloatStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor) +c_newWithStorage = const c_newWithStorage_ + +-- | c_newWithStorage1d : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithStorage1d" + c_newWithStorage1d_ :: Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage1d :: Ptr C'THState -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) +c_newWithStorage1d = const c_newWithStorage1d_ + +-- | c_newWithStorage2d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithStorage2d" + c_newWithStorage2d_ :: Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage2d :: Ptr C'THState -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) +c_newWithStorage2d = const c_newWithStorage2d_ + +-- | c_newWithStorage3d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithStorage3d" + c_newWithStorage3d_ :: Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage3d :: Ptr C'THState -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) +c_newWithStorage3d = const c_newWithStorage3d_ + +-- | c_newWithStorage4d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithStorage4d" + c_newWithStorage4d_ :: Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage4d :: Ptr C'THState -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) +c_newWithStorage4d = const c_newWithStorage4d_ + +-- | c_newWithSize : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithSize" + c_newWithSize_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1d : size0_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithSize1d" + c_newWithSize1d_ :: CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithSize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1d :: Ptr C'THState -> CLLong -> IO (Ptr C'THFloatTensor) +c_newWithSize1d = const c_newWithSize1d_ + +-- | c_newWithSize2d : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithSize2d" + c_newWithSize2d_ :: CLLong -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithSize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2d :: Ptr C'THState -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) +c_newWithSize2d = const c_newWithSize2d_ + +-- | c_newWithSize3d : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithSize3d" + c_newWithSize3d_ :: CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithSize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) +c_newWithSize3d = const c_newWithSize3d_ + +-- | c_newWithSize4d : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newWithSize4d" + c_newWithSize4d_ :: CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newWithSize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) +c_newWithSize4d = const c_newWithSize4d_ + +-- | c_newClone : self -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newClone" + c_newClone_ :: Ptr C'THFloatTensor -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newClone_ with unused argument (for CTHState) to unify backpack signatures. +c_newClone :: Ptr C'THState -> Ptr C'THFloatTensor -> IO (Ptr C'THFloatTensor) +c_newClone = const c_newClone_ + +-- | c_newContiguous : tensor -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newContiguous" + c_newContiguous_ :: Ptr C'THFloatTensor -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_newContiguous :: Ptr C'THState -> Ptr C'THFloatTensor -> IO (Ptr C'THFloatTensor) +c_newContiguous = const c_newContiguous_ + +-- | c_newSelect : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newSelect" + c_newSelect_ :: Ptr C'THFloatTensor -> CInt -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_newSelect :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> CLLong -> IO (Ptr C'THFloatTensor) +c_newSelect = const c_newSelect_ + +-- | c_newNarrow : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newNarrow" + c_newNarrow_ :: Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newNarrow_ with unused argument (for CTHState) to unify backpack signatures. +c_newNarrow :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) +c_newNarrow = const c_newNarrow_ + +-- | c_newTranspose : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newTranspose" + c_newTranspose_ :: Ptr C'THFloatTensor -> CInt -> CInt -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newTranspose_ with unused argument (for CTHState) to unify backpack signatures. +c_newTranspose :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> CInt -> IO (Ptr C'THFloatTensor) +c_newTranspose = const c_newTranspose_ + +-- | c_newUnfold : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newUnfold" + c_newUnfold_ :: Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newUnfold_ with unused argument (for CTHState) to unify backpack signatures. +c_newUnfold :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor) +c_newUnfold = const c_newUnfold_ + +-- | c_newView : tensor size -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newView" + c_newView_ :: Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newView_ with unused argument (for CTHState) to unify backpack signatures. +c_newView :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor) +c_newView = const c_newView_ + +-- | c_newExpand : tensor size -> THTensor * +foreign import ccall "THTensor.h THFloatTensor_newExpand" + c_newExpand_ :: Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor) + +-- | alias of c_newExpand_ with unused argument (for CTHState) to unify backpack signatures. +c_newExpand :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor) +c_newExpand = const c_newExpand_ + +-- | c_expand : r tensor size -> void +foreign import ccall "THTensor.h THFloatTensor_expand" + c_expand_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_expand_ with unused argument (for CTHState) to unify backpack signatures. +c_expand :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO () +c_expand = const c_expand_ + +-- | c_expandNd : rets ops count -> void +foreign import ccall "THTensor.h THFloatTensor_expandNd" + c_expandNd_ :: Ptr (Ptr C'THFloatTensor) -> Ptr (Ptr C'THFloatTensor) -> CInt -> IO () + +-- | alias of c_expandNd_ with unused argument (for CTHState) to unify backpack signatures. +c_expandNd :: Ptr C'THState -> Ptr (Ptr C'THFloatTensor) -> Ptr (Ptr C'THFloatTensor) -> CInt -> IO () +c_expandNd = const c_expandNd_ + +-- | c_resize : tensor size stride -> void +foreign import ccall "THTensor.h THFloatTensor_resize" + c_resize_ :: Ptr C'THFloatTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_resize = const c_resize_ + +-- | c_resizeAs : tensor src -> void +foreign import ccall "THTensor.h THFloatTensor_resizeAs" + c_resizeAs_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_resizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeAs :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_resizeAs = const c_resizeAs_ + +-- | c_resizeNd : tensor nDimension size stride -> void +foreign import ccall "THTensor.h THFloatTensor_resizeNd" + c_resizeNd_ :: Ptr C'THFloatTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_resizeNd_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeNd :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_resizeNd = const c_resizeNd_ + +-- | c_resize1d : tensor size0_ -> void +foreign import ccall "THTensor.h THFloatTensor_resize1d" + c_resize1d_ :: Ptr C'THFloatTensor -> CLLong -> IO () + +-- | alias of c_resize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize1d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> IO () +c_resize1d = const c_resize1d_ + +-- | c_resize2d : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h THFloatTensor_resize2d" + c_resize2d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_resize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize2d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> IO () +c_resize2d = const c_resize2d_ + +-- | c_resize3d : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h THFloatTensor_resize3d" + c_resize3d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize3d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> IO () +c_resize3d = const c_resize3d_ + +-- | c_resize4d : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h THFloatTensor_resize4d" + c_resize4d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize4d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize4d = const c_resize4d_ + +-- | c_resize5d : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h THFloatTensor_resize5d" + c_resize5d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize5d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize5d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize5d = const c_resize5d_ + +-- | c_set : self src -> void +foreign import ccall "THTensor.h THFloatTensor_set" + c_set_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_set = const c_set_ + +-- | c_setStorage : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h THFloatTensor_setStorage" + c_setStorage_ :: Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_setStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_setStorage = const c_setStorage_ + +-- | c_setStorageNd : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h THFloatTensor_setStorageNd" + c_setStorageNd_ :: Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_setStorageNd_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorageNd :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_setStorageNd = const c_setStorageNd_ + +-- | c_setStorage1d : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h THFloatTensor_setStorage1d" + c_setStorage1d_ :: Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage1d :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> IO () +c_setStorage1d = const c_setStorage1d_ + +-- | c_setStorage2d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h THFloatTensor_setStorage2d" + c_setStorage2d_ :: Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage2d :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage2d = const c_setStorage2d_ + +-- | c_setStorage3d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h THFloatTensor_setStorage3d" + c_setStorage3d_ :: Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage3d :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage3d = const c_setStorage3d_ + +-- | c_setStorage4d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h THFloatTensor_setStorage4d" + c_setStorage4d_ :: Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage4d :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage4d = const c_setStorage4d_ + +-- | c_narrow : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h THFloatTensor_narrow" + c_narrow_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_narrow_ with unused argument (for CTHState) to unify backpack signatures. +c_narrow :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO () +c_narrow = const c_narrow_ + +-- | c_select : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h THFloatTensor_select" + c_select_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CLLong -> IO () + +-- | alias of c_select_ with unused argument (for CTHState) to unify backpack signatures. +c_select :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CLLong -> IO () +c_select = const c_select_ + +-- | c_transpose : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h THFloatTensor_transpose" + c_transpose_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_transpose_ with unused argument (for CTHState) to unify backpack signatures. +c_transpose :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_transpose = const c_transpose_ + +-- | c_unfold : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h THFloatTensor_unfold" + c_unfold_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_unfold_ with unused argument (for CTHState) to unify backpack signatures. +c_unfold :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO () +c_unfold = const c_unfold_ + +-- | c_squeeze : self src -> void +foreign import ccall "THTensor.h THFloatTensor_squeeze" + c_squeeze_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_squeeze_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_squeeze = const c_squeeze_ + +-- | c_squeeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THFloatTensor_squeeze1d" + c_squeeze1d_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | alias of c_squeeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze1d :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () +c_squeeze1d = const c_squeeze1d_ + +-- | c_unsqueeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THFloatTensor_unsqueeze1d" + c_unsqueeze1d_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | alias of c_unsqueeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_unsqueeze1d :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () +c_unsqueeze1d = const c_unsqueeze1d_ + +-- | c_isContiguous : self -> int +foreign import ccall "THTensor.h THFloatTensor_isContiguous" + c_isContiguous_ :: Ptr C'THFloatTensor -> IO CInt + +-- | alias of c_isContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_isContiguous :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CInt +c_isContiguous = const c_isContiguous_ + +-- | c_isSameSizeAs : self src -> int +foreign import ccall "THTensor.h THFloatTensor_isSameSizeAs" + c_isSameSizeAs_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CInt + +-- | alias of c_isSameSizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_isSameSizeAs :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CInt +c_isSameSizeAs = const c_isSameSizeAs_ + +-- | c_isSetTo : self src -> int +foreign import ccall "THTensor.h THFloatTensor_isSetTo" + c_isSetTo_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CInt + +-- | alias of c_isSetTo_ with unused argument (for CTHState) to unify backpack signatures. +c_isSetTo :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CInt +c_isSetTo = const c_isSetTo_ + +-- | c_isSize : self dims -> int +foreign import ccall "THTensor.h THFloatTensor_isSize" + c_isSize_ :: Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO CInt + +-- | alias of c_isSize_ with unused argument (for CTHState) to unify backpack signatures. +c_isSize :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO CInt +c_isSize = const c_isSize_ + +-- | c_nElement : self -> ptrdiff_t +foreign import ccall "THTensor.h THFloatTensor_nElement" + c_nElement_ :: Ptr C'THFloatTensor -> IO CPtrdiff + +-- | alias of c_nElement_ with unused argument (for CTHState) to unify backpack signatures. +c_nElement :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CPtrdiff +c_nElement = const c_nElement_ + +-- | c_retain : self -> void +foreign import ccall "THTensor.h THFloatTensor_retain" + c_retain_ :: Ptr C'THFloatTensor -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THFloatTensor -> IO () +c_retain = const c_retain_ + +-- | c_free : self -> void +foreign import ccall "THTensor.h THFloatTensor_free" + c_free_ :: Ptr C'THFloatTensor -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THFloatTensor -> IO () +c_free = const c_free_ + +-- | c_freeCopyTo : self dst -> void +foreign import ccall "THTensor.h THFloatTensor_freeCopyTo" + c_freeCopyTo_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_freeCopyTo_ with unused argument (for CTHState) to unify backpack signatures. +c_freeCopyTo :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_freeCopyTo = const c_freeCopyTo_ + +-- | c_set1d : tensor x0 value -> void +foreign import ccall "THTensor.h THFloatTensor_set1d" + c_set1d_ :: Ptr C'THFloatTensor -> CLLong -> CFloat -> IO () + +-- | alias of c_set1d_ with unused argument (for CTHState) to unify backpack signatures. +c_set1d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CFloat -> IO () +c_set1d = const c_set1d_ + +-- | c_set2d : tensor x0 x1 value -> void +foreign import ccall "THTensor.h THFloatTensor_set2d" + c_set2d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> CFloat -> IO () + +-- | alias of c_set2d_ with unused argument (for CTHState) to unify backpack signatures. +c_set2d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CFloat -> IO () +c_set2d = const c_set2d_ + +-- | c_set3d : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h THFloatTensor_set3d" + c_set3d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CFloat -> IO () + +-- | alias of c_set3d_ with unused argument (for CTHState) to unify backpack signatures. +c_set3d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CFloat -> IO () +c_set3d = const c_set3d_ + +-- | c_set4d : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h THFloatTensor_set4d" + c_set4d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CFloat -> IO () + +-- | alias of c_set4d_ with unused argument (for CTHState) to unify backpack signatures. +c_set4d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CFloat -> IO () +c_set4d = const c_set4d_ + +-- | c_get1d : tensor x0 -> real +foreign import ccall "THTensor.h THFloatTensor_get1d" + c_get1d_ :: Ptr C'THFloatTensor -> CLLong -> IO CFloat + +-- | alias of c_get1d_ with unused argument (for CTHState) to unify backpack signatures. +c_get1d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> IO CFloat +c_get1d = const c_get1d_ + +-- | c_get2d : tensor x0 x1 -> real +foreign import ccall "THTensor.h THFloatTensor_get2d" + c_get2d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> IO CFloat + +-- | alias of c_get2d_ with unused argument (for CTHState) to unify backpack signatures. +c_get2d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> IO CFloat +c_get2d = const c_get2d_ + +-- | c_get3d : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h THFloatTensor_get3d" + c_get3d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> IO CFloat + +-- | alias of c_get3d_ with unused argument (for CTHState) to unify backpack signatures. +c_get3d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> IO CFloat +c_get3d = const c_get3d_ + +-- | c_get4d : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h THFloatTensor_get4d" + c_get4d_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CFloat + +-- | alias of c_get4d_ with unused argument (for CTHState) to unify backpack signatures. +c_get4d :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CFloat +c_get4d = const c_get4d_ + +-- | c_desc : tensor -> THDescBuff +foreign import ccall "THTensor.h THFloatTensor_desc" + c_desc_ :: Ptr C'THFloatTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_desc_ with unused argument (for CTHState) to unify backpack signatures. +c_desc :: Ptr C'THState -> Ptr C'THFloatTensor -> IO (Ptr C'THDescBuff) +c_desc = const c_desc_ + +-- | c_sizeDesc : tensor -> THDescBuff +foreign import ccall "THTensor.h THFloatTensor_sizeDesc" + c_sizeDesc_ :: Ptr C'THFloatTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_sizeDesc_ with unused argument (for CTHState) to unify backpack signatures. +c_sizeDesc :: Ptr C'THState -> Ptr C'THFloatTensor -> IO (Ptr C'THDescBuff) +c_sizeDesc = const c_sizeDesc_ + +-- | p_storage : Pointer to function : self -> THStorage * +foreign import ccall "THTensor.h &THFloatTensor_storage" + p_storage :: FunPtr (Ptr C'THFloatTensor -> IO (Ptr C'THFloatStorage)) + +-- | p_storageOffset : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THFloatTensor_storageOffset" + p_storageOffset :: FunPtr (Ptr C'THFloatTensor -> IO CPtrdiff) + +-- | p_nDimension : Pointer to function : self -> int +foreign import ccall "THTensor.h &THFloatTensor_nDimension" + p_nDimension :: FunPtr (Ptr C'THFloatTensor -> IO CInt) + +-- | p_size : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THFloatTensor_size" + p_size :: FunPtr (Ptr C'THFloatTensor -> CInt -> IO CLLong) + +-- | p_stride : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THFloatTensor_stride" + p_stride :: FunPtr (Ptr C'THFloatTensor -> CInt -> IO CLLong) + +-- | p_newSizeOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THFloatTensor_newSizeOf" + p_newSizeOf :: FunPtr (Ptr C'THFloatTensor -> IO (Ptr C'THLongStorage)) + +-- | p_newStrideOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THFloatTensor_newStrideOf" + p_newStrideOf :: FunPtr (Ptr C'THFloatTensor -> IO (Ptr C'THLongStorage)) + +-- | p_data : Pointer to function : self -> real * +foreign import ccall "THTensor.h &THFloatTensor_data" + p_data :: FunPtr (Ptr C'THFloatTensor -> IO (Ptr CFloat)) + +-- | p_setFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THFloatTensor_setFlag" + p_setFlag :: FunPtr (Ptr C'THFloatTensor -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THFloatTensor_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THFloatTensor -> CChar -> IO ()) + +-- | p_new : Pointer to function : -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_new" + p_new :: FunPtr (IO (Ptr C'THFloatTensor)) + +-- | p_newWithTensor : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithTensor" + p_newWithTensor :: FunPtr (Ptr C'THFloatTensor -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithStorage : Pointer to function : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithStorage" + p_newWithStorage :: FunPtr (Ptr C'THFloatStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithStorage1d : Pointer to function : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithStorage1d" + p_newWithStorage1d :: FunPtr (Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithStorage2d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithStorage2d" + p_newWithStorage2d :: FunPtr (Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithStorage3d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithStorage3d" + p_newWithStorage3d :: FunPtr (Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithStorage4d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithStorage4d" + p_newWithStorage4d :: FunPtr (Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithSize : Pointer to function : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithSize" + p_newWithSize :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithSize1d : Pointer to function : size0_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithSize1d" + p_newWithSize1d :: FunPtr (CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithSize2d : Pointer to function : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithSize2d" + p_newWithSize2d :: FunPtr (CLLong -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithSize3d : Pointer to function : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithSize3d" + p_newWithSize3d :: FunPtr (CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newWithSize4d : Pointer to function : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newWithSize4d" + p_newWithSize4d :: FunPtr (CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newClone : Pointer to function : self -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newClone" + p_newClone :: FunPtr (Ptr C'THFloatTensor -> IO (Ptr C'THFloatTensor)) + +-- | p_newContiguous : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newContiguous" + p_newContiguous :: FunPtr (Ptr C'THFloatTensor -> IO (Ptr C'THFloatTensor)) + +-- | p_newSelect : Pointer to function : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newSelect" + p_newSelect :: FunPtr (Ptr C'THFloatTensor -> CInt -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newNarrow : Pointer to function : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newNarrow" + p_newNarrow :: FunPtr (Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newTranspose : Pointer to function : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newTranspose" + p_newTranspose :: FunPtr (Ptr C'THFloatTensor -> CInt -> CInt -> IO (Ptr C'THFloatTensor)) + +-- | p_newUnfold : Pointer to function : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newUnfold" + p_newUnfold :: FunPtr (Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THFloatTensor)) + +-- | p_newView : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newView" + p_newView :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor)) + +-- | p_newExpand : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THFloatTensor_newExpand" + p_newExpand :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO (Ptr C'THFloatTensor)) + +-- | p_expand : Pointer to function : r tensor size -> void +foreign import ccall "THTensor.h &THFloatTensor_expand" + p_expand :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_expandNd : Pointer to function : rets ops count -> void +foreign import ccall "THTensor.h &THFloatTensor_expandNd" + p_expandNd :: FunPtr (Ptr (Ptr C'THFloatTensor) -> Ptr (Ptr C'THFloatTensor) -> CInt -> IO ()) + +-- | p_resize : Pointer to function : tensor size stride -> void +foreign import ccall "THTensor.h &THFloatTensor_resize" + p_resize :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_resizeAs : Pointer to function : tensor src -> void +foreign import ccall "THTensor.h &THFloatTensor_resizeAs" + p_resizeAs :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_resizeNd : Pointer to function : tensor nDimension size stride -> void +foreign import ccall "THTensor.h &THFloatTensor_resizeNd" + p_resizeNd :: FunPtr (Ptr C'THFloatTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_resize1d : Pointer to function : tensor size0_ -> void +foreign import ccall "THTensor.h &THFloatTensor_resize1d" + p_resize1d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> IO ()) + +-- | p_resize2d : Pointer to function : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h &THFloatTensor_resize2d" + p_resize2d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> IO ()) + +-- | p_resize3d : Pointer to function : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h &THFloatTensor_resize3d" + p_resize3d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize4d : Pointer to function : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h &THFloatTensor_resize4d" + p_resize4d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize5d : Pointer to function : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h &THFloatTensor_resize5d" + p_resize5d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_set : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THFloatTensor_set" + p_set :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_setStorage : Pointer to function : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h &THFloatTensor_setStorage" + p_setStorage :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_setStorageNd : Pointer to function : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h &THFloatTensor_setStorageNd" + p_setStorageNd :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_setStorage1d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h &THFloatTensor_setStorage1d" + p_setStorage1d :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage2d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h &THFloatTensor_setStorage2d" + p_setStorage2d :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage3d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h &THFloatTensor_setStorage3d" + p_setStorage3d :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage4d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h &THFloatTensor_setStorage4d" + p_setStorage4d :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_narrow : Pointer to function : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h &THFloatTensor_narrow" + p_narrow :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_select : Pointer to function : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h &THFloatTensor_select" + p_select :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CLLong -> IO ()) + +-- | p_transpose : Pointer to function : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h &THFloatTensor_transpose" + p_transpose :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_unfold : Pointer to function : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h &THFloatTensor_unfold" + p_unfold :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_squeeze : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THFloatTensor_squeeze" + p_squeeze :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_squeeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THFloatTensor_squeeze1d" + p_squeeze1d :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_unsqueeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THFloatTensor_unsqueeze1d" + p_unsqueeze1d :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_isContiguous : Pointer to function : self -> int +foreign import ccall "THTensor.h &THFloatTensor_isContiguous" + p_isContiguous :: FunPtr (Ptr C'THFloatTensor -> IO CInt) + +-- | p_isSameSizeAs : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THFloatTensor_isSameSizeAs" + p_isSameSizeAs :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CInt) + +-- | p_isSetTo : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THFloatTensor_isSetTo" + p_isSetTo :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CInt) + +-- | p_isSize : Pointer to function : self dims -> int +foreign import ccall "THTensor.h &THFloatTensor_isSize" + p_isSize :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO CInt) + +-- | p_nElement : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THFloatTensor_nElement" + p_nElement :: FunPtr (Ptr C'THFloatTensor -> IO CPtrdiff) + +-- | p_retain : Pointer to function : self -> void +foreign import ccall "THTensor.h &THFloatTensor_retain" + p_retain :: FunPtr (Ptr C'THFloatTensor -> IO ()) + +-- | p_free : Pointer to function : self -> void +foreign import ccall "THTensor.h &THFloatTensor_free" + p_free :: FunPtr (Ptr C'THFloatTensor -> IO ()) + +-- | p_freeCopyTo : Pointer to function : self dst -> void +foreign import ccall "THTensor.h &THFloatTensor_freeCopyTo" + p_freeCopyTo :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_set1d : Pointer to function : tensor x0 value -> void +foreign import ccall "THTensor.h &THFloatTensor_set1d" + p_set1d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CFloat -> IO ()) + +-- | p_set2d : Pointer to function : tensor x0 x1 value -> void +foreign import ccall "THTensor.h &THFloatTensor_set2d" + p_set2d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> CFloat -> IO ()) + +-- | p_set3d : Pointer to function : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h &THFloatTensor_set3d" + p_set3d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CFloat -> IO ()) + +-- | p_set4d : Pointer to function : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h &THFloatTensor_set4d" + p_set4d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CFloat -> IO ()) + +-- | p_get1d : Pointer to function : tensor x0 -> real +foreign import ccall "THTensor.h &THFloatTensor_get1d" + p_get1d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> IO CFloat) + +-- | p_get2d : Pointer to function : tensor x0 x1 -> real +foreign import ccall "THTensor.h &THFloatTensor_get2d" + p_get2d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> IO CFloat) + +-- | p_get3d : Pointer to function : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h &THFloatTensor_get3d" + p_get3d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> IO CFloat) + +-- | p_get4d : Pointer to function : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h &THFloatTensor_get4d" + p_get4d :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CFloat) + +-- | p_desc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THFloatTensor_desc" + p_desc :: FunPtr (Ptr C'THFloatTensor -> IO (Ptr C'THDescBuff)) + +-- | p_sizeDesc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THFloatTensor_sizeDesc" + p_sizeDesc :: FunPtr (Ptr C'THFloatTensor -> IO (Ptr C'THDescBuff)) diff --git a/src/Torch/FFI/TH/Float/TensorConv.hs b/src/Torch/FFI/TH/Float/TensorConv.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/TensorConv.hs @@ -0,0 +1,272 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.TensorConv where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_validXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_validXCorr2Dptr" + c_validXCorr2Dptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2Dptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2Dptr = const c_validXCorr2Dptr_ + +-- | c_validConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_validConv2Dptr" + c_validConv2Dptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv2Dptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv2Dptr = const c_validConv2Dptr_ + +-- | c_fullXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_fullXCorr2Dptr" + c_fullXCorr2Dptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr2Dptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr2Dptr = const c_fullXCorr2Dptr_ + +-- | c_fullConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_fullConv2Dptr" + c_fullConv2Dptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv2Dptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv2Dptr = const c_fullConv2Dptr_ + +-- | c_validXCorr2DRevptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_validXCorr2DRevptr" + c_validXCorr2DRevptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2DRevptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2DRevptr = const c_validXCorr2DRevptr_ + +-- | c_conv2DRevger : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv2DRevger" + c_conv2DRevger_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevger :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> IO () +c_conv2DRevger = const c_conv2DRevger_ + +-- | c_conv2DRevgerm : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv2DRevgerm" + c_conv2DRevgerm_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevgerm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevgerm :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> IO () +c_conv2DRevgerm = const c_conv2DRevgerm_ + +-- | c_conv2Dger : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv2Dger" + c_conv2Dger_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dger :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dger = const c_conv2Dger_ + +-- | c_conv2Dmv : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv2Dmv" + c_conv2Dmv_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmv :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmv = const c_conv2Dmv_ + +-- | c_conv2Dmm : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv2Dmm" + c_conv2Dmm_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmm :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmm = const c_conv2Dmm_ + +-- | c_conv2Dmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv2Dmul" + c_conv2Dmul_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmul :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmul = const c_conv2Dmul_ + +-- | c_conv2Dcmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv2Dcmul" + c_conv2Dcmul_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dcmul :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dcmul = const c_conv2Dcmul_ + +-- | c_validXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_validXCorr3Dptr" + c_validXCorr3Dptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3Dptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3Dptr = const c_validXCorr3Dptr_ + +-- | c_validConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_validConv3Dptr" + c_validConv3Dptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv3Dptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv3Dptr = const c_validConv3Dptr_ + +-- | c_fullXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_fullXCorr3Dptr" + c_fullXCorr3Dptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr3Dptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr3Dptr = const c_fullXCorr3Dptr_ + +-- | c_fullConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_fullConv3Dptr" + c_fullConv3Dptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv3Dptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv3Dptr = const c_fullConv3Dptr_ + +-- | c_validXCorr3DRevptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THFloatTensor_validXCorr3DRevptr" + c_validXCorr3DRevptr_ :: Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3DRevptr :: Ptr C'THState -> Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3DRevptr = const c_validXCorr3DRevptr_ + +-- | c_conv3DRevger : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv3DRevger" + c_conv3DRevger_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_conv3DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3DRevger :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> IO () +c_conv3DRevger = const c_conv3DRevger_ + +-- | c_conv3Dger : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv3Dger" + c_conv3Dger_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dger :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dger = const c_conv3Dger_ + +-- | c_conv3Dmv : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv3Dmv" + c_conv3Dmv_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmv :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmv = const c_conv3Dmv_ + +-- | c_conv3Dmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv3Dmul" + c_conv3Dmul_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmul :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmul = const c_conv3Dmul_ + +-- | c_conv3Dcmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THFloatTensor_conv3Dcmul" + c_conv3Dcmul_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dcmul :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dcmul = const c_conv3Dcmul_ + +-- | p_validXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_validXCorr2Dptr" + p_validXCorr2Dptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_validConv2Dptr" + p_validConv2Dptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_fullXCorr2Dptr" + p_fullXCorr2Dptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_fullConv2Dptr" + p_fullConv2Dptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr2DRevptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_validXCorr2DRevptr" + p_validXCorr2DRevptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevger : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv2DRevger" + p_conv2DRevger :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevgerm : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv2DRevgerm" + p_conv2DRevgerm :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2Dger : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv2Dger" + p_conv2Dger :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmv : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv2Dmv" + p_conv2Dmv :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmm : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv2Dmm" + p_conv2Dmm :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv2Dmul" + p_conv2Dmul :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dcmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv2Dcmul" + p_conv2Dcmul :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_validXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_validXCorr3Dptr" + p_validXCorr3Dptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_validConv3Dptr" + p_validConv3Dptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_fullXCorr3Dptr" + p_fullXCorr3Dptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_fullConv3Dptr" + p_fullConv3Dptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr3DRevptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_validXCorr3DRevptr" + p_validXCorr3DRevptr :: FunPtr (Ptr CFloat -> CFloat -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> Ptr CFloat -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3DRevger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv3DRevger" + p_conv3DRevger :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3Dger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv3Dger" + p_conv3Dger :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmv : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv3Dmv" + p_conv3Dmv :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv3Dmul" + p_conv3Dmul :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dcmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THFloatTensor_conv3Dcmul" + p_conv3Dcmul :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) diff --git a/src/Torch/FFI/TH/Float/TensorCopy.hs b/src/Torch/FFI/TH/Float/TensorCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/TensorCopy.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.TensorCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_copy : tensor src -> void +foreign import ccall "THTensorCopy.h THFloatTensor_copy" + c_copy_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : tensor src -> void +foreign import ccall "THTensorCopy.h THFloatTensor_copyByte" + c_copyByte_ :: Ptr C'THFloatTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THByteTensor -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : tensor src -> void +foreign import ccall "THTensorCopy.h THFloatTensor_copyChar" + c_copyChar_ :: Ptr C'THFloatTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THCharTensor -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : tensor src -> void +foreign import ccall "THTensorCopy.h THFloatTensor_copyShort" + c_copyShort_ :: Ptr C'THFloatTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THShortTensor -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : tensor src -> void +foreign import ccall "THTensorCopy.h THFloatTensor_copyInt" + c_copyInt_ :: Ptr C'THFloatTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THIntTensor -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : tensor src -> void +foreign import ccall "THTensorCopy.h THFloatTensor_copyLong" + c_copyLong_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : tensor src -> void +foreign import ccall "THTensorCopy.h THFloatTensor_copyFloat" + c_copyFloat_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : tensor src -> void +foreign import ccall "THTensorCopy.h THFloatTensor_copyDouble" + c_copyDouble_ :: Ptr C'THFloatTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THDoubleTensor -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : tensor src -> void +foreign import ccall "THTensorCopy.h THFloatTensor_copyHalf" + c_copyHalf_ :: Ptr C'THFloatTensor -> Ptr C'THHalfTensor -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THHalfTensor -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_copy : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THFloatTensor_copy" + p_copy :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_copyByte : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THFloatTensor_copyByte" + p_copyByte :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_copyChar : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THFloatTensor_copyChar" + p_copyChar :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_copyShort : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THFloatTensor_copyShort" + p_copyShort :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_copyInt : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THFloatTensor_copyInt" + p_copyInt :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_copyLong : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THFloatTensor_copyLong" + p_copyLong :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_copyFloat : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THFloatTensor_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_copyDouble : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THFloatTensor_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_copyHalf : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THFloatTensor_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THHalfTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Float/TensorLapack.hs b/src/Torch/FFI/TH/Float/TensorLapack.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/TensorLapack.hs @@ -0,0 +1,224 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.TensorLapack where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_gesv : rb_ ra_ b_ a_ -> void +foreign import ccall "THTensorLapack.h THFloatTensor_gesv" + c_gesv_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_gesv_ with unused argument (for CTHState) to unify backpack signatures. +c_gesv :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_gesv = const c_gesv_ + +-- | c_trtrs : rb_ ra_ b_ a_ uplo trans diag -> void +foreign import ccall "THTensorLapack.h THFloatTensor_trtrs" + c_trtrs_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_trtrs_ with unused argument (for CTHState) to unify backpack signatures. +c_trtrs :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> Ptr CChar -> Ptr CChar -> IO () +c_trtrs = const c_trtrs_ + +-- | c_gels : rb_ ra_ b_ a_ -> void +foreign import ccall "THTensorLapack.h THFloatTensor_gels" + c_gels_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_gels_ with unused argument (for CTHState) to unify backpack signatures. +c_gels :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_gels = const c_gels_ + +-- | c_syev : re_ rv_ a_ jobz uplo -> void +foreign import ccall "THTensorLapack.h THFloatTensor_syev" + c_syev_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_syev_ with unused argument (for CTHState) to unify backpack signatures. +c_syev :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> Ptr CChar -> IO () +c_syev = const c_syev_ + +-- | c_geev : re_ rv_ a_ jobvr -> void +foreign import ccall "THTensorLapack.h THFloatTensor_geev" + c_geev_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () + +-- | alias of c_geev_ with unused argument (for CTHState) to unify backpack signatures. +c_geev :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () +c_geev = const c_geev_ + +-- | c_gesvd : ru_ rs_ rv_ a jobu -> void +foreign import ccall "THTensorLapack.h THFloatTensor_gesvd" + c_gesvd_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () + +-- | alias of c_gesvd_ with unused argument (for CTHState) to unify backpack signatures. +c_gesvd :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () +c_gesvd = const c_gesvd_ + +-- | c_gesvd2 : ru_ rs_ rv_ ra_ a jobu -> void +foreign import ccall "THTensorLapack.h THFloatTensor_gesvd2" + c_gesvd2_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () + +-- | alias of c_gesvd2_ with unused argument (for CTHState) to unify backpack signatures. +c_gesvd2 :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () +c_gesvd2 = const c_gesvd2_ + +-- | c_getri : ra_ a -> void +foreign import ccall "THTensorLapack.h THFloatTensor_getri" + c_getri_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_getri_ with unused argument (for CTHState) to unify backpack signatures. +c_getri :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_getri = const c_getri_ + +-- | c_potrf : ra_ a uplo -> void +foreign import ccall "THTensorLapack.h THFloatTensor_potrf" + c_potrf_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () + +-- | alias of c_potrf_ with unused argument (for CTHState) to unify backpack signatures. +c_potrf :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () +c_potrf = const c_potrf_ + +-- | c_potrs : rb_ b_ a_ uplo -> void +foreign import ccall "THTensorLapack.h THFloatTensor_potrs" + c_potrs_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () + +-- | alias of c_potrs_ with unused argument (for CTHState) to unify backpack signatures. +c_potrs :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () +c_potrs = const c_potrs_ + +-- | c_potri : ra_ a uplo -> void +foreign import ccall "THTensorLapack.h THFloatTensor_potri" + c_potri_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () + +-- | alias of c_potri_ with unused argument (for CTHState) to unify backpack signatures. +c_potri :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO () +c_potri = const c_potri_ + +-- | c_qr : rq_ rr_ a -> void +foreign import ccall "THTensorLapack.h THFloatTensor_qr" + c_qr_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_qr_ with unused argument (for CTHState) to unify backpack signatures. +c_qr :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_qr = const c_qr_ + +-- | c_geqrf : ra_ rtau_ a -> void +foreign import ccall "THTensorLapack.h THFloatTensor_geqrf" + c_geqrf_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_geqrf_ with unused argument (for CTHState) to unify backpack signatures. +c_geqrf :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_geqrf = const c_geqrf_ + +-- | c_orgqr : ra_ a tau -> void +foreign import ccall "THTensorLapack.h THFloatTensor_orgqr" + c_orgqr_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_orgqr_ with unused argument (for CTHState) to unify backpack signatures. +c_orgqr :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_orgqr = const c_orgqr_ + +-- | c_ormqr : ra_ a tau c side trans -> void +foreign import ccall "THTensorLapack.h THFloatTensor_ormqr" + c_ormqr_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_ormqr_ with unused argument (for CTHState) to unify backpack signatures. +c_ormqr :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> Ptr CChar -> IO () +c_ormqr = const c_ormqr_ + +-- | c_pstrf : ra_ rpiv_ a uplo tol -> void +foreign import ccall "THTensorLapack.h THFloatTensor_pstrf" + c_pstrf_ :: Ptr C'THFloatTensor -> Ptr C'THIntTensor -> Ptr C'THFloatTensor -> Ptr CChar -> CFloat -> IO () + +-- | alias of c_pstrf_ with unused argument (for CTHState) to unify backpack signatures. +c_pstrf :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THIntTensor -> Ptr C'THFloatTensor -> Ptr CChar -> CFloat -> IO () +c_pstrf = const c_pstrf_ + +-- | c_btrifact : ra_ rpivots_ rinfo_ pivot a -> void +foreign import ccall "THTensorLapack.h THFloatTensor_btrifact" + c_btrifact_ :: Ptr C'THFloatTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_btrifact_ with unused argument (for CTHState) to unify backpack signatures. +c_btrifact :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THFloatTensor -> IO () +c_btrifact = const c_btrifact_ + +-- | c_btrisolve : rb_ b atf pivots -> void +foreign import ccall "THTensorLapack.h THFloatTensor_btrisolve" + c_btrisolve_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_btrisolve_ with unused argument (for CTHState) to unify backpack signatures. +c_btrisolve :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIntTensor -> IO () +c_btrisolve = const c_btrisolve_ + +-- | p_gesv : Pointer to function : rb_ ra_ b_ a_ -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_gesv" + p_gesv :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_trtrs : Pointer to function : rb_ ra_ b_ a_ uplo trans diag -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_trtrs" + p_trtrs :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_gels : Pointer to function : rb_ ra_ b_ a_ -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_gels" + p_gels :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_syev : Pointer to function : re_ rv_ a_ jobz uplo -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_syev" + p_syev :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_geev : Pointer to function : re_ rv_ a_ jobvr -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_geev" + p_geev :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO ()) + +-- | p_gesvd : Pointer to function : ru_ rs_ rv_ a jobu -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_gesvd" + p_gesvd :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO ()) + +-- | p_gesvd2 : Pointer to function : ru_ rs_ rv_ ra_ a jobu -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_gesvd2" + p_gesvd2 :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO ()) + +-- | p_getri : Pointer to function : ra_ a -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_getri" + p_getri :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_potrf : Pointer to function : ra_ a uplo -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_potrf" + p_potrf :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO ()) + +-- | p_potrs : Pointer to function : rb_ b_ a_ uplo -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_potrs" + p_potrs :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO ()) + +-- | p_potri : Pointer to function : ra_ a uplo -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_potri" + p_potri :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> IO ()) + +-- | p_qr : Pointer to function : rq_ rr_ a -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_qr" + p_qr :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_geqrf : Pointer to function : ra_ rtau_ a -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_geqrf" + p_geqrf :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_orgqr : Pointer to function : ra_ a tau -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_orgqr" + p_orgqr :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_ormqr : Pointer to function : ra_ a tau c side trans -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_ormqr" + p_ormqr :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_pstrf : Pointer to function : ra_ rpiv_ a uplo tol -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_pstrf" + p_pstrf :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THIntTensor -> Ptr C'THFloatTensor -> Ptr CChar -> CFloat -> IO ()) + +-- | p_btrifact : Pointer to function : ra_ rpivots_ rinfo_ pivot a -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_btrifact" + p_btrifact :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THFloatTensor -> IO ()) + +-- | p_btrisolve : Pointer to function : rb_ b atf pivots -> void +foreign import ccall "THTensorLapack.h &THFloatTensor_btrisolve" + p_btrisolve :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THIntTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Float/TensorMath.hs b/src/Torch/FFI/TH/Float/TensorMath.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/TensorMath.hs @@ -0,0 +1,2000 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.TensorMath where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : r_ value -> void +foreign import ccall "THTensorMath.h THFloatTensor_fill" + c_fill_ :: Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> IO () +c_fill = const c_fill_ + +-- | c_zero : r_ -> void +foreign import ccall "THTensorMath.h THFloatTensor_zero" + c_zero_ :: Ptr C'THFloatTensor -> IO () + +-- | alias of c_zero_ with unused argument (for CTHState) to unify backpack signatures. +c_zero :: Ptr C'THState -> Ptr C'THFloatTensor -> IO () +c_zero = const c_zero_ + +-- | c_maskedFill : tensor mask value -> void +foreign import ccall "THTensorMath.h THFloatTensor_maskedFill" + c_maskedFill_ :: Ptr C'THFloatTensor -> Ptr C'THByteTensor -> CFloat -> IO () + +-- | alias of c_maskedFill_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedFill :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THByteTensor -> CFloat -> IO () +c_maskedFill = const c_maskedFill_ + +-- | c_maskedCopy : tensor mask src -> void +foreign import ccall "THTensorMath.h THFloatTensor_maskedCopy" + c_maskedCopy_ :: Ptr C'THFloatTensor -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_maskedCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedCopy :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> IO () +c_maskedCopy = const c_maskedCopy_ + +-- | c_maskedSelect : tensor src mask -> void +foreign import ccall "THTensorMath.h THFloatTensor_maskedSelect" + c_maskedSelect_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_maskedSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedSelect :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THByteTensor -> IO () +c_maskedSelect = const c_maskedSelect_ + +-- | c_nonzero : subscript tensor -> void +foreign import ccall "THTensorMath.h THFloatTensor_nonzero" + c_nonzero_ :: Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_nonzero_ with unused argument (for CTHState) to unify backpack signatures. +c_nonzero :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () +c_nonzero = const c_nonzero_ + +-- | c_indexSelect : tensor src dim index -> void +foreign import ccall "THTensorMath.h THFloatTensor_indexSelect" + c_indexSelect_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_indexSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_indexSelect :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_indexSelect = const c_indexSelect_ + +-- | c_indexCopy : tensor dim index src -> void +foreign import ccall "THTensorMath.h THFloatTensor_indexCopy" + c_indexCopy_ :: Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_indexCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_indexCopy :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () +c_indexCopy = const c_indexCopy_ + +-- | c_indexAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THFloatTensor_indexAdd" + c_indexAdd_ :: Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_indexAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_indexAdd :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () +c_indexAdd = const c_indexAdd_ + +-- | c_indexFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THFloatTensor_indexFill" + c_indexFill_ :: Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> CFloat -> IO () + +-- | alias of c_indexFill_ with unused argument (for CTHState) to unify backpack signatures. +c_indexFill :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> CFloat -> IO () +c_indexFill = const c_indexFill_ + +-- | c_take : tensor src index -> void +foreign import ccall "THTensorMath.h THFloatTensor_take" + c_take_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_take_ with unused argument (for CTHState) to unify backpack signatures. +c_take :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> IO () +c_take = const c_take_ + +-- | c_put : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h THFloatTensor_put" + c_put_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | alias of c_put_ with unused argument (for CTHState) to unify backpack signatures. +c_put :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> IO () +c_put = const c_put_ + +-- | c_gather : tensor src dim index -> void +foreign import ccall "THTensorMath.h THFloatTensor_gather" + c_gather_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_gather_ with unused argument (for CTHState) to unify backpack signatures. +c_gather :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_gather = const c_gather_ + +-- | c_scatter : tensor dim index src -> void +foreign import ccall "THTensorMath.h THFloatTensor_scatter" + c_scatter_ :: Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_scatter_ with unused argument (for CTHState) to unify backpack signatures. +c_scatter :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () +c_scatter = const c_scatter_ + +-- | c_scatterAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THFloatTensor_scatterAdd" + c_scatterAdd_ :: Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_scatterAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterAdd :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () +c_scatterAdd = const c_scatterAdd_ + +-- | c_scatterFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THFloatTensor_scatterFill" + c_scatterFill_ :: Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> CFloat -> IO () + +-- | alias of c_scatterFill_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterFill :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> CFloat -> IO () +c_scatterFill = const c_scatterFill_ + +-- | c_dot : t src -> accreal +foreign import ccall "THTensorMath.h THFloatTensor_dot" + c_dot_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CDouble + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CDouble +c_dot = const c_dot_ + +-- | c_minall : t -> real +foreign import ccall "THTensorMath.h THFloatTensor_minall" + c_minall_ :: Ptr C'THFloatTensor -> IO CFloat + +-- | alias of c_minall_ with unused argument (for CTHState) to unify backpack signatures. +c_minall :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CFloat +c_minall = const c_minall_ + +-- | c_maxall : t -> real +foreign import ccall "THTensorMath.h THFloatTensor_maxall" + c_maxall_ :: Ptr C'THFloatTensor -> IO CFloat + +-- | alias of c_maxall_ with unused argument (for CTHState) to unify backpack signatures. +c_maxall :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CFloat +c_maxall = const c_maxall_ + +-- | c_medianall : t -> real +foreign import ccall "THTensorMath.h THFloatTensor_medianall" + c_medianall_ :: Ptr C'THFloatTensor -> IO CFloat + +-- | alias of c_medianall_ with unused argument (for CTHState) to unify backpack signatures. +c_medianall :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CFloat +c_medianall = const c_medianall_ + +-- | c_sumall : t -> accreal +foreign import ccall "THTensorMath.h THFloatTensor_sumall" + c_sumall_ :: Ptr C'THFloatTensor -> IO CDouble + +-- | alias of c_sumall_ with unused argument (for CTHState) to unify backpack signatures. +c_sumall :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CDouble +c_sumall = const c_sumall_ + +-- | c_prodall : t -> accreal +foreign import ccall "THTensorMath.h THFloatTensor_prodall" + c_prodall_ :: Ptr C'THFloatTensor -> IO CDouble + +-- | alias of c_prodall_ with unused argument (for CTHState) to unify backpack signatures. +c_prodall :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CDouble +c_prodall = const c_prodall_ + +-- | c_neg : self src -> void +foreign import ccall "THTensorMath.h THFloatTensor_neg" + c_neg_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_neg = const c_neg_ + +-- | c_cinv : self src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cinv" + c_cinv_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cinv_ with unused argument (for CTHState) to unify backpack signatures. +c_cinv :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cinv = const c_cinv_ + +-- | c_add : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_add" + c_add_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_add_ with unused argument (for CTHState) to unify backpack signatures. +c_add :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_add = const c_add_ + +-- | c_sub : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_sub" + c_sub_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_sub_ with unused argument (for CTHState) to unify backpack signatures. +c_sub :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_sub = const c_sub_ + +-- | c_add_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THFloatTensor_add_scaled" + c_add_scaled_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CFloat -> IO () + +-- | alias of c_add_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_add_scaled :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CFloat -> IO () +c_add_scaled = const c_add_scaled_ + +-- | c_sub_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THFloatTensor_sub_scaled" + c_sub_scaled_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CFloat -> IO () + +-- | alias of c_sub_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_sub_scaled :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CFloat -> IO () +c_sub_scaled = const c_sub_scaled_ + +-- | c_mul : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_mul" + c_mul_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_mul_ with unused argument (for CTHState) to unify backpack signatures. +c_mul :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_mul = const c_mul_ + +-- | c_div : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_div" + c_div_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_div_ with unused argument (for CTHState) to unify backpack signatures. +c_div :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_div = const c_div_ + +-- | c_lshift : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_lshift" + c_lshift_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_lshift_ with unused argument (for CTHState) to unify backpack signatures. +c_lshift :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_lshift = const c_lshift_ + +-- | c_rshift : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_rshift" + c_rshift_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_rshift_ with unused argument (for CTHState) to unify backpack signatures. +c_rshift :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_rshift = const c_rshift_ + +-- | c_fmod : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_fmod" + c_fmod_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_fmod_ with unused argument (for CTHState) to unify backpack signatures. +c_fmod :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_fmod = const c_fmod_ + +-- | c_remainder : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_remainder" + c_remainder_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_remainder_ with unused argument (for CTHState) to unify backpack signatures. +c_remainder :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_remainder = const c_remainder_ + +-- | c_clamp : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h THFloatTensor_clamp" + c_clamp_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CFloat -> IO () + +-- | alias of c_clamp_ with unused argument (for CTHState) to unify backpack signatures. +c_clamp :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CFloat -> IO () +c_clamp = const c_clamp_ + +-- | c_bitand : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_bitand" + c_bitand_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_bitand_ with unused argument (for CTHState) to unify backpack signatures. +c_bitand :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_bitand = const c_bitand_ + +-- | c_bitor : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_bitor" + c_bitor_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_bitor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitor :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_bitor = const c_bitor_ + +-- | c_bitxor : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_bitxor" + c_bitxor_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_bitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitxor :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_bitxor = const c_bitxor_ + +-- | c_cadd : r_ t value src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cadd" + c_cadd_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> IO () +c_cadd = const c_cadd_ + +-- | c_csub : self src1 value src2 -> void +foreign import ccall "THTensorMath.h THFloatTensor_csub" + c_csub_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_csub_ with unused argument (for CTHState) to unify backpack signatures. +c_csub :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> IO () +c_csub = const c_csub_ + +-- | c_cmul : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cmul" + c_cmul_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cmul = const c_cmul_ + +-- | c_cpow : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cpow" + c_cpow_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cpow_ with unused argument (for CTHState) to unify backpack signatures. +c_cpow :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cpow = const c_cpow_ + +-- | c_cdiv : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cdiv" + c_cdiv_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cdiv = const c_cdiv_ + +-- | c_clshift : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_clshift" + c_clshift_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_clshift_ with unused argument (for CTHState) to unify backpack signatures. +c_clshift :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_clshift = const c_clshift_ + +-- | c_crshift : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_crshift" + c_crshift_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_crshift_ with unused argument (for CTHState) to unify backpack signatures. +c_crshift :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_crshift = const c_crshift_ + +-- | c_cfmod : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cfmod" + c_cfmod_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cfmod_ with unused argument (for CTHState) to unify backpack signatures. +c_cfmod :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cfmod = const c_cfmod_ + +-- | c_cremainder : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cremainder" + c_cremainder_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cremainder_ with unused argument (for CTHState) to unify backpack signatures. +c_cremainder :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cremainder = const c_cremainder_ + +-- | c_cbitand : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cbitand" + c_cbitand_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cbitand_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitand :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cbitand = const c_cbitand_ + +-- | c_cbitor : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cbitor" + c_cbitor_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cbitor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitor :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cbitor = const c_cbitor_ + +-- | c_cbitxor : r_ t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cbitxor" + c_cbitxor_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cbitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitxor :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cbitxor = const c_cbitxor_ + +-- | c_addcmul : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THFloatTensor_addcmul" + c_addcmul_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_addcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_addcmul :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_addcmul = const c_addcmul_ + +-- | c_addcdiv : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THFloatTensor_addcdiv" + c_addcdiv_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_addcdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_addcdiv :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_addcdiv = const c_addcdiv_ + +-- | c_addmv : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h THFloatTensor_addmv" + c_addmv_ :: Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_addmv_ with unused argument (for CTHState) to unify backpack signatures. +c_addmv :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_addmv = const c_addmv_ + +-- | c_addmm : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h THFloatTensor_addmm" + c_addmm_ :: Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_addmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addmm :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_addmm = const c_addmm_ + +-- | c_addr : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h THFloatTensor_addr" + c_addr_ :: Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_addr_ with unused argument (for CTHState) to unify backpack signatures. +c_addr :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_addr = const c_addr_ + +-- | c_addbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THFloatTensor_addbmm" + c_addbmm_ :: Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_addbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addbmm :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_addbmm = const c_addbmm_ + +-- | c_baddbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THFloatTensor_baddbmm" + c_baddbmm_ :: Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_baddbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_baddbmm :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_baddbmm = const c_baddbmm_ + +-- | c_match : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h THFloatTensor_match" + c_match_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_match_ with unused argument (for CTHState) to unify backpack signatures. +c_match :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_match = const c_match_ + +-- | c_numel : t -> ptrdiff_t +foreign import ccall "THTensorMath.h THFloatTensor_numel" + c_numel_ :: Ptr C'THFloatTensor -> IO CPtrdiff + +-- | alias of c_numel_ with unused argument (for CTHState) to unify backpack signatures. +c_numel :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CPtrdiff +c_numel = const c_numel_ + +-- | c_preserveReduceDimSemantics : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_preserveReduceDimSemantics" + c_preserveReduceDimSemantics_ :: Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_preserveReduceDimSemantics_ with unused argument (for CTHState) to unify backpack signatures. +c_preserveReduceDimSemantics :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO () +c_preserveReduceDimSemantics = const c_preserveReduceDimSemantics_ + +-- | c_max : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_max" + c_max_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_max_ with unused argument (for CTHState) to unify backpack signatures. +c_max :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_max = const c_max_ + +-- | c_min : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_min" + c_min_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_min_ with unused argument (for CTHState) to unify backpack signatures. +c_min :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_min = const c_min_ + +-- | c_kthvalue : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_kthvalue" + c_kthvalue_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CLLong -> CInt -> CInt -> IO () + +-- | alias of c_kthvalue_ with unused argument (for CTHState) to unify backpack signatures. +c_kthvalue :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CLLong -> CInt -> CInt -> IO () +c_kthvalue = const c_kthvalue_ + +-- | c_mode : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_mode" + c_mode_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_mode_ with unused argument (for CTHState) to unify backpack signatures. +c_mode :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_mode = const c_mode_ + +-- | c_median : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_median" + c_median_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_median_ with unused argument (for CTHState) to unify backpack signatures. +c_median :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_median = const c_median_ + +-- | c_sum : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_sum" + c_sum_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_sum_ with unused argument (for CTHState) to unify backpack signatures. +c_sum :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_sum = const c_sum_ + +-- | c_prod : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_prod" + c_prod_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_prod_ with unused argument (for CTHState) to unify backpack signatures. +c_prod :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_prod = const c_prod_ + +-- | c_cumsum : r_ t dimension -> void +foreign import ccall "THTensorMath.h THFloatTensor_cumsum" + c_cumsum_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | alias of c_cumsum_ with unused argument (for CTHState) to unify backpack signatures. +c_cumsum :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () +c_cumsum = const c_cumsum_ + +-- | c_cumprod : r_ t dimension -> void +foreign import ccall "THTensorMath.h THFloatTensor_cumprod" + c_cumprod_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | alias of c_cumprod_ with unused argument (for CTHState) to unify backpack signatures. +c_cumprod :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () +c_cumprod = const c_cumprod_ + +-- | c_sign : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_sign" + c_sign_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_sign_ with unused argument (for CTHState) to unify backpack signatures. +c_sign :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_sign = const c_sign_ + +-- | c_trace : t -> accreal +foreign import ccall "THTensorMath.h THFloatTensor_trace" + c_trace_ :: Ptr C'THFloatTensor -> IO CDouble + +-- | alias of c_trace_ with unused argument (for CTHState) to unify backpack signatures. +c_trace :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CDouble +c_trace = const c_trace_ + +-- | c_cross : r_ a b dimension -> void +foreign import ccall "THTensorMath.h THFloatTensor_cross" + c_cross_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | alias of c_cross_ with unused argument (for CTHState) to unify backpack signatures. +c_cross :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () +c_cross = const c_cross_ + +-- | c_cmax : r t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cmax" + c_cmax_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cmax_ with unused argument (for CTHState) to unify backpack signatures. +c_cmax :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cmax = const c_cmax_ + +-- | c_cmin : r t src -> void +foreign import ccall "THTensorMath.h THFloatTensor_cmin" + c_cmin_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cmin_ with unused argument (for CTHState) to unify backpack signatures. +c_cmin :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cmin = const c_cmin_ + +-- | c_cmaxValue : r t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_cmaxValue" + c_cmaxValue_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_cmaxValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cmaxValue :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_cmaxValue = const c_cmaxValue_ + +-- | c_cminValue : r t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_cminValue" + c_cminValue_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_cminValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cminValue :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_cminValue = const c_cminValue_ + +-- | c_zeros : r_ size -> void +foreign import ccall "THTensorMath.h THFloatTensor_zeros" + c_zeros_ :: Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_zeros_ with unused argument (for CTHState) to unify backpack signatures. +c_zeros :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO () +c_zeros = const c_zeros_ + +-- | c_zerosLike : r_ input -> void +foreign import ccall "THTensorMath.h THFloatTensor_zerosLike" + c_zerosLike_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_zerosLike_ with unused argument (for CTHState) to unify backpack signatures. +c_zerosLike :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_zerosLike = const c_zerosLike_ + +-- | c_ones : r_ size -> void +foreign import ccall "THTensorMath.h THFloatTensor_ones" + c_ones_ :: Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_ones_ with unused argument (for CTHState) to unify backpack signatures. +c_ones :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO () +c_ones = const c_ones_ + +-- | c_onesLike : r_ input -> void +foreign import ccall "THTensorMath.h THFloatTensor_onesLike" + c_onesLike_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_onesLike_ with unused argument (for CTHState) to unify backpack signatures. +c_onesLike :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_onesLike = const c_onesLike_ + +-- | c_diag : r_ t k -> void +foreign import ccall "THTensorMath.h THFloatTensor_diag" + c_diag_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | alias of c_diag_ with unused argument (for CTHState) to unify backpack signatures. +c_diag :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () +c_diag = const c_diag_ + +-- | c_eye : r_ n m -> void +foreign import ccall "THTensorMath.h THFloatTensor_eye" + c_eye_ :: Ptr C'THFloatTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_eye_ with unused argument (for CTHState) to unify backpack signatures. +c_eye :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> CLLong -> IO () +c_eye = const c_eye_ + +-- | c_arange : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THFloatTensor_arange" + c_arange_ :: Ptr C'THFloatTensor -> CDouble -> CDouble -> CDouble -> IO () + +-- | alias of c_arange_ with unused argument (for CTHState) to unify backpack signatures. +c_arange :: Ptr C'THState -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CDouble -> IO () +c_arange = const c_arange_ + +-- | c_range : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THFloatTensor_range" + c_range_ :: Ptr C'THFloatTensor -> CDouble -> CDouble -> CDouble -> IO () + +-- | alias of c_range_ with unused argument (for CTHState) to unify backpack signatures. +c_range :: Ptr C'THState -> Ptr C'THFloatTensor -> CDouble -> CDouble -> CDouble -> IO () +c_range = const c_range_ + +-- | c_randperm : r_ _generator n -> void +foreign import ccall "THTensorMath.h THFloatTensor_randperm" + c_randperm_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_randperm_ with unused argument (for CTHState) to unify backpack signatures. +c_randperm :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_randperm = const c_randperm_ + +-- | c_reshape : r_ t size -> void +foreign import ccall "THTensorMath.h THFloatTensor_reshape" + c_reshape_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_reshape_ with unused argument (for CTHState) to unify backpack signatures. +c_reshape :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO () +c_reshape = const c_reshape_ + +-- | c_sort : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h THFloatTensor_sort" + c_sort_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_sort_ with unused argument (for CTHState) to unify backpack signatures. +c_sort :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_sort = const c_sort_ + +-- | c_topk : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h THFloatTensor_topk" + c_topk_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CLLong -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_topk_ with unused argument (for CTHState) to unify backpack signatures. +c_topk :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CLLong -> CInt -> CInt -> CInt -> IO () +c_topk = const c_topk_ + +-- | c_tril : r_ t k -> void +foreign import ccall "THTensorMath.h THFloatTensor_tril" + c_tril_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO () + +-- | alias of c_tril_ with unused argument (for CTHState) to unify backpack signatures. +c_tril :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO () +c_tril = const c_tril_ + +-- | c_triu : r_ t k -> void +foreign import ccall "THTensorMath.h THFloatTensor_triu" + c_triu_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO () + +-- | alias of c_triu_ with unused argument (for CTHState) to unify backpack signatures. +c_triu :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO () +c_triu = const c_triu_ + +-- | c_cat : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h THFloatTensor_cat" + c_cat_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () + +-- | alias of c_cat_ with unused argument (for CTHState) to unify backpack signatures. +c_cat :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO () +c_cat = const c_cat_ + +-- | c_catArray : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h THFloatTensor_catArray" + c_catArray_ :: Ptr C'THFloatTensor -> Ptr (Ptr C'THFloatTensor) -> CInt -> CInt -> IO () + +-- | alias of c_catArray_ with unused argument (for CTHState) to unify backpack signatures. +c_catArray :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr (Ptr C'THFloatTensor) -> CInt -> CInt -> IO () +c_catArray = const c_catArray_ + +-- | c_equal : ta tb -> int +foreign import ccall "THTensorMath.h THFloatTensor_equal" + c_equal_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CInt + +-- | alias of c_equal_ with unused argument (for CTHState) to unify backpack signatures. +c_equal :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CInt +c_equal = const c_equal_ + +-- | c_ltValue : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_ltValue" + c_ltValue_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_ltValue_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_ltValue = const c_ltValue_ + +-- | c_leValue : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_leValue" + c_leValue_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_leValue_ with unused argument (for CTHState) to unify backpack signatures. +c_leValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_leValue = const c_leValue_ + +-- | c_gtValue : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_gtValue" + c_gtValue_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_gtValue_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_gtValue = const c_gtValue_ + +-- | c_geValue : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_geValue" + c_geValue_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_geValue_ with unused argument (for CTHState) to unify backpack signatures. +c_geValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_geValue = const c_geValue_ + +-- | c_neValue : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_neValue" + c_neValue_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_neValue_ with unused argument (for CTHState) to unify backpack signatures. +c_neValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_neValue = const c_neValue_ + +-- | c_eqValue : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_eqValue" + c_eqValue_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_eqValue_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_eqValue = const c_eqValue_ + +-- | c_ltValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_ltValueT" + c_ltValueT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_ltValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValueT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_ltValueT = const c_ltValueT_ + +-- | c_leValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_leValueT" + c_leValueT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_leValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_leValueT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_leValueT = const c_leValueT_ + +-- | c_gtValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_gtValueT" + c_gtValueT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_gtValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValueT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_gtValueT = const c_gtValueT_ + +-- | c_geValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_geValueT" + c_geValueT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_geValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_geValueT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_geValueT = const c_geValueT_ + +-- | c_neValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_neValueT" + c_neValueT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_neValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_neValueT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_neValueT = const c_neValueT_ + +-- | c_eqValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_eqValueT" + c_eqValueT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_eqValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValueT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_eqValueT = const c_eqValueT_ + +-- | c_ltTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_ltTensor" + c_ltTensor_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_ltTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_ltTensor = const c_ltTensor_ + +-- | c_leTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_leTensor" + c_leTensor_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_leTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_leTensor = const c_leTensor_ + +-- | c_gtTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_gtTensor" + c_gtTensor_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_gtTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_gtTensor = const c_gtTensor_ + +-- | c_geTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_geTensor" + c_geTensor_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_geTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_geTensor = const c_geTensor_ + +-- | c_neTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_neTensor" + c_neTensor_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_neTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_neTensor = const c_neTensor_ + +-- | c_eqTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_eqTensor" + c_eqTensor_ :: Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_eqTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_eqTensor = const c_eqTensor_ + +-- | c_ltTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_ltTensorT" + c_ltTensorT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_ltTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensorT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_ltTensorT = const c_ltTensorT_ + +-- | c_leTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_leTensorT" + c_leTensorT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_leTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensorT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_leTensorT = const c_leTensorT_ + +-- | c_gtTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_gtTensorT" + c_gtTensorT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_gtTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensorT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_gtTensorT = const c_gtTensorT_ + +-- | c_geTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_geTensorT" + c_geTensorT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_geTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensorT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_geTensorT = const c_geTensorT_ + +-- | c_neTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_neTensorT" + c_neTensorT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_neTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensorT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_neTensorT = const c_neTensorT_ + +-- | c_eqTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THFloatTensor_eqTensorT" + c_eqTensorT_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_eqTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensorT :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_eqTensorT = const c_eqTensorT_ + +-- | c_abs : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_abs" + c_abs_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_abs = const c_abs_ + +-- | c_sigmoid : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_sigmoid" + c_sigmoid_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_sigmoid_ with unused argument (for CTHState) to unify backpack signatures. +c_sigmoid :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_sigmoid = const c_sigmoid_ + +-- | c_log : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_log" + c_log_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_log_ with unused argument (for CTHState) to unify backpack signatures. +c_log :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_log = const c_log_ + +-- | c_lgamma : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_lgamma" + c_lgamma_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_lgamma_ with unused argument (for CTHState) to unify backpack signatures. +c_lgamma :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_lgamma = const c_lgamma_ + +-- | c_digamma : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_digamma" + c_digamma_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_digamma_ with unused argument (for CTHState) to unify backpack signatures. +c_digamma :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_digamma = const c_digamma_ + +-- | c_trigamma : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_trigamma" + c_trigamma_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_trigamma_ with unused argument (for CTHState) to unify backpack signatures. +c_trigamma :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_trigamma = const c_trigamma_ + +-- | c_polygamma : r_ n t -> void +foreign import ccall "THTensorMath.h THFloatTensor_polygamma" + c_polygamma_ :: Ptr C'THFloatTensor -> CLLong -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_polygamma_ with unused argument (for CTHState) to unify backpack signatures. +c_polygamma :: Ptr C'THState -> Ptr C'THFloatTensor -> CLLong -> Ptr C'THFloatTensor -> IO () +c_polygamma = const c_polygamma_ + +-- | c_log1p : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_log1p" + c_log1p_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_log1p_ with unused argument (for CTHState) to unify backpack signatures. +c_log1p :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_log1p = const c_log1p_ + +-- | c_exp : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_exp" + c_exp_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_exp_ with unused argument (for CTHState) to unify backpack signatures. +c_exp :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_exp = const c_exp_ + +-- | c_expm1 : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_expm1" + c_expm1_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_expm1_ with unused argument (for CTHState) to unify backpack signatures. +c_expm1 :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_expm1 = const c_expm1_ + +-- | c_cos : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_cos" + c_cos_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cos_ with unused argument (for CTHState) to unify backpack signatures. +c_cos :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cos = const c_cos_ + +-- | c_acos : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_acos" + c_acos_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_acos_ with unused argument (for CTHState) to unify backpack signatures. +c_acos :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_acos = const c_acos_ + +-- | c_cosh : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_cosh" + c_cosh_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_cosh_ with unused argument (for CTHState) to unify backpack signatures. +c_cosh :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_cosh = const c_cosh_ + +-- | c_sin : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_sin" + c_sin_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_sin_ with unused argument (for CTHState) to unify backpack signatures. +c_sin :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_sin = const c_sin_ + +-- | c_asin : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_asin" + c_asin_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_asin_ with unused argument (for CTHState) to unify backpack signatures. +c_asin :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_asin = const c_asin_ + +-- | c_sinh : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_sinh" + c_sinh_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_sinh_ with unused argument (for CTHState) to unify backpack signatures. +c_sinh :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_sinh = const c_sinh_ + +-- | c_tan : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_tan" + c_tan_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_tan_ with unused argument (for CTHState) to unify backpack signatures. +c_tan :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_tan = const c_tan_ + +-- | c_atan : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_atan" + c_atan_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_atan_ with unused argument (for CTHState) to unify backpack signatures. +c_atan :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_atan = const c_atan_ + +-- | c_atan2 : r_ tx ty -> void +foreign import ccall "THTensorMath.h THFloatTensor_atan2" + c_atan2_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_atan2_ with unused argument (for CTHState) to unify backpack signatures. +c_atan2 :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_atan2 = const c_atan2_ + +-- | c_tanh : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_tanh" + c_tanh_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_tanh_ with unused argument (for CTHState) to unify backpack signatures. +c_tanh :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_tanh = const c_tanh_ + +-- | c_erf : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_erf" + c_erf_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_erf_ with unused argument (for CTHState) to unify backpack signatures. +c_erf :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_erf = const c_erf_ + +-- | c_erfinv : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_erfinv" + c_erfinv_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_erfinv_ with unused argument (for CTHState) to unify backpack signatures. +c_erfinv :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_erfinv = const c_erfinv_ + +-- | c_pow : r_ t value -> void +foreign import ccall "THTensorMath.h THFloatTensor_pow" + c_pow_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_pow_ with unused argument (for CTHState) to unify backpack signatures. +c_pow :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_pow = const c_pow_ + +-- | c_tpow : r_ value t -> void +foreign import ccall "THTensorMath.h THFloatTensor_tpow" + c_tpow_ :: Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_tpow_ with unused argument (for CTHState) to unify backpack signatures. +c_tpow :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> IO () +c_tpow = const c_tpow_ + +-- | c_sqrt : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_sqrt" + c_sqrt_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_sqrt_ with unused argument (for CTHState) to unify backpack signatures. +c_sqrt :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_sqrt = const c_sqrt_ + +-- | c_rsqrt : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_rsqrt" + c_rsqrt_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_rsqrt_ with unused argument (for CTHState) to unify backpack signatures. +c_rsqrt :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_rsqrt = const c_rsqrt_ + +-- | c_ceil : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_ceil" + c_ceil_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_ceil_ with unused argument (for CTHState) to unify backpack signatures. +c_ceil :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_ceil = const c_ceil_ + +-- | c_floor : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_floor" + c_floor_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_floor_ with unused argument (for CTHState) to unify backpack signatures. +c_floor :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_floor = const c_floor_ + +-- | c_round : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_round" + c_round_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_round_ with unused argument (for CTHState) to unify backpack signatures. +c_round :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_round = const c_round_ + +-- | c_trunc : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_trunc" + c_trunc_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_trunc_ with unused argument (for CTHState) to unify backpack signatures. +c_trunc :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_trunc = const c_trunc_ + +-- | c_frac : r_ t -> void +foreign import ccall "THTensorMath.h THFloatTensor_frac" + c_frac_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_frac_ with unused argument (for CTHState) to unify backpack signatures. +c_frac :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_frac = const c_frac_ + +-- | c_lerp : r_ a b weight -> void +foreign import ccall "THTensorMath.h THFloatTensor_lerp" + c_lerp_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () + +-- | alias of c_lerp_ with unused argument (for CTHState) to unify backpack signatures. +c_lerp :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO () +c_lerp = const c_lerp_ + +-- | c_mean : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_mean" + c_mean_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_mean_ with unused argument (for CTHState) to unify backpack signatures. +c_mean :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_mean = const c_mean_ + +-- | c_std : r_ t dimension biased keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_std" + c_std_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_std_ with unused argument (for CTHState) to unify backpack signatures. +c_std :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO () +c_std = const c_std_ + +-- | c_var : r_ t dimension biased keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_var" + c_var_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_var_ with unused argument (for CTHState) to unify backpack signatures. +c_var :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO () +c_var = const c_var_ + +-- | c_norm : r_ t value dimension keepdim -> void +foreign import ccall "THTensorMath.h THFloatTensor_norm" + c_norm_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CInt -> CInt -> IO () + +-- | alias of c_norm_ with unused argument (for CTHState) to unify backpack signatures. +c_norm :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CInt -> CInt -> IO () +c_norm = const c_norm_ + +-- | c_renorm : r_ t value dimension maxnorm -> void +foreign import ccall "THTensorMath.h THFloatTensor_renorm" + c_renorm_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CInt -> CFloat -> IO () + +-- | alias of c_renorm_ with unused argument (for CTHState) to unify backpack signatures. +c_renorm :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CInt -> CFloat -> IO () +c_renorm = const c_renorm_ + +-- | c_dist : a b value -> accreal +foreign import ccall "THTensorMath.h THFloatTensor_dist" + c_dist_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO CDouble + +-- | alias of c_dist_ with unused argument (for CTHState) to unify backpack signatures. +c_dist :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO CDouble +c_dist = const c_dist_ + +-- | c_histc : hist tensor nbins minvalue maxvalue -> void +foreign import ccall "THTensorMath.h THFloatTensor_histc" + c_histc_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CFloat -> CFloat -> IO () + +-- | alias of c_histc_ with unused argument (for CTHState) to unify backpack signatures. +c_histc :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CFloat -> CFloat -> IO () +c_histc = const c_histc_ + +-- | c_bhistc : hist tensor nbins minvalue maxvalue -> void +foreign import ccall "THTensorMath.h THFloatTensor_bhistc" + c_bhistc_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CFloat -> CFloat -> IO () + +-- | alias of c_bhistc_ with unused argument (for CTHState) to unify backpack signatures. +c_bhistc :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CFloat -> CFloat -> IO () +c_bhistc = const c_bhistc_ + +-- | c_meanall : self -> accreal +foreign import ccall "THTensorMath.h THFloatTensor_meanall" + c_meanall_ :: Ptr C'THFloatTensor -> IO CDouble + +-- | alias of c_meanall_ with unused argument (for CTHState) to unify backpack signatures. +c_meanall :: Ptr C'THState -> Ptr C'THFloatTensor -> IO CDouble +c_meanall = const c_meanall_ + +-- | c_varall : self biased -> accreal +foreign import ccall "THTensorMath.h THFloatTensor_varall" + c_varall_ :: Ptr C'THFloatTensor -> CInt -> IO CDouble + +-- | alias of c_varall_ with unused argument (for CTHState) to unify backpack signatures. +c_varall :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> IO CDouble +c_varall = const c_varall_ + +-- | c_stdall : self biased -> accreal +foreign import ccall "THTensorMath.h THFloatTensor_stdall" + c_stdall_ :: Ptr C'THFloatTensor -> CInt -> IO CDouble + +-- | alias of c_stdall_ with unused argument (for CTHState) to unify backpack signatures. +c_stdall :: Ptr C'THState -> Ptr C'THFloatTensor -> CInt -> IO CDouble +c_stdall = const c_stdall_ + +-- | c_normall : t value -> accreal +foreign import ccall "THTensorMath.h THFloatTensor_normall" + c_normall_ :: Ptr C'THFloatTensor -> CFloat -> IO CDouble + +-- | alias of c_normall_ with unused argument (for CTHState) to unify backpack signatures. +c_normall :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> IO CDouble +c_normall = const c_normall_ + +-- | c_linspace : r_ a b n -> void +foreign import ccall "THTensorMath.h THFloatTensor_linspace" + c_linspace_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> CLLong -> IO () + +-- | alias of c_linspace_ with unused argument (for CTHState) to unify backpack signatures. +c_linspace :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> CLLong -> IO () +c_linspace = const c_linspace_ + +-- | c_logspace : r_ a b n -> void +foreign import ccall "THTensorMath.h THFloatTensor_logspace" + c_logspace_ :: Ptr C'THFloatTensor -> CFloat -> CFloat -> CLLong -> IO () + +-- | alias of c_logspace_ with unused argument (for CTHState) to unify backpack signatures. +c_logspace :: Ptr C'THState -> Ptr C'THFloatTensor -> CFloat -> CFloat -> CLLong -> IO () +c_logspace = const c_logspace_ + +-- | c_rand : r_ _generator size -> void +foreign import ccall "THTensorMath.h THFloatTensor_rand" + c_rand_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO () + +-- | alias of c_rand_ with unused argument (for CTHState) to unify backpack signatures. +c_rand :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO () +c_rand = const c_rand_ + +-- | c_randn : r_ _generator size -> void +foreign import ccall "THTensorMath.h THFloatTensor_randn" + c_randn_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO () + +-- | alias of c_randn_ with unused argument (for CTHState) to unify backpack signatures. +c_randn :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO () +c_randn = const c_randn_ + +-- | c_dirichlet_grad : self x alpha total -> void +foreign import ccall "THTensorMath.h THFloatTensor_dirichlet_grad" + c_dirichlet_grad_ :: Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_dirichlet_grad_ with unused argument (for CTHState) to unify backpack signatures. +c_dirichlet_grad :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_dirichlet_grad = const c_dirichlet_grad_ + +-- | p_fill : Pointer to function : r_ value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_fill" + p_fill :: FunPtr (Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_zero : Pointer to function : r_ -> void +foreign import ccall "THTensorMath.h &THFloatTensor_zero" + p_zero :: FunPtr (Ptr C'THFloatTensor -> IO ()) + +-- | p_maskedFill : Pointer to function : tensor mask value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_maskedFill" + p_maskedFill :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THByteTensor -> CFloat -> IO ()) + +-- | p_maskedCopy : Pointer to function : tensor mask src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_maskedCopy" + p_maskedCopy :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THByteTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_maskedSelect : Pointer to function : tensor src mask -> void +foreign import ccall "THTensorMath.h &THFloatTensor_maskedSelect" + p_maskedSelect :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_nonzero : Pointer to function : subscript tensor -> void +foreign import ccall "THTensorMath.h &THFloatTensor_nonzero" + p_nonzero :: FunPtr (Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_indexSelect : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THFloatTensor_indexSelect" + p_indexSelect :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexCopy : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_indexCopy" + p_indexCopy :: FunPtr (Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_indexAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_indexAdd" + p_indexAdd :: FunPtr (Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_indexFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THFloatTensor_indexFill" + p_indexFill :: FunPtr (Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> CFloat -> IO ()) + +-- | p_take : Pointer to function : tensor src index -> void +foreign import ccall "THTensorMath.h &THFloatTensor_take" + p_take :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_put : Pointer to function : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h &THFloatTensor_put" + p_put :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_gather : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THFloatTensor_gather" + p_gather :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_scatter : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_scatter" + p_scatter :: FunPtr (Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_scatterAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_scatterAdd" + p_scatterAdd :: FunPtr (Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_scatterFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THFloatTensor_scatterFill" + p_scatterFill :: FunPtr (Ptr C'THFloatTensor -> CInt -> Ptr C'THLongTensor -> CFloat -> IO ()) + +-- | p_dot : Pointer to function : t src -> accreal +foreign import ccall "THTensorMath.h &THFloatTensor_dot" + p_dot :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CDouble) + +-- | p_minall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THFloatTensor_minall" + p_minall :: FunPtr (Ptr C'THFloatTensor -> IO CFloat) + +-- | p_maxall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THFloatTensor_maxall" + p_maxall :: FunPtr (Ptr C'THFloatTensor -> IO CFloat) + +-- | p_medianall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THFloatTensor_medianall" + p_medianall :: FunPtr (Ptr C'THFloatTensor -> IO CFloat) + +-- | p_sumall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THFloatTensor_sumall" + p_sumall :: FunPtr (Ptr C'THFloatTensor -> IO CDouble) + +-- | p_prodall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THFloatTensor_prodall" + p_prodall :: FunPtr (Ptr C'THFloatTensor -> IO CDouble) + +-- | p_neg : Pointer to function : self src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_neg" + p_neg :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cinv : Pointer to function : self src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cinv" + p_cinv :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_add : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_add" + p_add :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_sub : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_sub" + p_sub :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_add_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THFloatTensor_add_scaled" + p_add_scaled :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CFloat -> IO ()) + +-- | p_sub_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THFloatTensor_sub_scaled" + p_sub_scaled :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CFloat -> IO ()) + +-- | p_mul : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_mul" + p_mul :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_div : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_div" + p_div :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_lshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_lshift" + p_lshift :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_rshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_rshift" + p_rshift :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_fmod : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_fmod" + p_fmod :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_remainder : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_remainder" + p_remainder :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_clamp : Pointer to function : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_clamp" + p_clamp :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CFloat -> IO ()) + +-- | p_bitand : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_bitand" + p_bitand :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_bitor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_bitor" + p_bitor :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_bitxor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_bitxor" + p_bitxor :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_cadd : Pointer to function : r_ t value src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cadd" + p_cadd :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> IO ()) + +-- | p_csub : Pointer to function : self src1 value src2 -> void +foreign import ccall "THTensorMath.h &THFloatTensor_csub" + p_csub :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cmul : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cmul" + p_cmul :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cpow : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cpow" + p_cpow :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cdiv : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cdiv" + p_cdiv :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_clshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_clshift" + p_clshift :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_crshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_crshift" + p_crshift :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cfmod : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cfmod" + p_cfmod :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cremainder : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cremainder" + p_cremainder :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cbitand : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cbitand" + p_cbitand :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cbitor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cbitor" + p_cbitor :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cbitxor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cbitxor" + p_cbitxor :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_addcmul : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THFloatTensor_addcmul" + p_addcmul :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_addcdiv : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THFloatTensor_addcdiv" + p_addcdiv :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_addmv : Pointer to function : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h &THFloatTensor_addmv" + p_addmv :: FunPtr (Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_addmm : Pointer to function : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h &THFloatTensor_addmm" + p_addmm :: FunPtr (Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_addr : Pointer to function : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h &THFloatTensor_addr" + p_addr :: FunPtr (Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_addbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THFloatTensor_addbmm" + p_addbmm :: FunPtr (Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_baddbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THFloatTensor_baddbmm" + p_baddbmm :: FunPtr (Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_match : Pointer to function : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h &THFloatTensor_match" + p_match :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_numel : Pointer to function : t -> ptrdiff_t +foreign import ccall "THTensorMath.h &THFloatTensor_numel" + p_numel :: FunPtr (Ptr C'THFloatTensor -> IO CPtrdiff) + +-- | p_preserveReduceDimSemantics : Pointer to function : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_preserveReduceDimSemantics" + p_preserveReduceDimSemantics :: FunPtr (Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_max : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_max" + p_max :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_min : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_min" + p_min :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_kthvalue : Pointer to function : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_kthvalue" + p_kthvalue :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CLLong -> CInt -> CInt -> IO ()) + +-- | p_mode : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_mode" + p_mode :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_median : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_median" + p_median :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_sum : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_sum" + p_sum :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_prod : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_prod" + p_prod :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_cumsum : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cumsum" + p_cumsum :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_cumprod : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cumprod" + p_cumprod :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_sign : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_sign" + p_sign :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_trace : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THFloatTensor_trace" + p_trace :: FunPtr (Ptr C'THFloatTensor -> IO CDouble) + +-- | p_cross : Pointer to function : r_ a b dimension -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cross" + p_cross :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_cmax : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cmax" + p_cmax :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cmin : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cmin" + p_cmin :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cmaxValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cmaxValue" + p_cmaxValue :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_cminValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cminValue" + p_cminValue :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_zeros : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THFloatTensor_zeros" + p_zeros :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_zerosLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THFloatTensor_zerosLike" + p_zerosLike :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_ones : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THFloatTensor_ones" + p_ones :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_onesLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THFloatTensor_onesLike" + p_onesLike :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_diag : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THFloatTensor_diag" + p_diag :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_eye : Pointer to function : r_ n m -> void +foreign import ccall "THTensorMath.h &THFloatTensor_eye" + p_eye :: FunPtr (Ptr C'THFloatTensor -> CLLong -> CLLong -> IO ()) + +-- | p_arange : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THFloatTensor_arange" + p_arange :: FunPtr (Ptr C'THFloatTensor -> CDouble -> CDouble -> CDouble -> IO ()) + +-- | p_range : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THFloatTensor_range" + p_range :: FunPtr (Ptr C'THFloatTensor -> CDouble -> CDouble -> CDouble -> IO ()) + +-- | p_randperm : Pointer to function : r_ _generator n -> void +foreign import ccall "THTensorMath.h &THFloatTensor_randperm" + p_randperm :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_reshape : Pointer to function : r_ t size -> void +foreign import ccall "THTensorMath.h &THFloatTensor_reshape" + p_reshape :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_sort : Pointer to function : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h &THFloatTensor_sort" + p_sort :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_topk : Pointer to function : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h &THFloatTensor_topk" + p_topk :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> CLLong -> CInt -> CInt -> CInt -> IO ()) + +-- | p_tril : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THFloatTensor_tril" + p_tril :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO ()) + +-- | p_triu : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THFloatTensor_triu" + p_triu :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> IO ()) + +-- | p_cat : Pointer to function : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cat" + p_cat :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> IO ()) + +-- | p_catArray : Pointer to function : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h &THFloatTensor_catArray" + p_catArray :: FunPtr (Ptr C'THFloatTensor -> Ptr (Ptr C'THFloatTensor) -> CInt -> CInt -> IO ()) + +-- | p_equal : Pointer to function : ta tb -> int +foreign import ccall "THTensorMath.h &THFloatTensor_equal" + p_equal :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO CInt) + +-- | p_ltValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_ltValue" + p_ltValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_leValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_leValue" + p_leValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_gtValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_gtValue" + p_gtValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_geValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_geValue" + p_geValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_neValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_neValue" + p_neValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_eqValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_eqValue" + p_eqValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_ltValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_ltValueT" + p_ltValueT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_leValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_leValueT" + p_leValueT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_gtValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_gtValueT" + p_gtValueT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_geValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_geValueT" + p_geValueT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_neValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_neValueT" + p_neValueT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_eqValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_eqValueT" + p_eqValueT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_ltTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_ltTensor" + p_ltTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_leTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_leTensor" + p_leTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_gtTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_gtTensor" + p_gtTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_geTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_geTensor" + p_geTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_neTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_neTensor" + p_neTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_eqTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_eqTensor" + p_eqTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_ltTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_ltTensorT" + p_ltTensorT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_leTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_leTensorT" + p_leTensorT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_gtTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_gtTensorT" + p_gtTensorT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_geTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_geTensorT" + p_geTensorT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_neTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_neTensorT" + p_neTensorT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_eqTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THFloatTensor_eqTensorT" + p_eqTensorT :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_abs : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_abs" + p_abs :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_sigmoid : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_sigmoid" + p_sigmoid :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_log : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_log" + p_log :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_lgamma : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_lgamma" + p_lgamma :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_digamma : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_digamma" + p_digamma :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_trigamma : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_trigamma" + p_trigamma :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_polygamma : Pointer to function : r_ n t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_polygamma" + p_polygamma :: FunPtr (Ptr C'THFloatTensor -> CLLong -> Ptr C'THFloatTensor -> IO ()) + +-- | p_log1p : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_log1p" + p_log1p :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_exp : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_exp" + p_exp :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_expm1 : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_expm1" + p_expm1 :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cos : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cos" + p_cos :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_acos : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_acos" + p_acos :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cosh : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_cosh" + p_cosh :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_sin : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_sin" + p_sin :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_asin : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_asin" + p_asin :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_sinh : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_sinh" + p_sinh :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_tan : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_tan" + p_tan :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_atan : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_atan" + p_atan :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_atan2 : Pointer to function : r_ tx ty -> void +foreign import ccall "THTensorMath.h &THFloatTensor_atan2" + p_atan2 :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_tanh : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_tanh" + p_tanh :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_erf : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_erf" + p_erf :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_erfinv : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_erfinv" + p_erfinv :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_pow : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THFloatTensor_pow" + p_pow :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_tpow : Pointer to function : r_ value t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_tpow" + p_tpow :: FunPtr (Ptr C'THFloatTensor -> CFloat -> Ptr C'THFloatTensor -> IO ()) + +-- | p_sqrt : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_sqrt" + p_sqrt :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_rsqrt : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_rsqrt" + p_rsqrt :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_ceil : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_ceil" + p_ceil :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_floor : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_floor" + p_floor :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_round : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_round" + p_round :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_trunc : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_trunc" + p_trunc :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_frac : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THFloatTensor_frac" + p_frac :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_lerp : Pointer to function : r_ a b weight -> void +foreign import ccall "THTensorMath.h &THFloatTensor_lerp" + p_lerp :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO ()) + +-- | p_mean : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_mean" + p_mean :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_std : Pointer to function : r_ t dimension biased keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_std" + p_std :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_var : Pointer to function : r_ t dimension biased keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_var" + p_var :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_norm : Pointer to function : r_ t value dimension keepdim -> void +foreign import ccall "THTensorMath.h &THFloatTensor_norm" + p_norm :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CInt -> CInt -> IO ()) + +-- | p_renorm : Pointer to function : r_ t value dimension maxnorm -> void +foreign import ccall "THTensorMath.h &THFloatTensor_renorm" + p_renorm :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> CInt -> CFloat -> IO ()) + +-- | p_dist : Pointer to function : a b value -> accreal +foreign import ccall "THTensorMath.h &THFloatTensor_dist" + p_dist :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CFloat -> IO CDouble) + +-- | p_histc : Pointer to function : hist tensor nbins minvalue maxvalue -> void +foreign import ccall "THTensorMath.h &THFloatTensor_histc" + p_histc :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CFloat -> CFloat -> IO ()) + +-- | p_bhistc : Pointer to function : hist tensor nbins minvalue maxvalue -> void +foreign import ccall "THTensorMath.h &THFloatTensor_bhistc" + p_bhistc :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> CLLong -> CFloat -> CFloat -> IO ()) + +-- | p_meanall : Pointer to function : self -> accreal +foreign import ccall "THTensorMath.h &THFloatTensor_meanall" + p_meanall :: FunPtr (Ptr C'THFloatTensor -> IO CDouble) + +-- | p_varall : Pointer to function : self biased -> accreal +foreign import ccall "THTensorMath.h &THFloatTensor_varall" + p_varall :: FunPtr (Ptr C'THFloatTensor -> CInt -> IO CDouble) + +-- | p_stdall : Pointer to function : self biased -> accreal +foreign import ccall "THTensorMath.h &THFloatTensor_stdall" + p_stdall :: FunPtr (Ptr C'THFloatTensor -> CInt -> IO CDouble) + +-- | p_normall : Pointer to function : t value -> accreal +foreign import ccall "THTensorMath.h &THFloatTensor_normall" + p_normall :: FunPtr (Ptr C'THFloatTensor -> CFloat -> IO CDouble) + +-- | p_linspace : Pointer to function : r_ a b n -> void +foreign import ccall "THTensorMath.h &THFloatTensor_linspace" + p_linspace :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> CLLong -> IO ()) + +-- | p_logspace : Pointer to function : r_ a b n -> void +foreign import ccall "THTensorMath.h &THFloatTensor_logspace" + p_logspace :: FunPtr (Ptr C'THFloatTensor -> CFloat -> CFloat -> CLLong -> IO ()) + +-- | p_rand : Pointer to function : r_ _generator size -> void +foreign import ccall "THTensorMath.h &THFloatTensor_rand" + p_rand :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO ()) + +-- | p_randn : Pointer to function : r_ _generator size -> void +foreign import ccall "THTensorMath.h &THFloatTensor_randn" + p_randn :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THLongStorage -> IO ()) + +-- | p_dirichlet_grad : Pointer to function : self x alpha total -> void +foreign import ccall "THTensorMath.h &THFloatTensor_dirichlet_grad" + p_dirichlet_grad :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Float/TensorRandom.hs b/src/Torch/FFI/TH/Float/TensorRandom.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/TensorRandom.hs @@ -0,0 +1,236 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.TensorRandom where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_random : self _generator -> void +foreign import ccall "THTensorRandom.h THFloatTensor_random" + c_random_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> IO () + +-- | alias of c_random_ with unused argument (for CTHState) to unify backpack signatures. +c_random :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> IO () +c_random = const c_random_ + +-- | c_clampedRandom : self _generator min max -> void +foreign import ccall "THTensorRandom.h THFloatTensor_clampedRandom" + c_clampedRandom_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () + +-- | alias of c_clampedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_clampedRandom :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () +c_clampedRandom = const c_clampedRandom_ + +-- | c_cappedRandom : self _generator max -> void +foreign import ccall "THTensorRandom.h THFloatTensor_cappedRandom" + c_cappedRandom_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_cappedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_cappedRandom :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_cappedRandom = const c_cappedRandom_ + +-- | c_geometric : self _generator p -> void +foreign import ccall "THTensorRandom.h THFloatTensor_geometric" + c_geometric_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_geometric_ with unused argument (for CTHState) to unify backpack signatures. +c_geometric :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_geometric = const c_geometric_ + +-- | c_bernoulli : self _generator p -> void +foreign import ccall "THTensorRandom.h THFloatTensor_bernoulli" + c_bernoulli_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_bernoulli_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_bernoulli = const c_bernoulli_ + +-- | c_bernoulli_FloatTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THFloatTensor_bernoulli_FloatTensor" + c_bernoulli_FloatTensor_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_bernoulli_FloatTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_FloatTensor :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () +c_bernoulli_FloatTensor = const c_bernoulli_FloatTensor_ + +-- | c_bernoulli_DoubleTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THFloatTensor_bernoulli_DoubleTensor" + c_bernoulli_DoubleTensor_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_bernoulli_DoubleTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_DoubleTensor :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () +c_bernoulli_DoubleTensor = const c_bernoulli_DoubleTensor_ + +-- | c_uniform : self _generator a b -> void +foreign import ccall "THTensorRandom.h THFloatTensor_uniform" + c_uniform_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () + +-- | alias of c_uniform_ with unused argument (for CTHState) to unify backpack signatures. +c_uniform :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () +c_uniform = const c_uniform_ + +-- | c_normal : self _generator mean stdv -> void +foreign import ccall "THTensorRandom.h THFloatTensor_normal" + c_normal_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () + +-- | alias of c_normal_ with unused argument (for CTHState) to unify backpack signatures. +c_normal :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () +c_normal = const c_normal_ + +-- | c_normal_means : self gen means stddev -> void +foreign import ccall "THTensorRandom.h THFloatTensor_normal_means" + c_normal_means_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> CDouble -> IO () + +-- | alias of c_normal_means_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_means :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> CDouble -> IO () +c_normal_means = const c_normal_means_ + +-- | c_normal_stddevs : self gen mean stddevs -> void +foreign import ccall "THTensorRandom.h THFloatTensor_normal_stddevs" + c_normal_stddevs_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_normal_stddevs_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_stddevs :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> Ptr C'THFloatTensor -> IO () +c_normal_stddevs = const c_normal_stddevs_ + +-- | c_normal_means_stddevs : self gen means stddevs -> void +foreign import ccall "THTensorRandom.h THFloatTensor_normal_means_stddevs" + c_normal_means_stddevs_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_normal_means_stddevs_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_means_stddevs :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO () +c_normal_means_stddevs = const c_normal_means_stddevs_ + +-- | c_exponential : self _generator lambda -> void +foreign import ccall "THTensorRandom.h THFloatTensor_exponential" + c_exponential_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_exponential_ with unused argument (for CTHState) to unify backpack signatures. +c_exponential :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_exponential = const c_exponential_ + +-- | c_standard_gamma : self _generator alpha -> void +foreign import ccall "THTensorRandom.h THFloatTensor_standard_gamma" + c_standard_gamma_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_standard_gamma_ with unused argument (for CTHState) to unify backpack signatures. +c_standard_gamma :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () +c_standard_gamma = const c_standard_gamma_ + +-- | c_cauchy : self _generator median sigma -> void +foreign import ccall "THTensorRandom.h THFloatTensor_cauchy" + c_cauchy_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () + +-- | alias of c_cauchy_ with unused argument (for CTHState) to unify backpack signatures. +c_cauchy :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () +c_cauchy = const c_cauchy_ + +-- | c_logNormal : self _generator mean stdv -> void +foreign import ccall "THTensorRandom.h THFloatTensor_logNormal" + c_logNormal_ :: Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () + +-- | alias of c_logNormal_ with unused argument (for CTHState) to unify backpack signatures. +c_logNormal :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO () +c_logNormal = const c_logNormal_ + +-- | c_multinomial : self _generator prob_dist n_sample with_replacement -> void +foreign import ccall "THTensorRandom.h THFloatTensor_multinomial" + c_multinomial_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () + +-- | alias of c_multinomial_ with unused argument (for CTHState) to unify backpack signatures. +c_multinomial :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> CInt -> CInt -> IO () +c_multinomial = const c_multinomial_ + +-- | c_multinomialAliasSetup : prob_dist J q -> void +foreign import ccall "THTensorRandom.h THFloatTensor_multinomialAliasSetup" + c_multinomialAliasSetup_ :: Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_multinomialAliasSetup_ with unused argument (for CTHState) to unify backpack signatures. +c_multinomialAliasSetup :: Ptr C'THState -> Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () +c_multinomialAliasSetup = const c_multinomialAliasSetup_ + +-- | c_multinomialAliasDraw : self _generator J q -> void +foreign import ccall "THTensorRandom.h THFloatTensor_multinomialAliasDraw" + c_multinomialAliasDraw_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_multinomialAliasDraw_ with unused argument (for CTHState) to unify backpack signatures. +c_multinomialAliasDraw :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () +c_multinomialAliasDraw = const c_multinomialAliasDraw_ + +-- | p_random : Pointer to function : self _generator -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_random" + p_random :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> IO ()) + +-- | p_clampedRandom : Pointer to function : self _generator min max -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_clampedRandom" + p_clampedRandom :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO ()) + +-- | p_cappedRandom : Pointer to function : self _generator max -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_cappedRandom" + p_cappedRandom :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_geometric : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_geometric" + p_geometric :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_bernoulli" + p_bernoulli :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli_FloatTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_bernoulli_FloatTensor" + p_bernoulli_FloatTensor :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO ()) + +-- | p_bernoulli_DoubleTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_bernoulli_DoubleTensor" + p_bernoulli_DoubleTensor :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_uniform : Pointer to function : self _generator a b -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_uniform" + p_uniform :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO ()) + +-- | p_normal : Pointer to function : self _generator mean stdv -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_normal" + p_normal :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO ()) + +-- | p_normal_means : Pointer to function : self gen means stddev -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_normal_means" + p_normal_means :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> CDouble -> IO ()) + +-- | p_normal_stddevs : Pointer to function : self gen mean stddevs -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_normal_stddevs" + p_normal_stddevs :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> Ptr C'THFloatTensor -> IO ()) + +-- | p_normal_means_stddevs : Pointer to function : self gen means stddevs -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_normal_means_stddevs" + p_normal_means_stddevs :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_exponential : Pointer to function : self _generator lambda -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_exponential" + p_exponential :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_standard_gamma : Pointer to function : self _generator alpha -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_standard_gamma" + p_standard_gamma :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO ()) + +-- | p_cauchy : Pointer to function : self _generator median sigma -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_cauchy" + p_cauchy :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO ()) + +-- | p_logNormal : Pointer to function : self _generator mean stdv -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_logNormal" + p_logNormal :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THGenerator -> CDouble -> CDouble -> IO ()) + +-- | p_multinomial : Pointer to function : self _generator prob_dist n_sample with_replacement -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_multinomial" + p_multinomial :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> CInt -> CInt -> IO ()) + +-- | p_multinomialAliasSetup : Pointer to function : prob_dist J q -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_multinomialAliasSetup" + p_multinomialAliasSetup :: FunPtr (Ptr C'THFloatTensor -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_multinomialAliasDraw : Pointer to function : self _generator J q -> void +foreign import ccall "THTensorRandom.h &THFloatTensor_multinomialAliasDraw" + p_multinomialAliasDraw :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Float/Vector.hs b/src/Torch/FFI/TH/Float/Vector.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Float/Vector.hs @@ -0,0 +1,476 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Float.Vector where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : x c n -> void +foreign import ccall "THVector.h THFloatVector_fill" + c_fill_ :: Ptr CFloat -> CFloat -> CPtrdiff -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () +c_fill = const c_fill_ + +-- | c_cadd : z x y c n -> void +foreign import ccall "THVector.h THFloatVector_cadd" + c_cadd_ :: Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () +c_cadd = const c_cadd_ + +-- | c_adds : y x c n -> void +foreign import ccall "THVector.h THFloatVector_adds" + c_adds_ :: Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () + +-- | alias of c_adds_ with unused argument (for CTHState) to unify backpack signatures. +c_adds :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () +c_adds = const c_adds_ + +-- | c_cmul : z x y n -> void +foreign import ccall "THVector.h THFloatVector_cmul" + c_cmul_ :: Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_cmul = const c_cmul_ + +-- | c_muls : y x c n -> void +foreign import ccall "THVector.h THFloatVector_muls" + c_muls_ :: Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () + +-- | alias of c_muls_ with unused argument (for CTHState) to unify backpack signatures. +c_muls :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () +c_muls = const c_muls_ + +-- | c_cdiv : z x y n -> void +foreign import ccall "THVector.h THFloatVector_cdiv" + c_cdiv_ :: Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_cdiv = const c_cdiv_ + +-- | c_divs : y x c n -> void +foreign import ccall "THVector.h THFloatVector_divs" + c_divs_ :: Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () + +-- | alias of c_divs_ with unused argument (for CTHState) to unify backpack signatures. +c_divs :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () +c_divs = const c_divs_ + +-- | c_copy : y x n -> void +foreign import ccall "THVector.h THFloatVector_copy" + c_copy_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_copy = const c_copy_ + +-- | c_neg : y x n -> void +foreign import ccall "THVector.h THFloatVector_neg" + c_neg_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_neg = const c_neg_ + +-- | c_normal_fill : data size generator mean stddev -> void +foreign import ccall "THVector.h THFloatVector_normal_fill" + c_normal_fill_ :: Ptr CFloat -> CLLong -> Ptr C'THGenerator -> CFloat -> CFloat -> IO () + +-- | alias of c_normal_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_fill :: Ptr C'THState -> Ptr CFloat -> CLLong -> Ptr C'THGenerator -> CFloat -> CFloat -> IO () +c_normal_fill = const c_normal_fill_ + +-- | c_abs : y x n -> void +foreign import ccall "THVector.h THFloatVector_abs" + c_abs_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_abs = const c_abs_ + +-- | c_log : y x n -> void +foreign import ccall "THVector.h THFloatVector_log" + c_log_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_log_ with unused argument (for CTHState) to unify backpack signatures. +c_log :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_log = const c_log_ + +-- | c_lgamma : y x n -> void +foreign import ccall "THVector.h THFloatVector_lgamma" + c_lgamma_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_lgamma_ with unused argument (for CTHState) to unify backpack signatures. +c_lgamma :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_lgamma = const c_lgamma_ + +-- | c_digamma : y x n -> void +foreign import ccall "THVector.h THFloatVector_digamma" + c_digamma_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_digamma_ with unused argument (for CTHState) to unify backpack signatures. +c_digamma :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_digamma = const c_digamma_ + +-- | c_trigamma : y x n -> void +foreign import ccall "THVector.h THFloatVector_trigamma" + c_trigamma_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_trigamma_ with unused argument (for CTHState) to unify backpack signatures. +c_trigamma :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_trigamma = const c_trigamma_ + +-- | c_log1p : y x n -> void +foreign import ccall "THVector.h THFloatVector_log1p" + c_log1p_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_log1p_ with unused argument (for CTHState) to unify backpack signatures. +c_log1p :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_log1p = const c_log1p_ + +-- | c_sigmoid : y x n -> void +foreign import ccall "THVector.h THFloatVector_sigmoid" + c_sigmoid_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_sigmoid_ with unused argument (for CTHState) to unify backpack signatures. +c_sigmoid :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_sigmoid = const c_sigmoid_ + +-- | c_exp : y x n -> void +foreign import ccall "THVector.h THFloatVector_exp" + c_exp_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_exp_ with unused argument (for CTHState) to unify backpack signatures. +c_exp :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_exp = const c_exp_ + +-- | c_expm1 : y x n -> void +foreign import ccall "THVector.h THFloatVector_expm1" + c_expm1_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_expm1_ with unused argument (for CTHState) to unify backpack signatures. +c_expm1 :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_expm1 = const c_expm1_ + +-- | c_erf : y x n -> void +foreign import ccall "THVector.h THFloatVector_erf" + c_erf_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_erf_ with unused argument (for CTHState) to unify backpack signatures. +c_erf :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_erf = const c_erf_ + +-- | c_erfinv : y x n -> void +foreign import ccall "THVector.h THFloatVector_erfinv" + c_erfinv_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_erfinv_ with unused argument (for CTHState) to unify backpack signatures. +c_erfinv :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_erfinv = const c_erfinv_ + +-- | c_cos : y x n -> void +foreign import ccall "THVector.h THFloatVector_cos" + c_cos_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_cos_ with unused argument (for CTHState) to unify backpack signatures. +c_cos :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_cos = const c_cos_ + +-- | c_acos : y x n -> void +foreign import ccall "THVector.h THFloatVector_acos" + c_acos_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_acos_ with unused argument (for CTHState) to unify backpack signatures. +c_acos :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_acos = const c_acos_ + +-- | c_cosh : y x n -> void +foreign import ccall "THVector.h THFloatVector_cosh" + c_cosh_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_cosh_ with unused argument (for CTHState) to unify backpack signatures. +c_cosh :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_cosh = const c_cosh_ + +-- | c_sin : y x n -> void +foreign import ccall "THVector.h THFloatVector_sin" + c_sin_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_sin_ with unused argument (for CTHState) to unify backpack signatures. +c_sin :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_sin = const c_sin_ + +-- | c_asin : y x n -> void +foreign import ccall "THVector.h THFloatVector_asin" + c_asin_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_asin_ with unused argument (for CTHState) to unify backpack signatures. +c_asin :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_asin = const c_asin_ + +-- | c_sinh : y x n -> void +foreign import ccall "THVector.h THFloatVector_sinh" + c_sinh_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_sinh_ with unused argument (for CTHState) to unify backpack signatures. +c_sinh :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_sinh = const c_sinh_ + +-- | c_tan : y x n -> void +foreign import ccall "THVector.h THFloatVector_tan" + c_tan_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_tan_ with unused argument (for CTHState) to unify backpack signatures. +c_tan :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_tan = const c_tan_ + +-- | c_atan : y x n -> void +foreign import ccall "THVector.h THFloatVector_atan" + c_atan_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_atan_ with unused argument (for CTHState) to unify backpack signatures. +c_atan :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_atan = const c_atan_ + +-- | c_tanh : y x n -> void +foreign import ccall "THVector.h THFloatVector_tanh" + c_tanh_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_tanh_ with unused argument (for CTHState) to unify backpack signatures. +c_tanh :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_tanh = const c_tanh_ + +-- | c_pow : y x c n -> void +foreign import ccall "THVector.h THFloatVector_pow" + c_pow_ :: Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () + +-- | alias of c_pow_ with unused argument (for CTHState) to unify backpack signatures. +c_pow :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO () +c_pow = const c_pow_ + +-- | c_sqrt : y x n -> void +foreign import ccall "THVector.h THFloatVector_sqrt" + c_sqrt_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_sqrt_ with unused argument (for CTHState) to unify backpack signatures. +c_sqrt :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_sqrt = const c_sqrt_ + +-- | c_rsqrt : y x n -> void +foreign import ccall "THVector.h THFloatVector_rsqrt" + c_rsqrt_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_rsqrt_ with unused argument (for CTHState) to unify backpack signatures. +c_rsqrt :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_rsqrt = const c_rsqrt_ + +-- | c_ceil : y x n -> void +foreign import ccall "THVector.h THFloatVector_ceil" + c_ceil_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_ceil_ with unused argument (for CTHState) to unify backpack signatures. +c_ceil :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_ceil = const c_ceil_ + +-- | c_floor : y x n -> void +foreign import ccall "THVector.h THFloatVector_floor" + c_floor_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_floor_ with unused argument (for CTHState) to unify backpack signatures. +c_floor :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_floor = const c_floor_ + +-- | c_round : y x n -> void +foreign import ccall "THVector.h THFloatVector_round" + c_round_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_round_ with unused argument (for CTHState) to unify backpack signatures. +c_round :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_round = const c_round_ + +-- | c_trunc : y x n -> void +foreign import ccall "THVector.h THFloatVector_trunc" + c_trunc_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_trunc_ with unused argument (for CTHState) to unify backpack signatures. +c_trunc :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_trunc = const c_trunc_ + +-- | c_frac : y x n -> void +foreign import ccall "THVector.h THFloatVector_frac" + c_frac_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_frac_ with unused argument (for CTHState) to unify backpack signatures. +c_frac :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_frac = const c_frac_ + +-- | c_cinv : y x n -> void +foreign import ccall "THVector.h THFloatVector_cinv" + c_cinv_ :: Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () + +-- | alias of c_cinv_ with unused argument (for CTHState) to unify backpack signatures. +c_cinv :: Ptr C'THState -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO () +c_cinv = const c_cinv_ + +-- | p_fill : Pointer to function : x c n -> void +foreign import ccall "THVector.h &THFloatVector_fill" + p_fill :: FunPtr (Ptr CFloat -> CFloat -> CPtrdiff -> IO ()) + +-- | p_cadd : Pointer to function : z x y c n -> void +foreign import ccall "THVector.h &THFloatVector_cadd" + p_cadd :: FunPtr (Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO ()) + +-- | p_adds : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THFloatVector_adds" + p_adds :: FunPtr (Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO ()) + +-- | p_cmul : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THFloatVector_cmul" + p_cmul :: FunPtr (Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_muls : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THFloatVector_muls" + p_muls :: FunPtr (Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO ()) + +-- | p_cdiv : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THFloatVector_cdiv" + p_cdiv :: FunPtr (Ptr CFloat -> Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_divs : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THFloatVector_divs" + p_divs :: FunPtr (Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO ()) + +-- | p_copy : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_copy" + p_copy :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_neg : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_neg" + p_neg :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_normal_fill : Pointer to function : data size generator mean stddev -> void +foreign import ccall "THVector.h &THFloatVector_normal_fill" + p_normal_fill :: FunPtr (Ptr CFloat -> CLLong -> Ptr C'THGenerator -> CFloat -> CFloat -> IO ()) + +-- | p_abs : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_abs" + p_abs :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_log : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_log" + p_log :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_lgamma : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_lgamma" + p_lgamma :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_digamma : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_digamma" + p_digamma :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_trigamma : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_trigamma" + p_trigamma :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_log1p : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_log1p" + p_log1p :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_sigmoid : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_sigmoid" + p_sigmoid :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_exp : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_exp" + p_exp :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_expm1 : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_expm1" + p_expm1 :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_erf : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_erf" + p_erf :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_erfinv : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_erfinv" + p_erfinv :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_cos : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_cos" + p_cos :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_acos : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_acos" + p_acos :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_cosh : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_cosh" + p_cosh :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_sin : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_sin" + p_sin :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_asin : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_asin" + p_asin :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_sinh : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_sinh" + p_sinh :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_tan : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_tan" + p_tan :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_atan : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_atan" + p_atan :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_tanh : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_tanh" + p_tanh :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_pow : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THFloatVector_pow" + p_pow :: FunPtr (Ptr CFloat -> Ptr CFloat -> CFloat -> CPtrdiff -> IO ()) + +-- | p_sqrt : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_sqrt" + p_sqrt :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_rsqrt : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_rsqrt" + p_rsqrt :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_ceil : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_ceil" + p_ceil :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_floor : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_floor" + p_floor :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_round : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_round" + p_round :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_trunc : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_trunc" + p_trunc :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_frac : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_frac" + p_frac :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) + +-- | p_cinv : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THFloatVector_cinv" + p_cinv :: FunPtr (Ptr CFloat -> Ptr CFloat -> CPtrdiff -> IO ()) diff --git a/src/Torch/FFI/TH/Int/Blas.hs b/src/Torch/FFI/TH/Int/Blas.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Int/Blas.hs @@ -0,0 +1,104 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.Blas where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_swap : n x incx y incy -> void +foreign import ccall "THBlas.h THIntBlas_swap" + c_swap_ :: CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO () +c_swap = const c_swap_ + +-- | c_scal : n a x incx -> void +foreign import ccall "THBlas.h THIntBlas_scal" + c_scal_ :: CLLong -> CInt -> Ptr CInt -> CLLong -> IO () + +-- | alias of c_scal_ with unused argument (for CTHState) to unify backpack signatures. +c_scal :: Ptr C'THState -> CLLong -> CInt -> Ptr CInt -> CLLong -> IO () +c_scal = const c_scal_ + +-- | c_copy : n x incx y incy -> void +foreign import ccall "THBlas.h THIntBlas_copy" + c_copy_ :: CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO () +c_copy = const c_copy_ + +-- | c_axpy : n a x incx y incy -> void +foreign import ccall "THBlas.h THIntBlas_axpy" + c_axpy_ :: CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO () + +-- | alias of c_axpy_ with unused argument (for CTHState) to unify backpack signatures. +c_axpy :: Ptr C'THState -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO () +c_axpy = const c_axpy_ + +-- | c_dot : n x incx y incy -> real +foreign import ccall "THBlas.h THIntBlas_dot" + c_dot_ :: CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO CInt + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO CInt +c_dot = const c_dot_ + +-- | c_gemv : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h THIntBlas_gemv" + c_gemv_ :: CChar -> CLLong -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> CInt -> Ptr CInt -> CLLong -> IO () + +-- | alias of c_gemv_ with unused argument (for CTHState) to unify backpack signatures. +c_gemv :: Ptr C'THState -> CChar -> CLLong -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> CInt -> Ptr CInt -> CLLong -> IO () +c_gemv = const c_gemv_ + +-- | c_ger : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h THIntBlas_ger" + c_ger_ :: CLLong -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO () + +-- | alias of c_ger_ with unused argument (for CTHState) to unify backpack signatures. +c_ger :: Ptr C'THState -> CLLong -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO () +c_ger = const c_ger_ + +-- | c_gemm : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h THIntBlas_gemm" + c_gemm_ :: CChar -> CChar -> CLLong -> CLLong -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> CInt -> Ptr CInt -> CLLong -> IO () + +-- | alias of c_gemm_ with unused argument (for CTHState) to unify backpack signatures. +c_gemm :: Ptr C'THState -> CChar -> CChar -> CLLong -> CLLong -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> CInt -> Ptr CInt -> CLLong -> IO () +c_gemm = const c_gemm_ + +-- | p_swap : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THIntBlas_swap" + p_swap :: FunPtr (CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO ()) + +-- | p_scal : Pointer to function : n a x incx -> void +foreign import ccall "THBlas.h &THIntBlas_scal" + p_scal :: FunPtr (CLLong -> CInt -> Ptr CInt -> CLLong -> IO ()) + +-- | p_copy : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THIntBlas_copy" + p_copy :: FunPtr (CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO ()) + +-- | p_axpy : Pointer to function : n a x incx y incy -> void +foreign import ccall "THBlas.h &THIntBlas_axpy" + p_axpy :: FunPtr (CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO ()) + +-- | p_dot : Pointer to function : n x incx y incy -> real +foreign import ccall "THBlas.h &THIntBlas_dot" + p_dot :: FunPtr (CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO CInt) + +-- | p_gemv : Pointer to function : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h &THIntBlas_gemv" + p_gemv :: FunPtr (CChar -> CLLong -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> CInt -> Ptr CInt -> CLLong -> IO ()) + +-- | p_ger : Pointer to function : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h &THIntBlas_ger" + p_ger :: FunPtr (CLLong -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> IO ()) + +-- | p_gemm : Pointer to function : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h &THIntBlas_gemm" + p_gemm :: FunPtr (CChar -> CChar -> CLLong -> CLLong -> CLLong -> CInt -> Ptr CInt -> CLLong -> Ptr CInt -> CLLong -> CInt -> Ptr CInt -> CLLong -> IO ()) diff --git a/src/Torch/FFI/TH/Int/Storage.hs b/src/Torch/FFI/TH/Int/Storage.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Int/Storage.hs @@ -0,0 +1,260 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.Storage where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_data : -> real * +foreign import ccall "THStorage.h THIntStorage_data" + c_data_ :: Ptr C'THIntStorage -> IO (Ptr CInt) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THIntStorage -> IO (Ptr CInt) +c_data = const c_data_ + +-- | c_size : -> ptrdiff_t +foreign import ccall "THStorage.h THIntStorage_size" + c_size_ :: Ptr C'THIntStorage -> IO CPtrdiff + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THIntStorage -> IO CPtrdiff +c_size = const c_size_ + +-- | c_set : -> void +foreign import ccall "THStorage.h THIntStorage_set" + c_set_ :: Ptr C'THIntStorage -> CPtrdiff -> CInt -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THIntStorage -> CPtrdiff -> CInt -> IO () +c_set = const c_set_ + +-- | c_get : -> real +foreign import ccall "THStorage.h THIntStorage_get" + c_get_ :: Ptr C'THIntStorage -> CPtrdiff -> IO CInt + +-- | alias of c_get_ with unused argument (for CTHState) to unify backpack signatures. +c_get :: Ptr C'THState -> Ptr C'THIntStorage -> CPtrdiff -> IO CInt +c_get = const c_get_ + +-- | c_new : -> THStorage * +foreign import ccall "THStorage.h THIntStorage_new" + c_new_ :: IO (Ptr C'THIntStorage) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THIntStorage) +c_new = const c_new_ + +-- | c_newWithSize : size -> THStorage * +foreign import ccall "THStorage.h THIntStorage_newWithSize" + c_newWithSize_ :: CPtrdiff -> IO (Ptr C'THIntStorage) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> CPtrdiff -> IO (Ptr C'THIntStorage) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1 : -> THStorage * +foreign import ccall "THStorage.h THIntStorage_newWithSize1" + c_newWithSize1_ :: CInt -> IO (Ptr C'THIntStorage) + +-- | alias of c_newWithSize1_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1 :: Ptr C'THState -> CInt -> IO (Ptr C'THIntStorage) +c_newWithSize1 = const c_newWithSize1_ + +-- | c_newWithSize2 : -> THStorage * +foreign import ccall "THStorage.h THIntStorage_newWithSize2" + c_newWithSize2_ :: CInt -> CInt -> IO (Ptr C'THIntStorage) + +-- | alias of c_newWithSize2_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2 :: Ptr C'THState -> CInt -> CInt -> IO (Ptr C'THIntStorage) +c_newWithSize2 = const c_newWithSize2_ + +-- | c_newWithSize3 : -> THStorage * +foreign import ccall "THStorage.h THIntStorage_newWithSize3" + c_newWithSize3_ :: CInt -> CInt -> CInt -> IO (Ptr C'THIntStorage) + +-- | alias of c_newWithSize3_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3 :: Ptr C'THState -> CInt -> CInt -> CInt -> IO (Ptr C'THIntStorage) +c_newWithSize3 = const c_newWithSize3_ + +-- | c_newWithSize4 : -> THStorage * +foreign import ccall "THStorage.h THIntStorage_newWithSize4" + c_newWithSize4_ :: CInt -> CInt -> CInt -> CInt -> IO (Ptr C'THIntStorage) + +-- | alias of c_newWithSize4_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4 :: Ptr C'THState -> CInt -> CInt -> CInt -> CInt -> IO (Ptr C'THIntStorage) +c_newWithSize4 = const c_newWithSize4_ + +-- | c_newWithMapping : filename size flags -> THStorage * +foreign import ccall "THStorage.h THIntStorage_newWithMapping" + c_newWithMapping_ :: Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THIntStorage) + +-- | alias of c_newWithMapping_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithMapping :: Ptr C'THState -> Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THIntStorage) +c_newWithMapping = const c_newWithMapping_ + +-- | c_newWithData : data size -> THStorage * +foreign import ccall "THStorage.h THIntStorage_newWithData" + c_newWithData_ :: Ptr CInt -> CPtrdiff -> IO (Ptr C'THIntStorage) + +-- | alias of c_newWithData_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithData :: Ptr C'THState -> Ptr CInt -> CPtrdiff -> IO (Ptr C'THIntStorage) +c_newWithData = const c_newWithData_ + +-- | c_newWithAllocator : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THIntStorage_newWithAllocator" + c_newWithAllocator_ :: CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THIntStorage) + +-- | alias of c_newWithAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithAllocator :: Ptr C'THState -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THIntStorage) +c_newWithAllocator = const c_newWithAllocator_ + +-- | c_newWithDataAndAllocator : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THIntStorage_newWithDataAndAllocator" + c_newWithDataAndAllocator_ :: Ptr CInt -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THIntStorage) + +-- | alias of c_newWithDataAndAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithDataAndAllocator :: Ptr C'THState -> Ptr CInt -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THIntStorage) +c_newWithDataAndAllocator = const c_newWithDataAndAllocator_ + +-- | c_setFlag : storage flag -> void +foreign import ccall "THStorage.h THIntStorage_setFlag" + c_setFlag_ :: Ptr C'THIntStorage -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THIntStorage -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : storage flag -> void +foreign import ccall "THStorage.h THIntStorage_clearFlag" + c_clearFlag_ :: Ptr C'THIntStorage -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THIntStorage -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_retain : storage -> void +foreign import ccall "THStorage.h THIntStorage_retain" + c_retain_ :: Ptr C'THIntStorage -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THIntStorage -> IO () +c_retain = const c_retain_ + +-- | c_swap : storage1 storage2 -> void +foreign import ccall "THStorage.h THIntStorage_swap" + c_swap_ :: Ptr C'THIntStorage -> Ptr C'THIntStorage -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THIntStorage -> IO () +c_swap = const c_swap_ + +-- | c_free : storage -> void +foreign import ccall "THStorage.h THIntStorage_free" + c_free_ :: Ptr C'THIntStorage -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THIntStorage -> IO () +c_free = const c_free_ + +-- | c_resize : storage size -> void +foreign import ccall "THStorage.h THIntStorage_resize" + c_resize_ :: Ptr C'THIntStorage -> CPtrdiff -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THIntStorage -> CPtrdiff -> IO () +c_resize = const c_resize_ + +-- | c_fill : storage value -> void +foreign import ccall "THStorage.h THIntStorage_fill" + c_fill_ :: Ptr C'THIntStorage -> CInt -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THIntStorage -> CInt -> IO () +c_fill = const c_fill_ + +-- | p_data : Pointer to function : -> real * +foreign import ccall "THStorage.h &THIntStorage_data" + p_data :: FunPtr (Ptr C'THIntStorage -> IO (Ptr CInt)) + +-- | p_size : Pointer to function : -> ptrdiff_t +foreign import ccall "THStorage.h &THIntStorage_size" + p_size :: FunPtr (Ptr C'THIntStorage -> IO CPtrdiff) + +-- | p_set : Pointer to function : -> void +foreign import ccall "THStorage.h &THIntStorage_set" + p_set :: FunPtr (Ptr C'THIntStorage -> CPtrdiff -> CInt -> IO ()) + +-- | p_get : Pointer to function : -> real +foreign import ccall "THStorage.h &THIntStorage_get" + p_get :: FunPtr (Ptr C'THIntStorage -> CPtrdiff -> IO CInt) + +-- | p_new : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_new" + p_new :: FunPtr (IO (Ptr C'THIntStorage)) + +-- | p_newWithSize : Pointer to function : size -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_newWithSize" + p_newWithSize :: FunPtr (CPtrdiff -> IO (Ptr C'THIntStorage)) + +-- | p_newWithSize1 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_newWithSize1" + p_newWithSize1 :: FunPtr (CInt -> IO (Ptr C'THIntStorage)) + +-- | p_newWithSize2 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_newWithSize2" + p_newWithSize2 :: FunPtr (CInt -> CInt -> IO (Ptr C'THIntStorage)) + +-- | p_newWithSize3 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_newWithSize3" + p_newWithSize3 :: FunPtr (CInt -> CInt -> CInt -> IO (Ptr C'THIntStorage)) + +-- | p_newWithSize4 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_newWithSize4" + p_newWithSize4 :: FunPtr (CInt -> CInt -> CInt -> CInt -> IO (Ptr C'THIntStorage)) + +-- | p_newWithMapping : Pointer to function : filename size flags -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_newWithMapping" + p_newWithMapping :: FunPtr (Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THIntStorage)) + +-- | p_newWithData : Pointer to function : data size -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_newWithData" + p_newWithData :: FunPtr (Ptr CInt -> CPtrdiff -> IO (Ptr C'THIntStorage)) + +-- | p_newWithAllocator : Pointer to function : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_newWithAllocator" + p_newWithAllocator :: FunPtr (CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THIntStorage)) + +-- | p_newWithDataAndAllocator : Pointer to function : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THIntStorage_newWithDataAndAllocator" + p_newWithDataAndAllocator :: FunPtr (Ptr CInt -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THIntStorage)) + +-- | p_setFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THIntStorage_setFlag" + p_setFlag :: FunPtr (Ptr C'THIntStorage -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THIntStorage_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THIntStorage -> CChar -> IO ()) + +-- | p_retain : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THIntStorage_retain" + p_retain :: FunPtr (Ptr C'THIntStorage -> IO ()) + +-- | p_swap : Pointer to function : storage1 storage2 -> void +foreign import ccall "THStorage.h &THIntStorage_swap" + p_swap :: FunPtr (Ptr C'THIntStorage -> Ptr C'THIntStorage -> IO ()) + +-- | p_free : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THIntStorage_free" + p_free :: FunPtr (Ptr C'THIntStorage -> IO ()) + +-- | p_resize : Pointer to function : storage size -> void +foreign import ccall "THStorage.h &THIntStorage_resize" + p_resize :: FunPtr (Ptr C'THIntStorage -> CPtrdiff -> IO ()) + +-- | p_fill : Pointer to function : storage value -> void +foreign import ccall "THStorage.h &THIntStorage_fill" + p_fill :: FunPtr (Ptr C'THIntStorage -> CInt -> IO ()) diff --git a/src/Torch/FFI/TH/Int/StorageCopy.hs b/src/Torch/FFI/TH/Int/StorageCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Int/StorageCopy.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.StorageCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_rawCopy : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_rawCopy" + c_rawCopy_ :: Ptr C'THIntStorage -> Ptr CInt -> IO () + +-- | alias of c_rawCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_rawCopy :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr CInt -> IO () +c_rawCopy = const c_rawCopy_ + +-- | c_copy : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_copy" + c_copy_ :: Ptr C'THIntStorage -> Ptr C'THIntStorage -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THIntStorage -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_copyByte" + c_copyByte_ :: Ptr C'THIntStorage -> Ptr C'THByteStorage -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THByteStorage -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_copyChar" + c_copyChar_ :: Ptr C'THIntStorage -> Ptr C'THCharStorage -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THCharStorage -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_copyShort" + c_copyShort_ :: Ptr C'THIntStorage -> Ptr C'THShortStorage -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THShortStorage -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_copyInt" + c_copyInt_ :: Ptr C'THIntStorage -> Ptr C'THIntStorage -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THIntStorage -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_copyLong" + c_copyLong_ :: Ptr C'THIntStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THLongStorage -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_copyFloat" + c_copyFloat_ :: Ptr C'THIntStorage -> Ptr C'THFloatStorage -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THFloatStorage -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_copyDouble" + c_copyDouble_ :: Ptr C'THIntStorage -> Ptr C'THDoubleStorage -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THDoubleStorage -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : storage src -> void +foreign import ccall "THStorageCopy.h THIntStorage_copyHalf" + c_copyHalf_ :: Ptr C'THIntStorage -> Ptr C'THHalfStorage -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THIntStorage -> Ptr C'THHalfStorage -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_rawCopy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_rawCopy" + p_rawCopy :: FunPtr (Ptr C'THIntStorage -> Ptr CInt -> IO ()) + +-- | p_copy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_copy" + p_copy :: FunPtr (Ptr C'THIntStorage -> Ptr C'THIntStorage -> IO ()) + +-- | p_copyByte : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_copyByte" + p_copyByte :: FunPtr (Ptr C'THIntStorage -> Ptr C'THByteStorage -> IO ()) + +-- | p_copyChar : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_copyChar" + p_copyChar :: FunPtr (Ptr C'THIntStorage -> Ptr C'THCharStorage -> IO ()) + +-- | p_copyShort : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_copyShort" + p_copyShort :: FunPtr (Ptr C'THIntStorage -> Ptr C'THShortStorage -> IO ()) + +-- | p_copyInt : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_copyInt" + p_copyInt :: FunPtr (Ptr C'THIntStorage -> Ptr C'THIntStorage -> IO ()) + +-- | p_copyLong : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_copyLong" + p_copyLong :: FunPtr (Ptr C'THIntStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_copyFloat : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THIntStorage -> Ptr C'THFloatStorage -> IO ()) + +-- | p_copyDouble : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THIntStorage -> Ptr C'THDoubleStorage -> IO ()) + +-- | p_copyHalf : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THIntStorage_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THIntStorage -> Ptr C'THHalfStorage -> IO ()) diff --git a/src/Torch/FFI/TH/Int/Tensor.hs b/src/Torch/FFI/TH/Int/Tensor.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Int/Tensor.hs @@ -0,0 +1,872 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.Tensor where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_storage : self -> THStorage * +foreign import ccall "THTensor.h THIntTensor_storage" + c_storage_ :: Ptr C'THIntTensor -> IO (Ptr C'THIntStorage) + +-- | alias of c_storage_ with unused argument (for CTHState) to unify backpack signatures. +c_storage :: Ptr C'THState -> Ptr C'THIntTensor -> IO (Ptr C'THIntStorage) +c_storage = const c_storage_ + +-- | c_storageOffset : self -> ptrdiff_t +foreign import ccall "THTensor.h THIntTensor_storageOffset" + c_storageOffset_ :: Ptr C'THIntTensor -> IO CPtrdiff + +-- | alias of c_storageOffset_ with unused argument (for CTHState) to unify backpack signatures. +c_storageOffset :: Ptr C'THState -> Ptr C'THIntTensor -> IO CPtrdiff +c_storageOffset = const c_storageOffset_ + +-- | c_nDimension : self -> int +foreign import ccall "THTensor.h THIntTensor_nDimension" + c_nDimension_ :: Ptr C'THIntTensor -> IO CInt + +-- | alias of c_nDimension_ with unused argument (for CTHState) to unify backpack signatures. +c_nDimension :: Ptr C'THState -> Ptr C'THIntTensor -> IO CInt +c_nDimension = const c_nDimension_ + +-- | c_size : self dim -> int64_t +foreign import ccall "THTensor.h THIntTensor_size" + c_size_ :: Ptr C'THIntTensor -> CInt -> IO CLLong + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> IO CLLong +c_size = const c_size_ + +-- | c_stride : self dim -> int64_t +foreign import ccall "THTensor.h THIntTensor_stride" + c_stride_ :: Ptr C'THIntTensor -> CInt -> IO CLLong + +-- | alias of c_stride_ with unused argument (for CTHState) to unify backpack signatures. +c_stride :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> IO CLLong +c_stride = const c_stride_ + +-- | c_newSizeOf : self -> THLongStorage * +foreign import ccall "THTensor.h THIntTensor_newSizeOf" + c_newSizeOf_ :: Ptr C'THIntTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newSizeOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newSizeOf :: Ptr C'THState -> Ptr C'THIntTensor -> IO (Ptr C'THLongStorage) +c_newSizeOf = const c_newSizeOf_ + +-- | c_newStrideOf : self -> THLongStorage * +foreign import ccall "THTensor.h THIntTensor_newStrideOf" + c_newStrideOf_ :: Ptr C'THIntTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newStrideOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newStrideOf :: Ptr C'THState -> Ptr C'THIntTensor -> IO (Ptr C'THLongStorage) +c_newStrideOf = const c_newStrideOf_ + +-- | c_data : self -> real * +foreign import ccall "THTensor.h THIntTensor_data" + c_data_ :: Ptr C'THIntTensor -> IO (Ptr CInt) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THIntTensor -> IO (Ptr CInt) +c_data = const c_data_ + +-- | c_setFlag : self flag -> void +foreign import ccall "THTensor.h THIntTensor_setFlag" + c_setFlag_ :: Ptr C'THIntTensor -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THIntTensor -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : self flag -> void +foreign import ccall "THTensor.h THIntTensor_clearFlag" + c_clearFlag_ :: Ptr C'THIntTensor -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THIntTensor -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_new : -> THTensor * +foreign import ccall "THTensor.h THIntTensor_new" + c_new_ :: IO (Ptr C'THIntTensor) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THIntTensor) +c_new = const c_new_ + +-- | c_newWithTensor : tensor -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithTensor" + c_newWithTensor_ :: Ptr C'THIntTensor -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithTensor :: Ptr C'THState -> Ptr C'THIntTensor -> IO (Ptr C'THIntTensor) +c_newWithTensor = const c_newWithTensor_ + +-- | c_newWithStorage : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithStorage" + c_newWithStorage_ :: Ptr C'THIntStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage :: Ptr C'THState -> Ptr C'THIntStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor) +c_newWithStorage = const c_newWithStorage_ + +-- | c_newWithStorage1d : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithStorage1d" + c_newWithStorage1d_ :: Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage1d :: Ptr C'THState -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) +c_newWithStorage1d = const c_newWithStorage1d_ + +-- | c_newWithStorage2d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithStorage2d" + c_newWithStorage2d_ :: Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage2d :: Ptr C'THState -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) +c_newWithStorage2d = const c_newWithStorage2d_ + +-- | c_newWithStorage3d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithStorage3d" + c_newWithStorage3d_ :: Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage3d :: Ptr C'THState -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) +c_newWithStorage3d = const c_newWithStorage3d_ + +-- | c_newWithStorage4d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithStorage4d" + c_newWithStorage4d_ :: Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage4d :: Ptr C'THState -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) +c_newWithStorage4d = const c_newWithStorage4d_ + +-- | c_newWithSize : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithSize" + c_newWithSize_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1d : size0_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithSize1d" + c_newWithSize1d_ :: CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithSize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1d :: Ptr C'THState -> CLLong -> IO (Ptr C'THIntTensor) +c_newWithSize1d = const c_newWithSize1d_ + +-- | c_newWithSize2d : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithSize2d" + c_newWithSize2d_ :: CLLong -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithSize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2d :: Ptr C'THState -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) +c_newWithSize2d = const c_newWithSize2d_ + +-- | c_newWithSize3d : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithSize3d" + c_newWithSize3d_ :: CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithSize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) +c_newWithSize3d = const c_newWithSize3d_ + +-- | c_newWithSize4d : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newWithSize4d" + c_newWithSize4d_ :: CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newWithSize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) +c_newWithSize4d = const c_newWithSize4d_ + +-- | c_newClone : self -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newClone" + c_newClone_ :: Ptr C'THIntTensor -> IO (Ptr C'THIntTensor) + +-- | alias of c_newClone_ with unused argument (for CTHState) to unify backpack signatures. +c_newClone :: Ptr C'THState -> Ptr C'THIntTensor -> IO (Ptr C'THIntTensor) +c_newClone = const c_newClone_ + +-- | c_newContiguous : tensor -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newContiguous" + c_newContiguous_ :: Ptr C'THIntTensor -> IO (Ptr C'THIntTensor) + +-- | alias of c_newContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_newContiguous :: Ptr C'THState -> Ptr C'THIntTensor -> IO (Ptr C'THIntTensor) +c_newContiguous = const c_newContiguous_ + +-- | c_newSelect : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newSelect" + c_newSelect_ :: Ptr C'THIntTensor -> CInt -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_newSelect :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CLLong -> IO (Ptr C'THIntTensor) +c_newSelect = const c_newSelect_ + +-- | c_newNarrow : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newNarrow" + c_newNarrow_ :: Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newNarrow_ with unused argument (for CTHState) to unify backpack signatures. +c_newNarrow :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) +c_newNarrow = const c_newNarrow_ + +-- | c_newTranspose : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newTranspose" + c_newTranspose_ :: Ptr C'THIntTensor -> CInt -> CInt -> IO (Ptr C'THIntTensor) + +-- | alias of c_newTranspose_ with unused argument (for CTHState) to unify backpack signatures. +c_newTranspose :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> IO (Ptr C'THIntTensor) +c_newTranspose = const c_newTranspose_ + +-- | c_newUnfold : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newUnfold" + c_newUnfold_ :: Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) + +-- | alias of c_newUnfold_ with unused argument (for CTHState) to unify backpack signatures. +c_newUnfold :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THIntTensor) +c_newUnfold = const c_newUnfold_ + +-- | c_newView : tensor size -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newView" + c_newView_ :: Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor) + +-- | alias of c_newView_ with unused argument (for CTHState) to unify backpack signatures. +c_newView :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor) +c_newView = const c_newView_ + +-- | c_newExpand : tensor size -> THTensor * +foreign import ccall "THTensor.h THIntTensor_newExpand" + c_newExpand_ :: Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor) + +-- | alias of c_newExpand_ with unused argument (for CTHState) to unify backpack signatures. +c_newExpand :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor) +c_newExpand = const c_newExpand_ + +-- | c_expand : r tensor size -> void +foreign import ccall "THTensor.h THIntTensor_expand" + c_expand_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_expand_ with unused argument (for CTHState) to unify backpack signatures. +c_expand :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO () +c_expand = const c_expand_ + +-- | c_expandNd : rets ops count -> void +foreign import ccall "THTensor.h THIntTensor_expandNd" + c_expandNd_ :: Ptr (Ptr C'THIntTensor) -> Ptr (Ptr C'THIntTensor) -> CInt -> IO () + +-- | alias of c_expandNd_ with unused argument (for CTHState) to unify backpack signatures. +c_expandNd :: Ptr C'THState -> Ptr (Ptr C'THIntTensor) -> Ptr (Ptr C'THIntTensor) -> CInt -> IO () +c_expandNd = const c_expandNd_ + +-- | c_resize : tensor size stride -> void +foreign import ccall "THTensor.h THIntTensor_resize" + c_resize_ :: Ptr C'THIntTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_resize = const c_resize_ + +-- | c_resizeAs : tensor src -> void +foreign import ccall "THTensor.h THIntTensor_resizeAs" + c_resizeAs_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_resizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeAs :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_resizeAs = const c_resizeAs_ + +-- | c_resizeNd : tensor nDimension size stride -> void +foreign import ccall "THTensor.h THIntTensor_resizeNd" + c_resizeNd_ :: Ptr C'THIntTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_resizeNd_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeNd :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_resizeNd = const c_resizeNd_ + +-- | c_resize1d : tensor size0_ -> void +foreign import ccall "THTensor.h THIntTensor_resize1d" + c_resize1d_ :: Ptr C'THIntTensor -> CLLong -> IO () + +-- | alias of c_resize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize1d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> IO () +c_resize1d = const c_resize1d_ + +-- | c_resize2d : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h THIntTensor_resize2d" + c_resize2d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_resize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize2d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> IO () +c_resize2d = const c_resize2d_ + +-- | c_resize3d : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h THIntTensor_resize3d" + c_resize3d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize3d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> IO () +c_resize3d = const c_resize3d_ + +-- | c_resize4d : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h THIntTensor_resize4d" + c_resize4d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize4d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize4d = const c_resize4d_ + +-- | c_resize5d : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h THIntTensor_resize5d" + c_resize5d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize5d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize5d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize5d = const c_resize5d_ + +-- | c_set : self src -> void +foreign import ccall "THTensor.h THIntTensor_set" + c_set_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_set = const c_set_ + +-- | c_setStorage : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h THIntTensor_setStorage" + c_setStorage_ :: Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_setStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_setStorage = const c_setStorage_ + +-- | c_setStorageNd : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h THIntTensor_setStorageNd" + c_setStorageNd_ :: Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_setStorageNd_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorageNd :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_setStorageNd = const c_setStorageNd_ + +-- | c_setStorage1d : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h THIntTensor_setStorage1d" + c_setStorage1d_ :: Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage1d :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> IO () +c_setStorage1d = const c_setStorage1d_ + +-- | c_setStorage2d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h THIntTensor_setStorage2d" + c_setStorage2d_ :: Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage2d :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage2d = const c_setStorage2d_ + +-- | c_setStorage3d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h THIntTensor_setStorage3d" + c_setStorage3d_ :: Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage3d :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage3d = const c_setStorage3d_ + +-- | c_setStorage4d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h THIntTensor_setStorage4d" + c_setStorage4d_ :: Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage4d :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage4d = const c_setStorage4d_ + +-- | c_narrow : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h THIntTensor_narrow" + c_narrow_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_narrow_ with unused argument (for CTHState) to unify backpack signatures. +c_narrow :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO () +c_narrow = const c_narrow_ + +-- | c_select : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h THIntTensor_select" + c_select_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CLLong -> IO () + +-- | alias of c_select_ with unused argument (for CTHState) to unify backpack signatures. +c_select :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CLLong -> IO () +c_select = const c_select_ + +-- | c_transpose : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h THIntTensor_transpose" + c_transpose_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_transpose_ with unused argument (for CTHState) to unify backpack signatures. +c_transpose :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_transpose = const c_transpose_ + +-- | c_unfold : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h THIntTensor_unfold" + c_unfold_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_unfold_ with unused argument (for CTHState) to unify backpack signatures. +c_unfold :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO () +c_unfold = const c_unfold_ + +-- | c_squeeze : self src -> void +foreign import ccall "THTensor.h THIntTensor_squeeze" + c_squeeze_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_squeeze_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_squeeze = const c_squeeze_ + +-- | c_squeeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THIntTensor_squeeze1d" + c_squeeze1d_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_squeeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze1d :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_squeeze1d = const c_squeeze1d_ + +-- | c_unsqueeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THIntTensor_unsqueeze1d" + c_unsqueeze1d_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_unsqueeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_unsqueeze1d :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_unsqueeze1d = const c_unsqueeze1d_ + +-- | c_isContiguous : self -> int +foreign import ccall "THTensor.h THIntTensor_isContiguous" + c_isContiguous_ :: Ptr C'THIntTensor -> IO CInt + +-- | alias of c_isContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_isContiguous :: Ptr C'THState -> Ptr C'THIntTensor -> IO CInt +c_isContiguous = const c_isContiguous_ + +-- | c_isSameSizeAs : self src -> int +foreign import ccall "THTensor.h THIntTensor_isSameSizeAs" + c_isSameSizeAs_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CInt + +-- | alias of c_isSameSizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_isSameSizeAs :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CInt +c_isSameSizeAs = const c_isSameSizeAs_ + +-- | c_isSetTo : self src -> int +foreign import ccall "THTensor.h THIntTensor_isSetTo" + c_isSetTo_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CInt + +-- | alias of c_isSetTo_ with unused argument (for CTHState) to unify backpack signatures. +c_isSetTo :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CInt +c_isSetTo = const c_isSetTo_ + +-- | c_isSize : self dims -> int +foreign import ccall "THTensor.h THIntTensor_isSize" + c_isSize_ :: Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO CInt + +-- | alias of c_isSize_ with unused argument (for CTHState) to unify backpack signatures. +c_isSize :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO CInt +c_isSize = const c_isSize_ + +-- | c_nElement : self -> ptrdiff_t +foreign import ccall "THTensor.h THIntTensor_nElement" + c_nElement_ :: Ptr C'THIntTensor -> IO CPtrdiff + +-- | alias of c_nElement_ with unused argument (for CTHState) to unify backpack signatures. +c_nElement :: Ptr C'THState -> Ptr C'THIntTensor -> IO CPtrdiff +c_nElement = const c_nElement_ + +-- | c_retain : self -> void +foreign import ccall "THTensor.h THIntTensor_retain" + c_retain_ :: Ptr C'THIntTensor -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THIntTensor -> IO () +c_retain = const c_retain_ + +-- | c_free : self -> void +foreign import ccall "THTensor.h THIntTensor_free" + c_free_ :: Ptr C'THIntTensor -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THIntTensor -> IO () +c_free = const c_free_ + +-- | c_freeCopyTo : self dst -> void +foreign import ccall "THTensor.h THIntTensor_freeCopyTo" + c_freeCopyTo_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_freeCopyTo_ with unused argument (for CTHState) to unify backpack signatures. +c_freeCopyTo :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_freeCopyTo = const c_freeCopyTo_ + +-- | c_set1d : tensor x0 value -> void +foreign import ccall "THTensor.h THIntTensor_set1d" + c_set1d_ :: Ptr C'THIntTensor -> CLLong -> CInt -> IO () + +-- | alias of c_set1d_ with unused argument (for CTHState) to unify backpack signatures. +c_set1d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CInt -> IO () +c_set1d = const c_set1d_ + +-- | c_set2d : tensor x0 x1 value -> void +foreign import ccall "THTensor.h THIntTensor_set2d" + c_set2d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> CInt -> IO () + +-- | alias of c_set2d_ with unused argument (for CTHState) to unify backpack signatures. +c_set2d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> CInt -> IO () +c_set2d = const c_set2d_ + +-- | c_set3d : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h THIntTensor_set3d" + c_set3d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CInt -> IO () + +-- | alias of c_set3d_ with unused argument (for CTHState) to unify backpack signatures. +c_set3d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CInt -> IO () +c_set3d = const c_set3d_ + +-- | c_set4d : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h THIntTensor_set4d" + c_set4d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CInt -> IO () + +-- | alias of c_set4d_ with unused argument (for CTHState) to unify backpack signatures. +c_set4d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CInt -> IO () +c_set4d = const c_set4d_ + +-- | c_get1d : tensor x0 -> real +foreign import ccall "THTensor.h THIntTensor_get1d" + c_get1d_ :: Ptr C'THIntTensor -> CLLong -> IO CInt + +-- | alias of c_get1d_ with unused argument (for CTHState) to unify backpack signatures. +c_get1d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> IO CInt +c_get1d = const c_get1d_ + +-- | c_get2d : tensor x0 x1 -> real +foreign import ccall "THTensor.h THIntTensor_get2d" + c_get2d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> IO CInt + +-- | alias of c_get2d_ with unused argument (for CTHState) to unify backpack signatures. +c_get2d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> IO CInt +c_get2d = const c_get2d_ + +-- | c_get3d : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h THIntTensor_get3d" + c_get3d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> IO CInt + +-- | alias of c_get3d_ with unused argument (for CTHState) to unify backpack signatures. +c_get3d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> IO CInt +c_get3d = const c_get3d_ + +-- | c_get4d : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h THIntTensor_get4d" + c_get4d_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CInt + +-- | alias of c_get4d_ with unused argument (for CTHState) to unify backpack signatures. +c_get4d :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CInt +c_get4d = const c_get4d_ + +-- | c_desc : tensor -> THDescBuff +foreign import ccall "THTensor.h THIntTensor_desc" + c_desc_ :: Ptr C'THIntTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_desc_ with unused argument (for CTHState) to unify backpack signatures. +c_desc :: Ptr C'THState -> Ptr C'THIntTensor -> IO (Ptr C'THDescBuff) +c_desc = const c_desc_ + +-- | c_sizeDesc : tensor -> THDescBuff +foreign import ccall "THTensor.h THIntTensor_sizeDesc" + c_sizeDesc_ :: Ptr C'THIntTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_sizeDesc_ with unused argument (for CTHState) to unify backpack signatures. +c_sizeDesc :: Ptr C'THState -> Ptr C'THIntTensor -> IO (Ptr C'THDescBuff) +c_sizeDesc = const c_sizeDesc_ + +-- | p_storage : Pointer to function : self -> THStorage * +foreign import ccall "THTensor.h &THIntTensor_storage" + p_storage :: FunPtr (Ptr C'THIntTensor -> IO (Ptr C'THIntStorage)) + +-- | p_storageOffset : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THIntTensor_storageOffset" + p_storageOffset :: FunPtr (Ptr C'THIntTensor -> IO CPtrdiff) + +-- | p_nDimension : Pointer to function : self -> int +foreign import ccall "THTensor.h &THIntTensor_nDimension" + p_nDimension :: FunPtr (Ptr C'THIntTensor -> IO CInt) + +-- | p_size : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THIntTensor_size" + p_size :: FunPtr (Ptr C'THIntTensor -> CInt -> IO CLLong) + +-- | p_stride : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THIntTensor_stride" + p_stride :: FunPtr (Ptr C'THIntTensor -> CInt -> IO CLLong) + +-- | p_newSizeOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THIntTensor_newSizeOf" + p_newSizeOf :: FunPtr (Ptr C'THIntTensor -> IO (Ptr C'THLongStorage)) + +-- | p_newStrideOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THIntTensor_newStrideOf" + p_newStrideOf :: FunPtr (Ptr C'THIntTensor -> IO (Ptr C'THLongStorage)) + +-- | p_data : Pointer to function : self -> real * +foreign import ccall "THTensor.h &THIntTensor_data" + p_data :: FunPtr (Ptr C'THIntTensor -> IO (Ptr CInt)) + +-- | p_setFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THIntTensor_setFlag" + p_setFlag :: FunPtr (Ptr C'THIntTensor -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THIntTensor_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THIntTensor -> CChar -> IO ()) + +-- | p_new : Pointer to function : -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_new" + p_new :: FunPtr (IO (Ptr C'THIntTensor)) + +-- | p_newWithTensor : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithTensor" + p_newWithTensor :: FunPtr (Ptr C'THIntTensor -> IO (Ptr C'THIntTensor)) + +-- | p_newWithStorage : Pointer to function : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithStorage" + p_newWithStorage :: FunPtr (Ptr C'THIntStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor)) + +-- | p_newWithStorage1d : Pointer to function : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithStorage1d" + p_newWithStorage1d :: FunPtr (Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newWithStorage2d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithStorage2d" + p_newWithStorage2d :: FunPtr (Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newWithStorage3d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithStorage3d" + p_newWithStorage3d :: FunPtr (Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newWithStorage4d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithStorage4d" + p_newWithStorage4d :: FunPtr (Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newWithSize : Pointer to function : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithSize" + p_newWithSize :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor)) + +-- | p_newWithSize1d : Pointer to function : size0_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithSize1d" + p_newWithSize1d :: FunPtr (CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newWithSize2d : Pointer to function : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithSize2d" + p_newWithSize2d :: FunPtr (CLLong -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newWithSize3d : Pointer to function : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithSize3d" + p_newWithSize3d :: FunPtr (CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newWithSize4d : Pointer to function : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newWithSize4d" + p_newWithSize4d :: FunPtr (CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newClone : Pointer to function : self -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newClone" + p_newClone :: FunPtr (Ptr C'THIntTensor -> IO (Ptr C'THIntTensor)) + +-- | p_newContiguous : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newContiguous" + p_newContiguous :: FunPtr (Ptr C'THIntTensor -> IO (Ptr C'THIntTensor)) + +-- | p_newSelect : Pointer to function : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newSelect" + p_newSelect :: FunPtr (Ptr C'THIntTensor -> CInt -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newNarrow : Pointer to function : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newNarrow" + p_newNarrow :: FunPtr (Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newTranspose : Pointer to function : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newTranspose" + p_newTranspose :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> IO (Ptr C'THIntTensor)) + +-- | p_newUnfold : Pointer to function : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newUnfold" + p_newUnfold :: FunPtr (Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THIntTensor)) + +-- | p_newView : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newView" + p_newView :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor)) + +-- | p_newExpand : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THIntTensor_newExpand" + p_newExpand :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO (Ptr C'THIntTensor)) + +-- | p_expand : Pointer to function : r tensor size -> void +foreign import ccall "THTensor.h &THIntTensor_expand" + p_expand :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_expandNd : Pointer to function : rets ops count -> void +foreign import ccall "THTensor.h &THIntTensor_expandNd" + p_expandNd :: FunPtr (Ptr (Ptr C'THIntTensor) -> Ptr (Ptr C'THIntTensor) -> CInt -> IO ()) + +-- | p_resize : Pointer to function : tensor size stride -> void +foreign import ccall "THTensor.h &THIntTensor_resize" + p_resize :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_resizeAs : Pointer to function : tensor src -> void +foreign import ccall "THTensor.h &THIntTensor_resizeAs" + p_resizeAs :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_resizeNd : Pointer to function : tensor nDimension size stride -> void +foreign import ccall "THTensor.h &THIntTensor_resizeNd" + p_resizeNd :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_resize1d : Pointer to function : tensor size0_ -> void +foreign import ccall "THTensor.h &THIntTensor_resize1d" + p_resize1d :: FunPtr (Ptr C'THIntTensor -> CLLong -> IO ()) + +-- | p_resize2d : Pointer to function : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h &THIntTensor_resize2d" + p_resize2d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> IO ()) + +-- | p_resize3d : Pointer to function : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h &THIntTensor_resize3d" + p_resize3d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize4d : Pointer to function : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h &THIntTensor_resize4d" + p_resize4d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize5d : Pointer to function : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h &THIntTensor_resize5d" + p_resize5d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_set : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THIntTensor_set" + p_set :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_setStorage : Pointer to function : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h &THIntTensor_setStorage" + p_setStorage :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_setStorageNd : Pointer to function : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h &THIntTensor_setStorageNd" + p_setStorageNd :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_setStorage1d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h &THIntTensor_setStorage1d" + p_setStorage1d :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage2d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h &THIntTensor_setStorage2d" + p_setStorage2d :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage3d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h &THIntTensor_setStorage3d" + p_setStorage3d :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage4d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h &THIntTensor_setStorage4d" + p_setStorage4d :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_narrow : Pointer to function : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h &THIntTensor_narrow" + p_narrow :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_select : Pointer to function : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h &THIntTensor_select" + p_select :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CLLong -> IO ()) + +-- | p_transpose : Pointer to function : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h &THIntTensor_transpose" + p_transpose :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_unfold : Pointer to function : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h &THIntTensor_unfold" + p_unfold :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_squeeze : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THIntTensor_squeeze" + p_squeeze :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_squeeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THIntTensor_squeeze1d" + p_squeeze1d :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_unsqueeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THIntTensor_unsqueeze1d" + p_unsqueeze1d :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_isContiguous : Pointer to function : self -> int +foreign import ccall "THTensor.h &THIntTensor_isContiguous" + p_isContiguous :: FunPtr (Ptr C'THIntTensor -> IO CInt) + +-- | p_isSameSizeAs : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THIntTensor_isSameSizeAs" + p_isSameSizeAs :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CInt) + +-- | p_isSetTo : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THIntTensor_isSetTo" + p_isSetTo :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CInt) + +-- | p_isSize : Pointer to function : self dims -> int +foreign import ccall "THTensor.h &THIntTensor_isSize" + p_isSize :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO CInt) + +-- | p_nElement : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THIntTensor_nElement" + p_nElement :: FunPtr (Ptr C'THIntTensor -> IO CPtrdiff) + +-- | p_retain : Pointer to function : self -> void +foreign import ccall "THTensor.h &THIntTensor_retain" + p_retain :: FunPtr (Ptr C'THIntTensor -> IO ()) + +-- | p_free : Pointer to function : self -> void +foreign import ccall "THTensor.h &THIntTensor_free" + p_free :: FunPtr (Ptr C'THIntTensor -> IO ()) + +-- | p_freeCopyTo : Pointer to function : self dst -> void +foreign import ccall "THTensor.h &THIntTensor_freeCopyTo" + p_freeCopyTo :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_set1d : Pointer to function : tensor x0 value -> void +foreign import ccall "THTensor.h &THIntTensor_set1d" + p_set1d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CInt -> IO ()) + +-- | p_set2d : Pointer to function : tensor x0 x1 value -> void +foreign import ccall "THTensor.h &THIntTensor_set2d" + p_set2d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> CInt -> IO ()) + +-- | p_set3d : Pointer to function : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h &THIntTensor_set3d" + p_set3d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CInt -> IO ()) + +-- | p_set4d : Pointer to function : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h &THIntTensor_set4d" + p_set4d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CInt -> IO ()) + +-- | p_get1d : Pointer to function : tensor x0 -> real +foreign import ccall "THTensor.h &THIntTensor_get1d" + p_get1d :: FunPtr (Ptr C'THIntTensor -> CLLong -> IO CInt) + +-- | p_get2d : Pointer to function : tensor x0 x1 -> real +foreign import ccall "THTensor.h &THIntTensor_get2d" + p_get2d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> IO CInt) + +-- | p_get3d : Pointer to function : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h &THIntTensor_get3d" + p_get3d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> IO CInt) + +-- | p_get4d : Pointer to function : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h &THIntTensor_get4d" + p_get4d :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CInt) + +-- | p_desc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THIntTensor_desc" + p_desc :: FunPtr (Ptr C'THIntTensor -> IO (Ptr C'THDescBuff)) + +-- | p_sizeDesc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THIntTensor_sizeDesc" + p_sizeDesc :: FunPtr (Ptr C'THIntTensor -> IO (Ptr C'THDescBuff)) diff --git a/src/Torch/FFI/TH/Int/TensorConv.hs b/src/Torch/FFI/TH/Int/TensorConv.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Int/TensorConv.hs @@ -0,0 +1,272 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.TensorConv where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_validXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_validXCorr2Dptr" + c_validXCorr2Dptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2Dptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2Dptr = const c_validXCorr2Dptr_ + +-- | c_validConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_validConv2Dptr" + c_validConv2Dptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv2Dptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv2Dptr = const c_validConv2Dptr_ + +-- | c_fullXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_fullXCorr2Dptr" + c_fullXCorr2Dptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr2Dptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr2Dptr = const c_fullXCorr2Dptr_ + +-- | c_fullConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_fullConv2Dptr" + c_fullConv2Dptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv2Dptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv2Dptr = const c_fullConv2Dptr_ + +-- | c_validXCorr2DRevptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_validXCorr2DRevptr" + c_validXCorr2DRevptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2DRevptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2DRevptr = const c_validXCorr2DRevptr_ + +-- | c_conv2DRevger : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THIntTensor_conv2DRevger" + c_conv2DRevger_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevger :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> IO () +c_conv2DRevger = const c_conv2DRevger_ + +-- | c_conv2DRevgerm : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THIntTensor_conv2DRevgerm" + c_conv2DRevgerm_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevgerm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevgerm :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> IO () +c_conv2DRevgerm = const c_conv2DRevgerm_ + +-- | c_conv2Dger : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THIntTensor_conv2Dger" + c_conv2Dger_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dger :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dger = const c_conv2Dger_ + +-- | c_conv2Dmv : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THIntTensor_conv2Dmv" + c_conv2Dmv_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmv :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmv = const c_conv2Dmv_ + +-- | c_conv2Dmm : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THIntTensor_conv2Dmm" + c_conv2Dmm_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmm :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmm = const c_conv2Dmm_ + +-- | c_conv2Dmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THIntTensor_conv2Dmul" + c_conv2Dmul_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmul :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmul = const c_conv2Dmul_ + +-- | c_conv2Dcmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THIntTensor_conv2Dcmul" + c_conv2Dcmul_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dcmul :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dcmul = const c_conv2Dcmul_ + +-- | c_validXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_validXCorr3Dptr" + c_validXCorr3Dptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3Dptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3Dptr = const c_validXCorr3Dptr_ + +-- | c_validConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_validConv3Dptr" + c_validConv3Dptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv3Dptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv3Dptr = const c_validConv3Dptr_ + +-- | c_fullXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_fullXCorr3Dptr" + c_fullXCorr3Dptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr3Dptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr3Dptr = const c_fullXCorr3Dptr_ + +-- | c_fullConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_fullConv3Dptr" + c_fullConv3Dptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv3Dptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv3Dptr = const c_fullConv3Dptr_ + +-- | c_validXCorr3DRevptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THIntTensor_validXCorr3DRevptr" + c_validXCorr3DRevptr_ :: Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3DRevptr :: Ptr C'THState -> Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3DRevptr = const c_validXCorr3DRevptr_ + +-- | c_conv3DRevger : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h THIntTensor_conv3DRevger" + c_conv3DRevger_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_conv3DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3DRevger :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> IO () +c_conv3DRevger = const c_conv3DRevger_ + +-- | c_conv3Dger : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THIntTensor_conv3Dger" + c_conv3Dger_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dger :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dger = const c_conv3Dger_ + +-- | c_conv3Dmv : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THIntTensor_conv3Dmv" + c_conv3Dmv_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmv :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmv = const c_conv3Dmv_ + +-- | c_conv3Dmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THIntTensor_conv3Dmul" + c_conv3Dmul_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmul :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmul = const c_conv3Dmul_ + +-- | c_conv3Dcmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THIntTensor_conv3Dcmul" + c_conv3Dcmul_ :: Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dcmul :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dcmul = const c_conv3Dcmul_ + +-- | p_validXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_validXCorr2Dptr" + p_validXCorr2Dptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_validConv2Dptr" + p_validConv2Dptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_fullXCorr2Dptr" + p_fullXCorr2Dptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_fullConv2Dptr" + p_fullConv2Dptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr2DRevptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_validXCorr2DRevptr" + p_validXCorr2DRevptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevger : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv2DRevger" + p_conv2DRevger :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevgerm : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv2DRevgerm" + p_conv2DRevgerm :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2Dger : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv2Dger" + p_conv2Dger :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmv : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv2Dmv" + p_conv2Dmv :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmm : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv2Dmm" + p_conv2Dmm :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv2Dmul" + p_conv2Dmul :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dcmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv2Dcmul" + p_conv2Dcmul :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_validXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_validXCorr3Dptr" + p_validXCorr3Dptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_validConv3Dptr" + p_validConv3Dptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_fullXCorr3Dptr" + p_fullXCorr3Dptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_fullConv3Dptr" + p_fullConv3Dptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr3DRevptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THIntTensor_validXCorr3DRevptr" + p_validXCorr3DRevptr :: FunPtr (Ptr CInt -> CInt -> Ptr CInt -> CLLong -> CLLong -> CLLong -> Ptr CInt -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3DRevger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv3DRevger" + p_conv3DRevger :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3Dger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv3Dger" + p_conv3Dger :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmv : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv3Dmv" + p_conv3Dmv :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv3Dmul" + p_conv3Dmul :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dcmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THIntTensor_conv3Dcmul" + p_conv3Dcmul :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) diff --git a/src/Torch/FFI/TH/Int/TensorCopy.hs b/src/Torch/FFI/TH/Int/TensorCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Int/TensorCopy.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.TensorCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_copy : tensor src -> void +foreign import ccall "THTensorCopy.h THIntTensor_copy" + c_copy_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : tensor src -> void +foreign import ccall "THTensorCopy.h THIntTensor_copyByte" + c_copyByte_ :: Ptr C'THIntTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THByteTensor -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : tensor src -> void +foreign import ccall "THTensorCopy.h THIntTensor_copyChar" + c_copyChar_ :: Ptr C'THIntTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THCharTensor -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : tensor src -> void +foreign import ccall "THTensorCopy.h THIntTensor_copyShort" + c_copyShort_ :: Ptr C'THIntTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THShortTensor -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : tensor src -> void +foreign import ccall "THTensorCopy.h THIntTensor_copyInt" + c_copyInt_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : tensor src -> void +foreign import ccall "THTensorCopy.h THIntTensor_copyLong" + c_copyLong_ :: Ptr C'THIntTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : tensor src -> void +foreign import ccall "THTensorCopy.h THIntTensor_copyFloat" + c_copyFloat_ :: Ptr C'THIntTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THFloatTensor -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : tensor src -> void +foreign import ccall "THTensorCopy.h THIntTensor_copyDouble" + c_copyDouble_ :: Ptr C'THIntTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THDoubleTensor -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : tensor src -> void +foreign import ccall "THTensorCopy.h THIntTensor_copyHalf" + c_copyHalf_ :: Ptr C'THIntTensor -> Ptr C'THHalfTensor -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THHalfTensor -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_copy : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THIntTensor_copy" + p_copy :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_copyByte : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THIntTensor_copyByte" + p_copyByte :: FunPtr (Ptr C'THIntTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_copyChar : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THIntTensor_copyChar" + p_copyChar :: FunPtr (Ptr C'THIntTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_copyShort : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THIntTensor_copyShort" + p_copyShort :: FunPtr (Ptr C'THIntTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_copyInt : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THIntTensor_copyInt" + p_copyInt :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_copyLong : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THIntTensor_copyLong" + p_copyLong :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_copyFloat : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THIntTensor_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THIntTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_copyDouble : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THIntTensor_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THIntTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_copyHalf : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THIntTensor_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THIntTensor -> Ptr C'THHalfTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Int/TensorMath.hs b/src/Torch/FFI/TH/Int/TensorMath.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Int/TensorMath.hs @@ -0,0 +1,1412 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.TensorMath where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : r_ value -> void +foreign import ccall "THTensorMath.h THIntTensor_fill" + c_fill_ :: Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> IO () +c_fill = const c_fill_ + +-- | c_zero : r_ -> void +foreign import ccall "THTensorMath.h THIntTensor_zero" + c_zero_ :: Ptr C'THIntTensor -> IO () + +-- | alias of c_zero_ with unused argument (for CTHState) to unify backpack signatures. +c_zero :: Ptr C'THState -> Ptr C'THIntTensor -> IO () +c_zero = const c_zero_ + +-- | c_maskedFill : tensor mask value -> void +foreign import ccall "THTensorMath.h THIntTensor_maskedFill" + c_maskedFill_ :: Ptr C'THIntTensor -> Ptr C'THByteTensor -> CInt -> IO () + +-- | alias of c_maskedFill_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedFill :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THByteTensor -> CInt -> IO () +c_maskedFill = const c_maskedFill_ + +-- | c_maskedCopy : tensor mask src -> void +foreign import ccall "THTensorMath.h THIntTensor_maskedCopy" + c_maskedCopy_ :: Ptr C'THIntTensor -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_maskedCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedCopy :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> IO () +c_maskedCopy = const c_maskedCopy_ + +-- | c_maskedSelect : tensor src mask -> void +foreign import ccall "THTensorMath.h THIntTensor_maskedSelect" + c_maskedSelect_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_maskedSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedSelect :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THByteTensor -> IO () +c_maskedSelect = const c_maskedSelect_ + +-- | c_nonzero : subscript tensor -> void +foreign import ccall "THTensorMath.h THIntTensor_nonzero" + c_nonzero_ :: Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_nonzero_ with unused argument (for CTHState) to unify backpack signatures. +c_nonzero :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () +c_nonzero = const c_nonzero_ + +-- | c_indexSelect : tensor src dim index -> void +foreign import ccall "THTensorMath.h THIntTensor_indexSelect" + c_indexSelect_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_indexSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_indexSelect :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_indexSelect = const c_indexSelect_ + +-- | c_indexCopy : tensor dim index src -> void +foreign import ccall "THTensorMath.h THIntTensor_indexCopy" + c_indexCopy_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_indexCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_indexCopy :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () +c_indexCopy = const c_indexCopy_ + +-- | c_indexAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THIntTensor_indexAdd" + c_indexAdd_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_indexAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_indexAdd :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () +c_indexAdd = const c_indexAdd_ + +-- | c_indexFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THIntTensor_indexFill" + c_indexFill_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_indexFill_ with unused argument (for CTHState) to unify backpack signatures. +c_indexFill :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> CInt -> IO () +c_indexFill = const c_indexFill_ + +-- | c_take : tensor src index -> void +foreign import ccall "THTensorMath.h THIntTensor_take" + c_take_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_take_ with unused argument (for CTHState) to unify backpack signatures. +c_take :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> IO () +c_take = const c_take_ + +-- | c_put : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h THIntTensor_put" + c_put_ :: Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_put_ with unused argument (for CTHState) to unify backpack signatures. +c_put :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_put = const c_put_ + +-- | c_gather : tensor src dim index -> void +foreign import ccall "THTensorMath.h THIntTensor_gather" + c_gather_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_gather_ with unused argument (for CTHState) to unify backpack signatures. +c_gather :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_gather = const c_gather_ + +-- | c_scatter : tensor dim index src -> void +foreign import ccall "THTensorMath.h THIntTensor_scatter" + c_scatter_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_scatter_ with unused argument (for CTHState) to unify backpack signatures. +c_scatter :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () +c_scatter = const c_scatter_ + +-- | c_scatterAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THIntTensor_scatterAdd" + c_scatterAdd_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_scatterAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterAdd :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () +c_scatterAdd = const c_scatterAdd_ + +-- | c_scatterFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THIntTensor_scatterFill" + c_scatterFill_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_scatterFill_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterFill :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> CInt -> IO () +c_scatterFill = const c_scatterFill_ + +-- | c_dot : t src -> accreal +foreign import ccall "THTensorMath.h THIntTensor_dot" + c_dot_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CLong + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CLong +c_dot = const c_dot_ + +-- | c_minall : t -> real +foreign import ccall "THTensorMath.h THIntTensor_minall" + c_minall_ :: Ptr C'THIntTensor -> IO CInt + +-- | alias of c_minall_ with unused argument (for CTHState) to unify backpack signatures. +c_minall :: Ptr C'THState -> Ptr C'THIntTensor -> IO CInt +c_minall = const c_minall_ + +-- | c_maxall : t -> real +foreign import ccall "THTensorMath.h THIntTensor_maxall" + c_maxall_ :: Ptr C'THIntTensor -> IO CInt + +-- | alias of c_maxall_ with unused argument (for CTHState) to unify backpack signatures. +c_maxall :: Ptr C'THState -> Ptr C'THIntTensor -> IO CInt +c_maxall = const c_maxall_ + +-- | c_medianall : t -> real +foreign import ccall "THTensorMath.h THIntTensor_medianall" + c_medianall_ :: Ptr C'THIntTensor -> IO CInt + +-- | alias of c_medianall_ with unused argument (for CTHState) to unify backpack signatures. +c_medianall :: Ptr C'THState -> Ptr C'THIntTensor -> IO CInt +c_medianall = const c_medianall_ + +-- | c_sumall : t -> accreal +foreign import ccall "THTensorMath.h THIntTensor_sumall" + c_sumall_ :: Ptr C'THIntTensor -> IO CLong + +-- | alias of c_sumall_ with unused argument (for CTHState) to unify backpack signatures. +c_sumall :: Ptr C'THState -> Ptr C'THIntTensor -> IO CLong +c_sumall = const c_sumall_ + +-- | c_prodall : t -> accreal +foreign import ccall "THTensorMath.h THIntTensor_prodall" + c_prodall_ :: Ptr C'THIntTensor -> IO CLong + +-- | alias of c_prodall_ with unused argument (for CTHState) to unify backpack signatures. +c_prodall :: Ptr C'THState -> Ptr C'THIntTensor -> IO CLong +c_prodall = const c_prodall_ + +-- | c_neg : self src -> void +foreign import ccall "THTensorMath.h THIntTensor_neg" + c_neg_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_neg = const c_neg_ + +-- | c_add : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_add" + c_add_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_add_ with unused argument (for CTHState) to unify backpack signatures. +c_add :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_add = const c_add_ + +-- | c_sub : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_sub" + c_sub_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_sub_ with unused argument (for CTHState) to unify backpack signatures. +c_sub :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_sub = const c_sub_ + +-- | c_add_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THIntTensor_add_scaled" + c_add_scaled_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_add_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_add_scaled :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_add_scaled = const c_add_scaled_ + +-- | c_sub_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THIntTensor_sub_scaled" + c_sub_scaled_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_sub_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_sub_scaled :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_sub_scaled = const c_sub_scaled_ + +-- | c_mul : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_mul" + c_mul_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_mul_ with unused argument (for CTHState) to unify backpack signatures. +c_mul :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_mul = const c_mul_ + +-- | c_div : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_div" + c_div_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_div_ with unused argument (for CTHState) to unify backpack signatures. +c_div :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_div = const c_div_ + +-- | c_lshift : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_lshift" + c_lshift_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_lshift_ with unused argument (for CTHState) to unify backpack signatures. +c_lshift :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_lshift = const c_lshift_ + +-- | c_rshift : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_rshift" + c_rshift_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_rshift_ with unused argument (for CTHState) to unify backpack signatures. +c_rshift :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_rshift = const c_rshift_ + +-- | c_fmod : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_fmod" + c_fmod_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_fmod_ with unused argument (for CTHState) to unify backpack signatures. +c_fmod :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_fmod = const c_fmod_ + +-- | c_remainder : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_remainder" + c_remainder_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_remainder_ with unused argument (for CTHState) to unify backpack signatures. +c_remainder :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_remainder = const c_remainder_ + +-- | c_clamp : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h THIntTensor_clamp" + c_clamp_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_clamp_ with unused argument (for CTHState) to unify backpack signatures. +c_clamp :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_clamp = const c_clamp_ + +-- | c_bitand : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_bitand" + c_bitand_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_bitand_ with unused argument (for CTHState) to unify backpack signatures. +c_bitand :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_bitand = const c_bitand_ + +-- | c_bitor : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_bitor" + c_bitor_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_bitor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitor :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_bitor = const c_bitor_ + +-- | c_bitxor : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_bitxor" + c_bitxor_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_bitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitxor :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_bitxor = const c_bitxor_ + +-- | c_cadd : r_ t value src -> void +foreign import ccall "THTensorMath.h THIntTensor_cadd" + c_cadd_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> IO () +c_cadd = const c_cadd_ + +-- | c_csub : self src1 value src2 -> void +foreign import ccall "THTensorMath.h THIntTensor_csub" + c_csub_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> IO () + +-- | alias of c_csub_ with unused argument (for CTHState) to unify backpack signatures. +c_csub :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> IO () +c_csub = const c_csub_ + +-- | c_cmul : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cmul" + c_cmul_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cmul = const c_cmul_ + +-- | c_cpow : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cpow" + c_cpow_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cpow_ with unused argument (for CTHState) to unify backpack signatures. +c_cpow :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cpow = const c_cpow_ + +-- | c_cdiv : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cdiv" + c_cdiv_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cdiv = const c_cdiv_ + +-- | c_clshift : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_clshift" + c_clshift_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_clshift_ with unused argument (for CTHState) to unify backpack signatures. +c_clshift :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_clshift = const c_clshift_ + +-- | c_crshift : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_crshift" + c_crshift_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_crshift_ with unused argument (for CTHState) to unify backpack signatures. +c_crshift :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_crshift = const c_crshift_ + +-- | c_cfmod : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cfmod" + c_cfmod_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cfmod_ with unused argument (for CTHState) to unify backpack signatures. +c_cfmod :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cfmod = const c_cfmod_ + +-- | c_cremainder : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cremainder" + c_cremainder_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cremainder_ with unused argument (for CTHState) to unify backpack signatures. +c_cremainder :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cremainder = const c_cremainder_ + +-- | c_cbitand : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cbitand" + c_cbitand_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cbitand_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitand :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cbitand = const c_cbitand_ + +-- | c_cbitor : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cbitor" + c_cbitor_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cbitor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitor :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cbitor = const c_cbitor_ + +-- | c_cbitxor : r_ t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cbitxor" + c_cbitxor_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cbitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitxor :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cbitxor = const c_cbitxor_ + +-- | c_addcmul : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THIntTensor_addcmul" + c_addcmul_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_addcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_addcmul :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_addcmul = const c_addcmul_ + +-- | c_addcdiv : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THIntTensor_addcdiv" + c_addcdiv_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_addcdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_addcdiv :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_addcdiv = const c_addcdiv_ + +-- | c_addmv : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h THIntTensor_addmv" + c_addmv_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_addmv_ with unused argument (for CTHState) to unify backpack signatures. +c_addmv :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_addmv = const c_addmv_ + +-- | c_addmm : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h THIntTensor_addmm" + c_addmm_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_addmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addmm :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_addmm = const c_addmm_ + +-- | c_addr : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h THIntTensor_addr" + c_addr_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_addr_ with unused argument (for CTHState) to unify backpack signatures. +c_addr :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_addr = const c_addr_ + +-- | c_addbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THIntTensor_addbmm" + c_addbmm_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_addbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addbmm :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_addbmm = const c_addbmm_ + +-- | c_baddbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THIntTensor_baddbmm" + c_baddbmm_ :: Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_baddbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_baddbmm :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_baddbmm = const c_baddbmm_ + +-- | c_match : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h THIntTensor_match" + c_match_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_match_ with unused argument (for CTHState) to unify backpack signatures. +c_match :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_match = const c_match_ + +-- | c_numel : t -> ptrdiff_t +foreign import ccall "THTensorMath.h THIntTensor_numel" + c_numel_ :: Ptr C'THIntTensor -> IO CPtrdiff + +-- | alias of c_numel_ with unused argument (for CTHState) to unify backpack signatures. +c_numel :: Ptr C'THState -> Ptr C'THIntTensor -> IO CPtrdiff +c_numel = const c_numel_ + +-- | c_preserveReduceDimSemantics : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h THIntTensor_preserveReduceDimSemantics" + c_preserveReduceDimSemantics_ :: Ptr C'THIntTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_preserveReduceDimSemantics_ with unused argument (for CTHState) to unify backpack signatures. +c_preserveReduceDimSemantics :: Ptr C'THState -> Ptr C'THIntTensor -> CInt -> CInt -> CInt -> IO () +c_preserveReduceDimSemantics = const c_preserveReduceDimSemantics_ + +-- | c_max : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THIntTensor_max" + c_max_ :: Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_max_ with unused argument (for CTHState) to unify backpack signatures. +c_max :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_max = const c_max_ + +-- | c_min : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THIntTensor_min" + c_min_ :: Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_min_ with unused argument (for CTHState) to unify backpack signatures. +c_min :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_min = const c_min_ + +-- | c_kthvalue : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h THIntTensor_kthvalue" + c_kthvalue_ :: Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CLLong -> CInt -> CInt -> IO () + +-- | alias of c_kthvalue_ with unused argument (for CTHState) to unify backpack signatures. +c_kthvalue :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CLLong -> CInt -> CInt -> IO () +c_kthvalue = const c_kthvalue_ + +-- | c_mode : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THIntTensor_mode" + c_mode_ :: Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_mode_ with unused argument (for CTHState) to unify backpack signatures. +c_mode :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_mode = const c_mode_ + +-- | c_median : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THIntTensor_median" + c_median_ :: Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_median_ with unused argument (for CTHState) to unify backpack signatures. +c_median :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_median = const c_median_ + +-- | c_sum : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THIntTensor_sum" + c_sum_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_sum_ with unused argument (for CTHState) to unify backpack signatures. +c_sum :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_sum = const c_sum_ + +-- | c_prod : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THIntTensor_prod" + c_prod_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_prod_ with unused argument (for CTHState) to unify backpack signatures. +c_prod :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_prod = const c_prod_ + +-- | c_cumsum : r_ t dimension -> void +foreign import ccall "THTensorMath.h THIntTensor_cumsum" + c_cumsum_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_cumsum_ with unused argument (for CTHState) to unify backpack signatures. +c_cumsum :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_cumsum = const c_cumsum_ + +-- | c_cumprod : r_ t dimension -> void +foreign import ccall "THTensorMath.h THIntTensor_cumprod" + c_cumprod_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_cumprod_ with unused argument (for CTHState) to unify backpack signatures. +c_cumprod :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_cumprod = const c_cumprod_ + +-- | c_sign : r_ t -> void +foreign import ccall "THTensorMath.h THIntTensor_sign" + c_sign_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_sign_ with unused argument (for CTHState) to unify backpack signatures. +c_sign :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_sign = const c_sign_ + +-- | c_trace : t -> accreal +foreign import ccall "THTensorMath.h THIntTensor_trace" + c_trace_ :: Ptr C'THIntTensor -> IO CLong + +-- | alias of c_trace_ with unused argument (for CTHState) to unify backpack signatures. +c_trace :: Ptr C'THState -> Ptr C'THIntTensor -> IO CLong +c_trace = const c_trace_ + +-- | c_cross : r_ a b dimension -> void +foreign import ccall "THTensorMath.h THIntTensor_cross" + c_cross_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_cross_ with unused argument (for CTHState) to unify backpack signatures. +c_cross :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_cross = const c_cross_ + +-- | c_cmax : r t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cmax" + c_cmax_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cmax_ with unused argument (for CTHState) to unify backpack signatures. +c_cmax :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cmax = const c_cmax_ + +-- | c_cmin : r t src -> void +foreign import ccall "THTensorMath.h THIntTensor_cmin" + c_cmin_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_cmin_ with unused argument (for CTHState) to unify backpack signatures. +c_cmin :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_cmin = const c_cmin_ + +-- | c_cmaxValue : r t value -> void +foreign import ccall "THTensorMath.h THIntTensor_cmaxValue" + c_cmaxValue_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_cmaxValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cmaxValue :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_cmaxValue = const c_cmaxValue_ + +-- | c_cminValue : r t value -> void +foreign import ccall "THTensorMath.h THIntTensor_cminValue" + c_cminValue_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_cminValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cminValue :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_cminValue = const c_cminValue_ + +-- | c_zeros : r_ size -> void +foreign import ccall "THTensorMath.h THIntTensor_zeros" + c_zeros_ :: Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_zeros_ with unused argument (for CTHState) to unify backpack signatures. +c_zeros :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO () +c_zeros = const c_zeros_ + +-- | c_zerosLike : r_ input -> void +foreign import ccall "THTensorMath.h THIntTensor_zerosLike" + c_zerosLike_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_zerosLike_ with unused argument (for CTHState) to unify backpack signatures. +c_zerosLike :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_zerosLike = const c_zerosLike_ + +-- | c_ones : r_ size -> void +foreign import ccall "THTensorMath.h THIntTensor_ones" + c_ones_ :: Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_ones_ with unused argument (for CTHState) to unify backpack signatures. +c_ones :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO () +c_ones = const c_ones_ + +-- | c_onesLike : r_ input -> void +foreign import ccall "THTensorMath.h THIntTensor_onesLike" + c_onesLike_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_onesLike_ with unused argument (for CTHState) to unify backpack signatures. +c_onesLike :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_onesLike = const c_onesLike_ + +-- | c_diag : r_ t k -> void +foreign import ccall "THTensorMath.h THIntTensor_diag" + c_diag_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_diag_ with unused argument (for CTHState) to unify backpack signatures. +c_diag :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_diag = const c_diag_ + +-- | c_eye : r_ n m -> void +foreign import ccall "THTensorMath.h THIntTensor_eye" + c_eye_ :: Ptr C'THIntTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_eye_ with unused argument (for CTHState) to unify backpack signatures. +c_eye :: Ptr C'THState -> Ptr C'THIntTensor -> CLLong -> CLLong -> IO () +c_eye = const c_eye_ + +-- | c_arange : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THIntTensor_arange" + c_arange_ :: Ptr C'THIntTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_arange_ with unused argument (for CTHState) to unify backpack signatures. +c_arange :: Ptr C'THState -> Ptr C'THIntTensor -> CLong -> CLong -> CLong -> IO () +c_arange = const c_arange_ + +-- | c_range : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THIntTensor_range" + c_range_ :: Ptr C'THIntTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_range_ with unused argument (for CTHState) to unify backpack signatures. +c_range :: Ptr C'THState -> Ptr C'THIntTensor -> CLong -> CLong -> CLong -> IO () +c_range = const c_range_ + +-- | c_randperm : r_ _generator n -> void +foreign import ccall "THTensorMath.h THIntTensor_randperm" + c_randperm_ :: Ptr C'THIntTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_randperm_ with unused argument (for CTHState) to unify backpack signatures. +c_randperm :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_randperm = const c_randperm_ + +-- | c_reshape : r_ t size -> void +foreign import ccall "THTensorMath.h THIntTensor_reshape" + c_reshape_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_reshape_ with unused argument (for CTHState) to unify backpack signatures. +c_reshape :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO () +c_reshape = const c_reshape_ + +-- | c_sort : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h THIntTensor_sort" + c_sort_ :: Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () + +-- | alias of c_sort_ with unused argument (for CTHState) to unify backpack signatures. +c_sort :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO () +c_sort = const c_sort_ + +-- | c_topk : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h THIntTensor_topk" + c_topk_ :: Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CLLong -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_topk_ with unused argument (for CTHState) to unify backpack signatures. +c_topk :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CLLong -> CInt -> CInt -> CInt -> IO () +c_topk = const c_topk_ + +-- | c_tril : r_ t k -> void +foreign import ccall "THTensorMath.h THIntTensor_tril" + c_tril_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> IO () + +-- | alias of c_tril_ with unused argument (for CTHState) to unify backpack signatures. +c_tril :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> IO () +c_tril = const c_tril_ + +-- | c_triu : r_ t k -> void +foreign import ccall "THTensorMath.h THIntTensor_triu" + c_triu_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> IO () + +-- | alias of c_triu_ with unused argument (for CTHState) to unify backpack signatures. +c_triu :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> IO () +c_triu = const c_triu_ + +-- | c_cat : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h THIntTensor_cat" + c_cat_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_cat_ with unused argument (for CTHState) to unify backpack signatures. +c_cat :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_cat = const c_cat_ + +-- | c_catArray : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h THIntTensor_catArray" + c_catArray_ :: Ptr C'THIntTensor -> Ptr (Ptr C'THIntTensor) -> CInt -> CInt -> IO () + +-- | alias of c_catArray_ with unused argument (for CTHState) to unify backpack signatures. +c_catArray :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr (Ptr C'THIntTensor) -> CInt -> CInt -> IO () +c_catArray = const c_catArray_ + +-- | c_equal : ta tb -> int +foreign import ccall "THTensorMath.h THIntTensor_equal" + c_equal_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CInt + +-- | alias of c_equal_ with unused argument (for CTHState) to unify backpack signatures. +c_equal :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CInt +c_equal = const c_equal_ + +-- | c_ltValue : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_ltValue" + c_ltValue_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_ltValue_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_ltValue = const c_ltValue_ + +-- | c_leValue : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_leValue" + c_leValue_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_leValue_ with unused argument (for CTHState) to unify backpack signatures. +c_leValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_leValue = const c_leValue_ + +-- | c_gtValue : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_gtValue" + c_gtValue_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_gtValue_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_gtValue = const c_gtValue_ + +-- | c_geValue : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_geValue" + c_geValue_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_geValue_ with unused argument (for CTHState) to unify backpack signatures. +c_geValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_geValue = const c_geValue_ + +-- | c_neValue : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_neValue" + c_neValue_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_neValue_ with unused argument (for CTHState) to unify backpack signatures. +c_neValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_neValue = const c_neValue_ + +-- | c_eqValue : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_eqValue" + c_eqValue_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_eqValue_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_eqValue = const c_eqValue_ + +-- | c_ltValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_ltValueT" + c_ltValueT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_ltValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValueT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_ltValueT = const c_ltValueT_ + +-- | c_leValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_leValueT" + c_leValueT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_leValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_leValueT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_leValueT = const c_leValueT_ + +-- | c_gtValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_gtValueT" + c_gtValueT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_gtValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValueT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_gtValueT = const c_gtValueT_ + +-- | c_geValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_geValueT" + c_geValueT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_geValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_geValueT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_geValueT = const c_geValueT_ + +-- | c_neValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_neValueT" + c_neValueT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_neValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_neValueT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_neValueT = const c_neValueT_ + +-- | c_eqValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THIntTensor_eqValueT" + c_eqValueT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () + +-- | alias of c_eqValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValueT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO () +c_eqValueT = const c_eqValueT_ + +-- | c_ltTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_ltTensor" + c_ltTensor_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_ltTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_ltTensor = const c_ltTensor_ + +-- | c_leTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_leTensor" + c_leTensor_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_leTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_leTensor = const c_leTensor_ + +-- | c_gtTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_gtTensor" + c_gtTensor_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_gtTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_gtTensor = const c_gtTensor_ + +-- | c_geTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_geTensor" + c_geTensor_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_geTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_geTensor = const c_geTensor_ + +-- | c_neTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_neTensor" + c_neTensor_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_neTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_neTensor = const c_neTensor_ + +-- | c_eqTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_eqTensor" + c_eqTensor_ :: Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_eqTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_eqTensor = const c_eqTensor_ + +-- | c_ltTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_ltTensorT" + c_ltTensorT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_ltTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensorT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_ltTensorT = const c_ltTensorT_ + +-- | c_leTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_leTensorT" + c_leTensorT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_leTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensorT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_leTensorT = const c_leTensorT_ + +-- | c_gtTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_gtTensorT" + c_gtTensorT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_gtTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensorT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_gtTensorT = const c_gtTensorT_ + +-- | c_geTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_geTensorT" + c_geTensorT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_geTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensorT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_geTensorT = const c_geTensorT_ + +-- | c_neTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_neTensorT" + c_neTensorT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_neTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensorT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_neTensorT = const c_neTensorT_ + +-- | c_eqTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THIntTensor_eqTensorT" + c_eqTensorT_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_eqTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensorT :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_eqTensorT = const c_eqTensorT_ + +-- | c_abs : r_ t -> void +foreign import ccall "THTensorMath.h THIntTensor_abs" + c_abs_ :: Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO () +c_abs = const c_abs_ + +-- | p_fill : Pointer to function : r_ value -> void +foreign import ccall "THTensorMath.h &THIntTensor_fill" + p_fill :: FunPtr (Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_zero : Pointer to function : r_ -> void +foreign import ccall "THTensorMath.h &THIntTensor_zero" + p_zero :: FunPtr (Ptr C'THIntTensor -> IO ()) + +-- | p_maskedFill : Pointer to function : tensor mask value -> void +foreign import ccall "THTensorMath.h &THIntTensor_maskedFill" + p_maskedFill :: FunPtr (Ptr C'THIntTensor -> Ptr C'THByteTensor -> CInt -> IO ()) + +-- | p_maskedCopy : Pointer to function : tensor mask src -> void +foreign import ccall "THTensorMath.h &THIntTensor_maskedCopy" + p_maskedCopy :: FunPtr (Ptr C'THIntTensor -> Ptr C'THByteTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_maskedSelect : Pointer to function : tensor src mask -> void +foreign import ccall "THTensorMath.h &THIntTensor_maskedSelect" + p_maskedSelect :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_nonzero : Pointer to function : subscript tensor -> void +foreign import ccall "THTensorMath.h &THIntTensor_nonzero" + p_nonzero :: FunPtr (Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_indexSelect : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THIntTensor_indexSelect" + p_indexSelect :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexCopy : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THIntTensor_indexCopy" + p_indexCopy :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_indexAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THIntTensor_indexAdd" + p_indexAdd :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_indexFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THIntTensor_indexFill" + p_indexFill :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_take : Pointer to function : tensor src index -> void +foreign import ccall "THTensorMath.h &THIntTensor_take" + p_take :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_put : Pointer to function : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h &THIntTensor_put" + p_put :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_gather : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THIntTensor_gather" + p_gather :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_scatter : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THIntTensor_scatter" + p_scatter :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_scatterAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THIntTensor_scatterAdd" + p_scatterAdd :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_scatterFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THIntTensor_scatterFill" + p_scatterFill :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_dot : Pointer to function : t src -> accreal +foreign import ccall "THTensorMath.h &THIntTensor_dot" + p_dot :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CLong) + +-- | p_minall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THIntTensor_minall" + p_minall :: FunPtr (Ptr C'THIntTensor -> IO CInt) + +-- | p_maxall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THIntTensor_maxall" + p_maxall :: FunPtr (Ptr C'THIntTensor -> IO CInt) + +-- | p_medianall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THIntTensor_medianall" + p_medianall :: FunPtr (Ptr C'THIntTensor -> IO CInt) + +-- | p_sumall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THIntTensor_sumall" + p_sumall :: FunPtr (Ptr C'THIntTensor -> IO CLong) + +-- | p_prodall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THIntTensor_prodall" + p_prodall :: FunPtr (Ptr C'THIntTensor -> IO CLong) + +-- | p_neg : Pointer to function : self src -> void +foreign import ccall "THTensorMath.h &THIntTensor_neg" + p_neg :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_add : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_add" + p_add :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_sub : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_sub" + p_sub :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_add_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THIntTensor_add_scaled" + p_add_scaled :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_sub_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THIntTensor_sub_scaled" + p_sub_scaled :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_mul : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_mul" + p_mul :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_div : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_div" + p_div :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_lshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_lshift" + p_lshift :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_rshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_rshift" + p_rshift :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_fmod : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_fmod" + p_fmod :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_remainder : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_remainder" + p_remainder :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_clamp : Pointer to function : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h &THIntTensor_clamp" + p_clamp :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_bitand : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_bitand" + p_bitand :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_bitor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_bitor" + p_bitor :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_bitxor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_bitxor" + p_bitxor :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_cadd : Pointer to function : r_ t value src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cadd" + p_cadd :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> IO ()) + +-- | p_csub : Pointer to function : self src1 value src2 -> void +foreign import ccall "THTensorMath.h &THIntTensor_csub" + p_csub :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> IO ()) + +-- | p_cmul : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cmul" + p_cmul :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_cpow : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cpow" + p_cpow :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_cdiv : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cdiv" + p_cdiv :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_clshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_clshift" + p_clshift :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_crshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_crshift" + p_crshift :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_cfmod : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cfmod" + p_cfmod :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_cremainder : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cremainder" + p_cremainder :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_cbitand : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cbitand" + p_cbitand :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_cbitor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cbitor" + p_cbitor :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_cbitxor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cbitxor" + p_cbitxor :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_addcmul : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THIntTensor_addcmul" + p_addcmul :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_addcdiv : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THIntTensor_addcdiv" + p_addcdiv :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_addmv : Pointer to function : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h &THIntTensor_addmv" + p_addmv :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_addmm : Pointer to function : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h &THIntTensor_addmm" + p_addmm :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_addr : Pointer to function : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h &THIntTensor_addr" + p_addr :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_addbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THIntTensor_addbmm" + p_addbmm :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_baddbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THIntTensor_baddbmm" + p_baddbmm :: FunPtr (Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> CInt -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_match : Pointer to function : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h &THIntTensor_match" + p_match :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_numel : Pointer to function : t -> ptrdiff_t +foreign import ccall "THTensorMath.h &THIntTensor_numel" + p_numel :: FunPtr (Ptr C'THIntTensor -> IO CPtrdiff) + +-- | p_preserveReduceDimSemantics : Pointer to function : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h &THIntTensor_preserveReduceDimSemantics" + p_preserveReduceDimSemantics :: FunPtr (Ptr C'THIntTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_max : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THIntTensor_max" + p_max :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_min : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THIntTensor_min" + p_min :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_kthvalue : Pointer to function : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h &THIntTensor_kthvalue" + p_kthvalue :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CLLong -> CInt -> CInt -> IO ()) + +-- | p_mode : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THIntTensor_mode" + p_mode :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_median : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THIntTensor_median" + p_median :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_sum : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THIntTensor_sum" + p_sum :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_prod : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THIntTensor_prod" + p_prod :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_cumsum : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THIntTensor_cumsum" + p_cumsum :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_cumprod : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THIntTensor_cumprod" + p_cumprod :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_sign : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THIntTensor_sign" + p_sign :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_trace : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THIntTensor_trace" + p_trace :: FunPtr (Ptr C'THIntTensor -> IO CLong) + +-- | p_cross : Pointer to function : r_ a b dimension -> void +foreign import ccall "THTensorMath.h &THIntTensor_cross" + p_cross :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_cmax : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cmax" + p_cmax :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_cmin : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THIntTensor_cmin" + p_cmin :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_cmaxValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_cmaxValue" + p_cmaxValue :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_cminValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_cminValue" + p_cminValue :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_zeros : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THIntTensor_zeros" + p_zeros :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_zerosLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THIntTensor_zerosLike" + p_zerosLike :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_ones : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THIntTensor_ones" + p_ones :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_onesLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THIntTensor_onesLike" + p_onesLike :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_diag : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THIntTensor_diag" + p_diag :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_eye : Pointer to function : r_ n m -> void +foreign import ccall "THTensorMath.h &THIntTensor_eye" + p_eye :: FunPtr (Ptr C'THIntTensor -> CLLong -> CLLong -> IO ()) + +-- | p_arange : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THIntTensor_arange" + p_arange :: FunPtr (Ptr C'THIntTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_range : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THIntTensor_range" + p_range :: FunPtr (Ptr C'THIntTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_randperm : Pointer to function : r_ _generator n -> void +foreign import ccall "THTensorMath.h &THIntTensor_randperm" + p_randperm :: FunPtr (Ptr C'THIntTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_reshape : Pointer to function : r_ t size -> void +foreign import ccall "THTensorMath.h &THIntTensor_reshape" + p_reshape :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_sort : Pointer to function : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h &THIntTensor_sort" + p_sort :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CInt -> CInt -> IO ()) + +-- | p_topk : Pointer to function : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h &THIntTensor_topk" + p_topk :: FunPtr (Ptr C'THIntTensor -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> CLLong -> CInt -> CInt -> CInt -> IO ()) + +-- | p_tril : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THIntTensor_tril" + p_tril :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> IO ()) + +-- | p_triu : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THIntTensor_triu" + p_triu :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CLLong -> IO ()) + +-- | p_cat : Pointer to function : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h &THIntTensor_cat" + p_cat :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_catArray : Pointer to function : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h &THIntTensor_catArray" + p_catArray :: FunPtr (Ptr C'THIntTensor -> Ptr (Ptr C'THIntTensor) -> CInt -> CInt -> IO ()) + +-- | p_equal : Pointer to function : ta tb -> int +foreign import ccall "THTensorMath.h &THIntTensor_equal" + p_equal :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO CInt) + +-- | p_ltValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_ltValue" + p_ltValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_leValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_leValue" + p_leValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_gtValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_gtValue" + p_gtValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_geValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_geValue" + p_geValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_neValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_neValue" + p_neValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_eqValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_eqValue" + p_eqValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_ltValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_ltValueT" + p_ltValueT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_leValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_leValueT" + p_leValueT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_gtValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_gtValueT" + p_gtValueT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_geValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_geValueT" + p_geValueT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_neValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_neValueT" + p_neValueT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_eqValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THIntTensor_eqValueT" + p_eqValueT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> CInt -> IO ()) + +-- | p_ltTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_ltTensor" + p_ltTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_leTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_leTensor" + p_leTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_gtTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_gtTensor" + p_gtTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_geTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_geTensor" + p_geTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_neTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_neTensor" + p_neTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_eqTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_eqTensor" + p_eqTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_ltTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_ltTensorT" + p_ltTensorT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_leTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_leTensorT" + p_leTensorT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_gtTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_gtTensorT" + p_gtTensorT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_geTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_geTensorT" + p_geTensorT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_neTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_neTensorT" + p_neTensorT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_eqTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THIntTensor_eqTensorT" + p_eqTensorT :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_abs : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THIntTensor_abs" + p_abs :: FunPtr (Ptr C'THIntTensor -> Ptr C'THIntTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Int/TensorRandom.hs b/src/Torch/FFI/TH/Int/TensorRandom.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Int/TensorRandom.hs @@ -0,0 +1,92 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.TensorRandom where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_random : self _generator -> void +foreign import ccall "THTensorRandom.h THIntTensor_random" + c_random_ :: Ptr C'THIntTensor -> Ptr C'THGenerator -> IO () + +-- | alias of c_random_ with unused argument (for CTHState) to unify backpack signatures. +c_random :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THGenerator -> IO () +c_random = const c_random_ + +-- | c_clampedRandom : self _generator min max -> void +foreign import ccall "THTensorRandom.h THIntTensor_clampedRandom" + c_clampedRandom_ :: Ptr C'THIntTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () + +-- | alias of c_clampedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_clampedRandom :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () +c_clampedRandom = const c_clampedRandom_ + +-- | c_cappedRandom : self _generator max -> void +foreign import ccall "THTensorRandom.h THIntTensor_cappedRandom" + c_cappedRandom_ :: Ptr C'THIntTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_cappedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_cappedRandom :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_cappedRandom = const c_cappedRandom_ + +-- | c_geometric : self _generator p -> void +foreign import ccall "THTensorRandom.h THIntTensor_geometric" + c_geometric_ :: Ptr C'THIntTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_geometric_ with unused argument (for CTHState) to unify backpack signatures. +c_geometric :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_geometric = const c_geometric_ + +-- | c_bernoulli : self _generator p -> void +foreign import ccall "THTensorRandom.h THIntTensor_bernoulli" + c_bernoulli_ :: Ptr C'THIntTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_bernoulli_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_bernoulli = const c_bernoulli_ + +-- | c_bernoulli_FloatTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THIntTensor_bernoulli_FloatTensor" + c_bernoulli_FloatTensor_ :: Ptr C'THIntTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_bernoulli_FloatTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_FloatTensor :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () +c_bernoulli_FloatTensor = const c_bernoulli_FloatTensor_ + +-- | c_bernoulli_DoubleTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THIntTensor_bernoulli_DoubleTensor" + c_bernoulli_DoubleTensor_ :: Ptr C'THIntTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_bernoulli_DoubleTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_DoubleTensor :: Ptr C'THState -> Ptr C'THIntTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () +c_bernoulli_DoubleTensor = const c_bernoulli_DoubleTensor_ + +-- | p_random : Pointer to function : self _generator -> void +foreign import ccall "THTensorRandom.h &THIntTensor_random" + p_random :: FunPtr (Ptr C'THIntTensor -> Ptr C'THGenerator -> IO ()) + +-- | p_clampedRandom : Pointer to function : self _generator min max -> void +foreign import ccall "THTensorRandom.h &THIntTensor_clampedRandom" + p_clampedRandom :: FunPtr (Ptr C'THIntTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO ()) + +-- | p_cappedRandom : Pointer to function : self _generator max -> void +foreign import ccall "THTensorRandom.h &THIntTensor_cappedRandom" + p_cappedRandom :: FunPtr (Ptr C'THIntTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_geometric : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THIntTensor_geometric" + p_geometric :: FunPtr (Ptr C'THIntTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THIntTensor_bernoulli" + p_bernoulli :: FunPtr (Ptr C'THIntTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli_FloatTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THIntTensor_bernoulli_FloatTensor" + p_bernoulli_FloatTensor :: FunPtr (Ptr C'THIntTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO ()) + +-- | p_bernoulli_DoubleTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THIntTensor_bernoulli_DoubleTensor" + p_bernoulli_DoubleTensor :: FunPtr (Ptr C'THIntTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Int/Vector.hs b/src/Torch/FFI/TH/Int/Vector.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Int/Vector.hs @@ -0,0 +1,140 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Int.Vector where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : x c n -> void +foreign import ccall "THVector.h THIntVector_fill" + c_fill_ :: Ptr CInt -> CInt -> CPtrdiff -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr CInt -> CInt -> CPtrdiff -> IO () +c_fill = const c_fill_ + +-- | c_cadd : z x y c n -> void +foreign import ccall "THVector.h THIntVector_cadd" + c_cadd_ :: Ptr CInt -> Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr CInt -> Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO () +c_cadd = const c_cadd_ + +-- | c_adds : y x c n -> void +foreign import ccall "THVector.h THIntVector_adds" + c_adds_ :: Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO () + +-- | alias of c_adds_ with unused argument (for CTHState) to unify backpack signatures. +c_adds :: Ptr C'THState -> Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO () +c_adds = const c_adds_ + +-- | c_cmul : z x y n -> void +foreign import ccall "THVector.h THIntVector_cmul" + c_cmul_ :: Ptr CInt -> Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr CInt -> Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () +c_cmul = const c_cmul_ + +-- | c_muls : y x c n -> void +foreign import ccall "THVector.h THIntVector_muls" + c_muls_ :: Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO () + +-- | alias of c_muls_ with unused argument (for CTHState) to unify backpack signatures. +c_muls :: Ptr C'THState -> Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO () +c_muls = const c_muls_ + +-- | c_cdiv : z x y n -> void +foreign import ccall "THVector.h THIntVector_cdiv" + c_cdiv_ :: Ptr CInt -> Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr CInt -> Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () +c_cdiv = const c_cdiv_ + +-- | c_divs : y x c n -> void +foreign import ccall "THVector.h THIntVector_divs" + c_divs_ :: Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO () + +-- | alias of c_divs_ with unused argument (for CTHState) to unify backpack signatures. +c_divs :: Ptr C'THState -> Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO () +c_divs = const c_divs_ + +-- | c_copy : y x n -> void +foreign import ccall "THVector.h THIntVector_copy" + c_copy_ :: Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () +c_copy = const c_copy_ + +-- | c_neg : y x n -> void +foreign import ccall "THVector.h THIntVector_neg" + c_neg_ :: Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () +c_neg = const c_neg_ + +-- | c_normal_fill : data size generator mean stddev -> void +foreign import ccall "THVector.h THIntVector_normal_fill" + c_normal_fill_ :: Ptr CInt -> CLLong -> Ptr C'THGenerator -> CInt -> CInt -> IO () + +-- | alias of c_normal_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_fill :: Ptr C'THState -> Ptr CInt -> CLLong -> Ptr C'THGenerator -> CInt -> CInt -> IO () +c_normal_fill = const c_normal_fill_ + +-- | c_abs : y x n -> void +foreign import ccall "THVector.h THIntVector_abs" + c_abs_ :: Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr CInt -> Ptr CInt -> CPtrdiff -> IO () +c_abs = const c_abs_ + +-- | p_fill : Pointer to function : x c n -> void +foreign import ccall "THVector.h &THIntVector_fill" + p_fill :: FunPtr (Ptr CInt -> CInt -> CPtrdiff -> IO ()) + +-- | p_cadd : Pointer to function : z x y c n -> void +foreign import ccall "THVector.h &THIntVector_cadd" + p_cadd :: FunPtr (Ptr CInt -> Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO ()) + +-- | p_adds : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THIntVector_adds" + p_adds :: FunPtr (Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO ()) + +-- | p_cmul : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THIntVector_cmul" + p_cmul :: FunPtr (Ptr CInt -> Ptr CInt -> Ptr CInt -> CPtrdiff -> IO ()) + +-- | p_muls : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THIntVector_muls" + p_muls :: FunPtr (Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO ()) + +-- | p_cdiv : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THIntVector_cdiv" + p_cdiv :: FunPtr (Ptr CInt -> Ptr CInt -> Ptr CInt -> CPtrdiff -> IO ()) + +-- | p_divs : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THIntVector_divs" + p_divs :: FunPtr (Ptr CInt -> Ptr CInt -> CInt -> CPtrdiff -> IO ()) + +-- | p_copy : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THIntVector_copy" + p_copy :: FunPtr (Ptr CInt -> Ptr CInt -> CPtrdiff -> IO ()) + +-- | p_neg : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THIntVector_neg" + p_neg :: FunPtr (Ptr CInt -> Ptr CInt -> CPtrdiff -> IO ()) + +-- | p_normal_fill : Pointer to function : data size generator mean stddev -> void +foreign import ccall "THVector.h &THIntVector_normal_fill" + p_normal_fill :: FunPtr (Ptr CInt -> CLLong -> Ptr C'THGenerator -> CInt -> CInt -> IO ()) + +-- | p_abs : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THIntVector_abs" + p_abs :: FunPtr (Ptr CInt -> Ptr CInt -> CPtrdiff -> IO ()) diff --git a/src/Torch/FFI/TH/LogAdd.hs b/src/Torch/FFI/TH/LogAdd.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/LogAdd.hs @@ -0,0 +1,32 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.LogAdd where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_THLogAdd : log_a log_b -> double +foreign import ccall "THLogAdd.h THLogAdd" + c_THLogAdd :: CDouble -> CDouble -> IO CDouble + +-- | c_THLogSub : log_a log_b -> double +foreign import ccall "THLogAdd.h THLogSub" + c_THLogSub :: CDouble -> CDouble -> IO CDouble + +-- | c_THExpMinusApprox : x -> double +foreign import ccall "THLogAdd.h THExpMinusApprox" + c_THExpMinusApprox :: CDouble -> IO CDouble + +-- | p_THLogAdd : Pointer to function : log_a log_b -> double +foreign import ccall "THLogAdd.h &THLogAdd" + p_THLogAdd :: FunPtr (CDouble -> CDouble -> IO CDouble) + +-- | p_THLogSub : Pointer to function : log_a log_b -> double +foreign import ccall "THLogAdd.h &THLogSub" + p_THLogSub :: FunPtr (CDouble -> CDouble -> IO CDouble) + +-- | p_THExpMinusApprox : Pointer to function : x -> double +foreign import ccall "THLogAdd.h &THExpMinusApprox" + p_THExpMinusApprox :: FunPtr (CDouble -> IO CDouble) diff --git a/src/Torch/FFI/TH/Long/Blas.hs b/src/Torch/FFI/TH/Long/Blas.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Long/Blas.hs @@ -0,0 +1,104 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.Blas where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_swap : n x incx y incy -> void +foreign import ccall "THBlas.h THLongBlas_swap" + c_swap_ :: CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO () +c_swap = const c_swap_ + +-- | c_scal : n a x incx -> void +foreign import ccall "THBlas.h THLongBlas_scal" + c_scal_ :: CLLong -> CLong -> Ptr CLong -> CLLong -> IO () + +-- | alias of c_scal_ with unused argument (for CTHState) to unify backpack signatures. +c_scal :: Ptr C'THState -> CLLong -> CLong -> Ptr CLong -> CLLong -> IO () +c_scal = const c_scal_ + +-- | c_copy : n x incx y incy -> void +foreign import ccall "THBlas.h THLongBlas_copy" + c_copy_ :: CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO () +c_copy = const c_copy_ + +-- | c_axpy : n a x incx y incy -> void +foreign import ccall "THBlas.h THLongBlas_axpy" + c_axpy_ :: CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO () + +-- | alias of c_axpy_ with unused argument (for CTHState) to unify backpack signatures. +c_axpy :: Ptr C'THState -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO () +c_axpy = const c_axpy_ + +-- | c_dot : n x incx y incy -> real +foreign import ccall "THBlas.h THLongBlas_dot" + c_dot_ :: CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO CLong + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO CLong +c_dot = const c_dot_ + +-- | c_gemv : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h THLongBlas_gemv" + c_gemv_ :: CChar -> CLLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> IO () + +-- | alias of c_gemv_ with unused argument (for CTHState) to unify backpack signatures. +c_gemv :: Ptr C'THState -> CChar -> CLLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> IO () +c_gemv = const c_gemv_ + +-- | c_ger : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h THLongBlas_ger" + c_ger_ :: CLLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO () + +-- | alias of c_ger_ with unused argument (for CTHState) to unify backpack signatures. +c_ger :: Ptr C'THState -> CLLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO () +c_ger = const c_ger_ + +-- | c_gemm : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h THLongBlas_gemm" + c_gemm_ :: CChar -> CChar -> CLLong -> CLLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> IO () + +-- | alias of c_gemm_ with unused argument (for CTHState) to unify backpack signatures. +c_gemm :: Ptr C'THState -> CChar -> CChar -> CLLong -> CLLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> IO () +c_gemm = const c_gemm_ + +-- | p_swap : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THLongBlas_swap" + p_swap :: FunPtr (CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO ()) + +-- | p_scal : Pointer to function : n a x incx -> void +foreign import ccall "THBlas.h &THLongBlas_scal" + p_scal :: FunPtr (CLLong -> CLong -> Ptr CLong -> CLLong -> IO ()) + +-- | p_copy : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THLongBlas_copy" + p_copy :: FunPtr (CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO ()) + +-- | p_axpy : Pointer to function : n a x incx y incy -> void +foreign import ccall "THBlas.h &THLongBlas_axpy" + p_axpy :: FunPtr (CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO ()) + +-- | p_dot : Pointer to function : n x incx y incy -> real +foreign import ccall "THBlas.h &THLongBlas_dot" + p_dot :: FunPtr (CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO CLong) + +-- | p_gemv : Pointer to function : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h &THLongBlas_gemv" + p_gemv :: FunPtr (CChar -> CLLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> IO ()) + +-- | p_ger : Pointer to function : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h &THLongBlas_ger" + p_ger :: FunPtr (CLLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> IO ()) + +-- | p_gemm : Pointer to function : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h &THLongBlas_gemm" + p_gemm :: FunPtr (CChar -> CChar -> CLLong -> CLLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> Ptr CLong -> CLLong -> CLong -> Ptr CLong -> CLLong -> IO ()) diff --git a/src/Torch/FFI/TH/Long/Storage.hs b/src/Torch/FFI/TH/Long/Storage.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Long/Storage.hs @@ -0,0 +1,260 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.Storage where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_data : -> real * +foreign import ccall "THStorage.h THLongStorage_data" + c_data_ :: Ptr C'THLongStorage -> IO (Ptr CLong) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THLongStorage -> IO (Ptr CLong) +c_data = const c_data_ + +-- | c_size : -> ptrdiff_t +foreign import ccall "THStorage.h THLongStorage_size" + c_size_ :: Ptr C'THLongStorage -> IO CPtrdiff + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THLongStorage -> IO CPtrdiff +c_size = const c_size_ + +-- | c_set : -> void +foreign import ccall "THStorage.h THLongStorage_set" + c_set_ :: Ptr C'THLongStorage -> CPtrdiff -> CLong -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THLongStorage -> CPtrdiff -> CLong -> IO () +c_set = const c_set_ + +-- | c_get : -> real +foreign import ccall "THStorage.h THLongStorage_get" + c_get_ :: Ptr C'THLongStorage -> CPtrdiff -> IO CLong + +-- | alias of c_get_ with unused argument (for CTHState) to unify backpack signatures. +c_get :: Ptr C'THState -> Ptr C'THLongStorage -> CPtrdiff -> IO CLong +c_get = const c_get_ + +-- | c_new : -> THStorage * +foreign import ccall "THStorage.h THLongStorage_new" + c_new_ :: IO (Ptr C'THLongStorage) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THLongStorage) +c_new = const c_new_ + +-- | c_newWithSize : size -> THStorage * +foreign import ccall "THStorage.h THLongStorage_newWithSize" + c_newWithSize_ :: CPtrdiff -> IO (Ptr C'THLongStorage) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> CPtrdiff -> IO (Ptr C'THLongStorage) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1 : -> THStorage * +foreign import ccall "THStorage.h THLongStorage_newWithSize1" + c_newWithSize1_ :: CLong -> IO (Ptr C'THLongStorage) + +-- | alias of c_newWithSize1_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1 :: Ptr C'THState -> CLong -> IO (Ptr C'THLongStorage) +c_newWithSize1 = const c_newWithSize1_ + +-- | c_newWithSize2 : -> THStorage * +foreign import ccall "THStorage.h THLongStorage_newWithSize2" + c_newWithSize2_ :: CLong -> CLong -> IO (Ptr C'THLongStorage) + +-- | alias of c_newWithSize2_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2 :: Ptr C'THState -> CLong -> CLong -> IO (Ptr C'THLongStorage) +c_newWithSize2 = const c_newWithSize2_ + +-- | c_newWithSize3 : -> THStorage * +foreign import ccall "THStorage.h THLongStorage_newWithSize3" + c_newWithSize3_ :: CLong -> CLong -> CLong -> IO (Ptr C'THLongStorage) + +-- | alias of c_newWithSize3_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3 :: Ptr C'THState -> CLong -> CLong -> CLong -> IO (Ptr C'THLongStorage) +c_newWithSize3 = const c_newWithSize3_ + +-- | c_newWithSize4 : -> THStorage * +foreign import ccall "THStorage.h THLongStorage_newWithSize4" + c_newWithSize4_ :: CLong -> CLong -> CLong -> CLong -> IO (Ptr C'THLongStorage) + +-- | alias of c_newWithSize4_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4 :: Ptr C'THState -> CLong -> CLong -> CLong -> CLong -> IO (Ptr C'THLongStorage) +c_newWithSize4 = const c_newWithSize4_ + +-- | c_newWithMapping : filename size flags -> THStorage * +foreign import ccall "THStorage.h THLongStorage_newWithMapping" + c_newWithMapping_ :: Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THLongStorage) + +-- | alias of c_newWithMapping_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithMapping :: Ptr C'THState -> Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THLongStorage) +c_newWithMapping = const c_newWithMapping_ + +-- | c_newWithData : data size -> THStorage * +foreign import ccall "THStorage.h THLongStorage_newWithData" + c_newWithData_ :: Ptr CLong -> CPtrdiff -> IO (Ptr C'THLongStorage) + +-- | alias of c_newWithData_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithData :: Ptr C'THState -> Ptr CLong -> CPtrdiff -> IO (Ptr C'THLongStorage) +c_newWithData = const c_newWithData_ + +-- | c_newWithAllocator : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THLongStorage_newWithAllocator" + c_newWithAllocator_ :: CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THLongStorage) + +-- | alias of c_newWithAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithAllocator :: Ptr C'THState -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THLongStorage) +c_newWithAllocator = const c_newWithAllocator_ + +-- | c_newWithDataAndAllocator : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THLongStorage_newWithDataAndAllocator" + c_newWithDataAndAllocator_ :: Ptr CLong -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THLongStorage) + +-- | alias of c_newWithDataAndAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithDataAndAllocator :: Ptr C'THState -> Ptr CLong -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THLongStorage) +c_newWithDataAndAllocator = const c_newWithDataAndAllocator_ + +-- | c_setFlag : storage flag -> void +foreign import ccall "THStorage.h THLongStorage_setFlag" + c_setFlag_ :: Ptr C'THLongStorage -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THLongStorage -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : storage flag -> void +foreign import ccall "THStorage.h THLongStorage_clearFlag" + c_clearFlag_ :: Ptr C'THLongStorage -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THLongStorage -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_retain : storage -> void +foreign import ccall "THStorage.h THLongStorage_retain" + c_retain_ :: Ptr C'THLongStorage -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THLongStorage -> IO () +c_retain = const c_retain_ + +-- | c_swap : storage1 storage2 -> void +foreign import ccall "THStorage.h THLongStorage_swap" + c_swap_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_swap = const c_swap_ + +-- | c_free : storage -> void +foreign import ccall "THStorage.h THLongStorage_free" + c_free_ :: Ptr C'THLongStorage -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THLongStorage -> IO () +c_free = const c_free_ + +-- | c_resize : storage size -> void +foreign import ccall "THStorage.h THLongStorage_resize" + c_resize_ :: Ptr C'THLongStorage -> CPtrdiff -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THLongStorage -> CPtrdiff -> IO () +c_resize = const c_resize_ + +-- | c_fill : storage value -> void +foreign import ccall "THStorage.h THLongStorage_fill" + c_fill_ :: Ptr C'THLongStorage -> CLong -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THLongStorage -> CLong -> IO () +c_fill = const c_fill_ + +-- | p_data : Pointer to function : -> real * +foreign import ccall "THStorage.h &THLongStorage_data" + p_data :: FunPtr (Ptr C'THLongStorage -> IO (Ptr CLong)) + +-- | p_size : Pointer to function : -> ptrdiff_t +foreign import ccall "THStorage.h &THLongStorage_size" + p_size :: FunPtr (Ptr C'THLongStorage -> IO CPtrdiff) + +-- | p_set : Pointer to function : -> void +foreign import ccall "THStorage.h &THLongStorage_set" + p_set :: FunPtr (Ptr C'THLongStorage -> CPtrdiff -> CLong -> IO ()) + +-- | p_get : Pointer to function : -> real +foreign import ccall "THStorage.h &THLongStorage_get" + p_get :: FunPtr (Ptr C'THLongStorage -> CPtrdiff -> IO CLong) + +-- | p_new : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_new" + p_new :: FunPtr (IO (Ptr C'THLongStorage)) + +-- | p_newWithSize : Pointer to function : size -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_newWithSize" + p_newWithSize :: FunPtr (CPtrdiff -> IO (Ptr C'THLongStorage)) + +-- | p_newWithSize1 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_newWithSize1" + p_newWithSize1 :: FunPtr (CLong -> IO (Ptr C'THLongStorage)) + +-- | p_newWithSize2 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_newWithSize2" + p_newWithSize2 :: FunPtr (CLong -> CLong -> IO (Ptr C'THLongStorage)) + +-- | p_newWithSize3 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_newWithSize3" + p_newWithSize3 :: FunPtr (CLong -> CLong -> CLong -> IO (Ptr C'THLongStorage)) + +-- | p_newWithSize4 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_newWithSize4" + p_newWithSize4 :: FunPtr (CLong -> CLong -> CLong -> CLong -> IO (Ptr C'THLongStorage)) + +-- | p_newWithMapping : Pointer to function : filename size flags -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_newWithMapping" + p_newWithMapping :: FunPtr (Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THLongStorage)) + +-- | p_newWithData : Pointer to function : data size -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_newWithData" + p_newWithData :: FunPtr (Ptr CLong -> CPtrdiff -> IO (Ptr C'THLongStorage)) + +-- | p_newWithAllocator : Pointer to function : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_newWithAllocator" + p_newWithAllocator :: FunPtr (CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THLongStorage)) + +-- | p_newWithDataAndAllocator : Pointer to function : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THLongStorage_newWithDataAndAllocator" + p_newWithDataAndAllocator :: FunPtr (Ptr CLong -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THLongStorage)) + +-- | p_setFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THLongStorage_setFlag" + p_setFlag :: FunPtr (Ptr C'THLongStorage -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THLongStorage_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THLongStorage -> CChar -> IO ()) + +-- | p_retain : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THLongStorage_retain" + p_retain :: FunPtr (Ptr C'THLongStorage -> IO ()) + +-- | p_swap : Pointer to function : storage1 storage2 -> void +foreign import ccall "THStorage.h &THLongStorage_swap" + p_swap :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_free : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THLongStorage_free" + p_free :: FunPtr (Ptr C'THLongStorage -> IO ()) + +-- | p_resize : Pointer to function : storage size -> void +foreign import ccall "THStorage.h &THLongStorage_resize" + p_resize :: FunPtr (Ptr C'THLongStorage -> CPtrdiff -> IO ()) + +-- | p_fill : Pointer to function : storage value -> void +foreign import ccall "THStorage.h &THLongStorage_fill" + p_fill :: FunPtr (Ptr C'THLongStorage -> CLong -> IO ()) diff --git a/src/Torch/FFI/TH/Long/StorageCopy.hs b/src/Torch/FFI/TH/Long/StorageCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Long/StorageCopy.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.StorageCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_rawCopy : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_rawCopy" + c_rawCopy_ :: Ptr C'THLongStorage -> Ptr CLong -> IO () + +-- | alias of c_rawCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_rawCopy :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr CLong -> IO () +c_rawCopy = const c_rawCopy_ + +-- | c_copy : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_copy" + c_copy_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_copyByte" + c_copyByte_ :: Ptr C'THLongStorage -> Ptr C'THByteStorage -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THByteStorage -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_copyChar" + c_copyChar_ :: Ptr C'THLongStorage -> Ptr C'THCharStorage -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THCharStorage -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_copyShort" + c_copyShort_ :: Ptr C'THLongStorage -> Ptr C'THShortStorage -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THShortStorage -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_copyInt" + c_copyInt_ :: Ptr C'THLongStorage -> Ptr C'THIntStorage -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THIntStorage -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_copyLong" + c_copyLong_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_copyFloat" + c_copyFloat_ :: Ptr C'THLongStorage -> Ptr C'THFloatStorage -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THFloatStorage -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_copyDouble" + c_copyDouble_ :: Ptr C'THLongStorage -> Ptr C'THDoubleStorage -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THDoubleStorage -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : storage src -> void +foreign import ccall "THStorageCopy.h THLongStorage_copyHalf" + c_copyHalf_ :: Ptr C'THLongStorage -> Ptr C'THHalfStorage -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THHalfStorage -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_rawCopy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_rawCopy" + p_rawCopy :: FunPtr (Ptr C'THLongStorage -> Ptr CLong -> IO ()) + +-- | p_copy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_copy" + p_copy :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_copyByte : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_copyByte" + p_copyByte :: FunPtr (Ptr C'THLongStorage -> Ptr C'THByteStorage -> IO ()) + +-- | p_copyChar : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_copyChar" + p_copyChar :: FunPtr (Ptr C'THLongStorage -> Ptr C'THCharStorage -> IO ()) + +-- | p_copyShort : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_copyShort" + p_copyShort :: FunPtr (Ptr C'THLongStorage -> Ptr C'THShortStorage -> IO ()) + +-- | p_copyInt : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_copyInt" + p_copyInt :: FunPtr (Ptr C'THLongStorage -> Ptr C'THIntStorage -> IO ()) + +-- | p_copyLong : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_copyLong" + p_copyLong :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_copyFloat : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THLongStorage -> Ptr C'THFloatStorage -> IO ()) + +-- | p_copyDouble : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THLongStorage -> Ptr C'THDoubleStorage -> IO ()) + +-- | p_copyHalf : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THLongStorage_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THLongStorage -> Ptr C'THHalfStorage -> IO ()) diff --git a/src/Torch/FFI/TH/Long/Tensor.hs b/src/Torch/FFI/TH/Long/Tensor.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Long/Tensor.hs @@ -0,0 +1,872 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.Tensor where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_storage : self -> THStorage * +foreign import ccall "THTensor.h THLongTensor_storage" + c_storage_ :: Ptr C'THLongTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_storage_ with unused argument (for CTHState) to unify backpack signatures. +c_storage :: Ptr C'THState -> Ptr C'THLongTensor -> IO (Ptr C'THLongStorage) +c_storage = const c_storage_ + +-- | c_storageOffset : self -> ptrdiff_t +foreign import ccall "THTensor.h THLongTensor_storageOffset" + c_storageOffset_ :: Ptr C'THLongTensor -> IO CPtrdiff + +-- | alias of c_storageOffset_ with unused argument (for CTHState) to unify backpack signatures. +c_storageOffset :: Ptr C'THState -> Ptr C'THLongTensor -> IO CPtrdiff +c_storageOffset = const c_storageOffset_ + +-- | c_nDimension : self -> int +foreign import ccall "THTensor.h THLongTensor_nDimension" + c_nDimension_ :: Ptr C'THLongTensor -> IO CInt + +-- | alias of c_nDimension_ with unused argument (for CTHState) to unify backpack signatures. +c_nDimension :: Ptr C'THState -> Ptr C'THLongTensor -> IO CInt +c_nDimension = const c_nDimension_ + +-- | c_size : self dim -> int64_t +foreign import ccall "THTensor.h THLongTensor_size" + c_size_ :: Ptr C'THLongTensor -> CInt -> IO CLLong + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> IO CLLong +c_size = const c_size_ + +-- | c_stride : self dim -> int64_t +foreign import ccall "THTensor.h THLongTensor_stride" + c_stride_ :: Ptr C'THLongTensor -> CInt -> IO CLLong + +-- | alias of c_stride_ with unused argument (for CTHState) to unify backpack signatures. +c_stride :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> IO CLLong +c_stride = const c_stride_ + +-- | c_newSizeOf : self -> THLongStorage * +foreign import ccall "THTensor.h THLongTensor_newSizeOf" + c_newSizeOf_ :: Ptr C'THLongTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newSizeOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newSizeOf :: Ptr C'THState -> Ptr C'THLongTensor -> IO (Ptr C'THLongStorage) +c_newSizeOf = const c_newSizeOf_ + +-- | c_newStrideOf : self -> THLongStorage * +foreign import ccall "THTensor.h THLongTensor_newStrideOf" + c_newStrideOf_ :: Ptr C'THLongTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newStrideOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newStrideOf :: Ptr C'THState -> Ptr C'THLongTensor -> IO (Ptr C'THLongStorage) +c_newStrideOf = const c_newStrideOf_ + +-- | c_data : self -> real * +foreign import ccall "THTensor.h THLongTensor_data" + c_data_ :: Ptr C'THLongTensor -> IO (Ptr CLong) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THLongTensor -> IO (Ptr CLong) +c_data = const c_data_ + +-- | c_setFlag : self flag -> void +foreign import ccall "THTensor.h THLongTensor_setFlag" + c_setFlag_ :: Ptr C'THLongTensor -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THLongTensor -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : self flag -> void +foreign import ccall "THTensor.h THLongTensor_clearFlag" + c_clearFlag_ :: Ptr C'THLongTensor -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THLongTensor -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_new : -> THTensor * +foreign import ccall "THTensor.h THLongTensor_new" + c_new_ :: IO (Ptr C'THLongTensor) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THLongTensor) +c_new = const c_new_ + +-- | c_newWithTensor : tensor -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithTensor" + c_newWithTensor_ :: Ptr C'THLongTensor -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithTensor :: Ptr C'THState -> Ptr C'THLongTensor -> IO (Ptr C'THLongTensor) +c_newWithTensor = const c_newWithTensor_ + +-- | c_newWithStorage : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithStorage" + c_newWithStorage_ :: Ptr C'THLongStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage :: Ptr C'THState -> Ptr C'THLongStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor) +c_newWithStorage = const c_newWithStorage_ + +-- | c_newWithStorage1d : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithStorage1d" + c_newWithStorage1d_ :: Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage1d :: Ptr C'THState -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) +c_newWithStorage1d = const c_newWithStorage1d_ + +-- | c_newWithStorage2d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithStorage2d" + c_newWithStorage2d_ :: Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage2d :: Ptr C'THState -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) +c_newWithStorage2d = const c_newWithStorage2d_ + +-- | c_newWithStorage3d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithStorage3d" + c_newWithStorage3d_ :: Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage3d :: Ptr C'THState -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) +c_newWithStorage3d = const c_newWithStorage3d_ + +-- | c_newWithStorage4d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithStorage4d" + c_newWithStorage4d_ :: Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage4d :: Ptr C'THState -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) +c_newWithStorage4d = const c_newWithStorage4d_ + +-- | c_newWithSize : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithSize" + c_newWithSize_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1d : size0_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithSize1d" + c_newWithSize1d_ :: CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithSize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1d :: Ptr C'THState -> CLLong -> IO (Ptr C'THLongTensor) +c_newWithSize1d = const c_newWithSize1d_ + +-- | c_newWithSize2d : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithSize2d" + c_newWithSize2d_ :: CLLong -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithSize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2d :: Ptr C'THState -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) +c_newWithSize2d = const c_newWithSize2d_ + +-- | c_newWithSize3d : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithSize3d" + c_newWithSize3d_ :: CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithSize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) +c_newWithSize3d = const c_newWithSize3d_ + +-- | c_newWithSize4d : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newWithSize4d" + c_newWithSize4d_ :: CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newWithSize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) +c_newWithSize4d = const c_newWithSize4d_ + +-- | c_newClone : self -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newClone" + c_newClone_ :: Ptr C'THLongTensor -> IO (Ptr C'THLongTensor) + +-- | alias of c_newClone_ with unused argument (for CTHState) to unify backpack signatures. +c_newClone :: Ptr C'THState -> Ptr C'THLongTensor -> IO (Ptr C'THLongTensor) +c_newClone = const c_newClone_ + +-- | c_newContiguous : tensor -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newContiguous" + c_newContiguous_ :: Ptr C'THLongTensor -> IO (Ptr C'THLongTensor) + +-- | alias of c_newContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_newContiguous :: Ptr C'THState -> Ptr C'THLongTensor -> IO (Ptr C'THLongTensor) +c_newContiguous = const c_newContiguous_ + +-- | c_newSelect : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newSelect" + c_newSelect_ :: Ptr C'THLongTensor -> CInt -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_newSelect :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> CLLong -> IO (Ptr C'THLongTensor) +c_newSelect = const c_newSelect_ + +-- | c_newNarrow : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newNarrow" + c_newNarrow_ :: Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newNarrow_ with unused argument (for CTHState) to unify backpack signatures. +c_newNarrow :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) +c_newNarrow = const c_newNarrow_ + +-- | c_newTranspose : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newTranspose" + c_newTranspose_ :: Ptr C'THLongTensor -> CInt -> CInt -> IO (Ptr C'THLongTensor) + +-- | alias of c_newTranspose_ with unused argument (for CTHState) to unify backpack signatures. +c_newTranspose :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> CInt -> IO (Ptr C'THLongTensor) +c_newTranspose = const c_newTranspose_ + +-- | c_newUnfold : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newUnfold" + c_newUnfold_ :: Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) + +-- | alias of c_newUnfold_ with unused argument (for CTHState) to unify backpack signatures. +c_newUnfold :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THLongTensor) +c_newUnfold = const c_newUnfold_ + +-- | c_newView : tensor size -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newView" + c_newView_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor) + +-- | alias of c_newView_ with unused argument (for CTHState) to unify backpack signatures. +c_newView :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor) +c_newView = const c_newView_ + +-- | c_newExpand : tensor size -> THTensor * +foreign import ccall "THTensor.h THLongTensor_newExpand" + c_newExpand_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor) + +-- | alias of c_newExpand_ with unused argument (for CTHState) to unify backpack signatures. +c_newExpand :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor) +c_newExpand = const c_newExpand_ + +-- | c_expand : r tensor size -> void +foreign import ccall "THTensor.h THLongTensor_expand" + c_expand_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_expand_ with unused argument (for CTHState) to unify backpack signatures. +c_expand :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO () +c_expand = const c_expand_ + +-- | c_expandNd : rets ops count -> void +foreign import ccall "THTensor.h THLongTensor_expandNd" + c_expandNd_ :: Ptr (Ptr C'THLongTensor) -> Ptr (Ptr C'THLongTensor) -> CInt -> IO () + +-- | alias of c_expandNd_ with unused argument (for CTHState) to unify backpack signatures. +c_expandNd :: Ptr C'THState -> Ptr (Ptr C'THLongTensor) -> Ptr (Ptr C'THLongTensor) -> CInt -> IO () +c_expandNd = const c_expandNd_ + +-- | c_resize : tensor size stride -> void +foreign import ccall "THTensor.h THLongTensor_resize" + c_resize_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_resize = const c_resize_ + +-- | c_resizeAs : tensor src -> void +foreign import ccall "THTensor.h THLongTensor_resizeAs" + c_resizeAs_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_resizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeAs :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_resizeAs = const c_resizeAs_ + +-- | c_resizeNd : tensor nDimension size stride -> void +foreign import ccall "THTensor.h THLongTensor_resizeNd" + c_resizeNd_ :: Ptr C'THLongTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_resizeNd_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeNd :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_resizeNd = const c_resizeNd_ + +-- | c_resize1d : tensor size0_ -> void +foreign import ccall "THTensor.h THLongTensor_resize1d" + c_resize1d_ :: Ptr C'THLongTensor -> CLLong -> IO () + +-- | alias of c_resize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize1d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> IO () +c_resize1d = const c_resize1d_ + +-- | c_resize2d : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h THLongTensor_resize2d" + c_resize2d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_resize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize2d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> IO () +c_resize2d = const c_resize2d_ + +-- | c_resize3d : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h THLongTensor_resize3d" + c_resize3d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize3d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> IO () +c_resize3d = const c_resize3d_ + +-- | c_resize4d : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h THLongTensor_resize4d" + c_resize4d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize4d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize4d = const c_resize4d_ + +-- | c_resize5d : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h THLongTensor_resize5d" + c_resize5d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize5d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize5d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize5d = const c_resize5d_ + +-- | c_set : self src -> void +foreign import ccall "THTensor.h THLongTensor_set" + c_set_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_set = const c_set_ + +-- | c_setStorage : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h THLongTensor_setStorage" + c_setStorage_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_setStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_setStorage = const c_setStorage_ + +-- | c_setStorageNd : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h THLongTensor_setStorageNd" + c_setStorageNd_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_setStorageNd_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorageNd :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_setStorageNd = const c_setStorageNd_ + +-- | c_setStorage1d : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h THLongTensor_setStorage1d" + c_setStorage1d_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage1d :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> IO () +c_setStorage1d = const c_setStorage1d_ + +-- | c_setStorage2d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h THLongTensor_setStorage2d" + c_setStorage2d_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage2d :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage2d = const c_setStorage2d_ + +-- | c_setStorage3d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h THLongTensor_setStorage3d" + c_setStorage3d_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage3d :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage3d = const c_setStorage3d_ + +-- | c_setStorage4d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h THLongTensor_setStorage4d" + c_setStorage4d_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage4d :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage4d = const c_setStorage4d_ + +-- | c_narrow : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h THLongTensor_narrow" + c_narrow_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_narrow_ with unused argument (for CTHState) to unify backpack signatures. +c_narrow :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO () +c_narrow = const c_narrow_ + +-- | c_select : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h THLongTensor_select" + c_select_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CLLong -> IO () + +-- | alias of c_select_ with unused argument (for CTHState) to unify backpack signatures. +c_select :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CLLong -> IO () +c_select = const c_select_ + +-- | c_transpose : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h THLongTensor_transpose" + c_transpose_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () + +-- | alias of c_transpose_ with unused argument (for CTHState) to unify backpack signatures. +c_transpose :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () +c_transpose = const c_transpose_ + +-- | c_unfold : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h THLongTensor_unfold" + c_unfold_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_unfold_ with unused argument (for CTHState) to unify backpack signatures. +c_unfold :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO () +c_unfold = const c_unfold_ + +-- | c_squeeze : self src -> void +foreign import ccall "THTensor.h THLongTensor_squeeze" + c_squeeze_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_squeeze_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_squeeze = const c_squeeze_ + +-- | c_squeeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THLongTensor_squeeze1d" + c_squeeze1d_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_squeeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze1d :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () +c_squeeze1d = const c_squeeze1d_ + +-- | c_unsqueeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THLongTensor_unsqueeze1d" + c_unsqueeze1d_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_unsqueeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_unsqueeze1d :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () +c_unsqueeze1d = const c_unsqueeze1d_ + +-- | c_isContiguous : self -> int +foreign import ccall "THTensor.h THLongTensor_isContiguous" + c_isContiguous_ :: Ptr C'THLongTensor -> IO CInt + +-- | alias of c_isContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_isContiguous :: Ptr C'THState -> Ptr C'THLongTensor -> IO CInt +c_isContiguous = const c_isContiguous_ + +-- | c_isSameSizeAs : self src -> int +foreign import ccall "THTensor.h THLongTensor_isSameSizeAs" + c_isSameSizeAs_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CInt + +-- | alias of c_isSameSizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_isSameSizeAs :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CInt +c_isSameSizeAs = const c_isSameSizeAs_ + +-- | c_isSetTo : self src -> int +foreign import ccall "THTensor.h THLongTensor_isSetTo" + c_isSetTo_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CInt + +-- | alias of c_isSetTo_ with unused argument (for CTHState) to unify backpack signatures. +c_isSetTo :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CInt +c_isSetTo = const c_isSetTo_ + +-- | c_isSize : self dims -> int +foreign import ccall "THTensor.h THLongTensor_isSize" + c_isSize_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO CInt + +-- | alias of c_isSize_ with unused argument (for CTHState) to unify backpack signatures. +c_isSize :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO CInt +c_isSize = const c_isSize_ + +-- | c_nElement : self -> ptrdiff_t +foreign import ccall "THTensor.h THLongTensor_nElement" + c_nElement_ :: Ptr C'THLongTensor -> IO CPtrdiff + +-- | alias of c_nElement_ with unused argument (for CTHState) to unify backpack signatures. +c_nElement :: Ptr C'THState -> Ptr C'THLongTensor -> IO CPtrdiff +c_nElement = const c_nElement_ + +-- | c_retain : self -> void +foreign import ccall "THTensor.h THLongTensor_retain" + c_retain_ :: Ptr C'THLongTensor -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THLongTensor -> IO () +c_retain = const c_retain_ + +-- | c_free : self -> void +foreign import ccall "THTensor.h THLongTensor_free" + c_free_ :: Ptr C'THLongTensor -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THLongTensor -> IO () +c_free = const c_free_ + +-- | c_freeCopyTo : self dst -> void +foreign import ccall "THTensor.h THLongTensor_freeCopyTo" + c_freeCopyTo_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_freeCopyTo_ with unused argument (for CTHState) to unify backpack signatures. +c_freeCopyTo :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_freeCopyTo = const c_freeCopyTo_ + +-- | c_set1d : tensor x0 value -> void +foreign import ccall "THTensor.h THLongTensor_set1d" + c_set1d_ :: Ptr C'THLongTensor -> CLLong -> CLong -> IO () + +-- | alias of c_set1d_ with unused argument (for CTHState) to unify backpack signatures. +c_set1d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLong -> IO () +c_set1d = const c_set1d_ + +-- | c_set2d : tensor x0 x1 value -> void +foreign import ccall "THTensor.h THLongTensor_set2d" + c_set2d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> CLong -> IO () + +-- | alias of c_set2d_ with unused argument (for CTHState) to unify backpack signatures. +c_set2d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLong -> IO () +c_set2d = const c_set2d_ + +-- | c_set3d : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h THLongTensor_set3d" + c_set3d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLong -> IO () + +-- | alias of c_set3d_ with unused argument (for CTHState) to unify backpack signatures. +c_set3d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLong -> IO () +c_set3d = const c_set3d_ + +-- | c_set4d : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h THLongTensor_set4d" + c_set4d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLong -> IO () + +-- | alias of c_set4d_ with unused argument (for CTHState) to unify backpack signatures. +c_set4d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLong -> IO () +c_set4d = const c_set4d_ + +-- | c_get1d : tensor x0 -> real +foreign import ccall "THTensor.h THLongTensor_get1d" + c_get1d_ :: Ptr C'THLongTensor -> CLLong -> IO CLong + +-- | alias of c_get1d_ with unused argument (for CTHState) to unify backpack signatures. +c_get1d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> IO CLong +c_get1d = const c_get1d_ + +-- | c_get2d : tensor x0 x1 -> real +foreign import ccall "THTensor.h THLongTensor_get2d" + c_get2d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> IO CLong + +-- | alias of c_get2d_ with unused argument (for CTHState) to unify backpack signatures. +c_get2d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> IO CLong +c_get2d = const c_get2d_ + +-- | c_get3d : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h THLongTensor_get3d" + c_get3d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> IO CLong + +-- | alias of c_get3d_ with unused argument (for CTHState) to unify backpack signatures. +c_get3d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> IO CLong +c_get3d = const c_get3d_ + +-- | c_get4d : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h THLongTensor_get4d" + c_get4d_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CLong + +-- | alias of c_get4d_ with unused argument (for CTHState) to unify backpack signatures. +c_get4d :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CLong +c_get4d = const c_get4d_ + +-- | c_desc : tensor -> THDescBuff +foreign import ccall "THTensor.h THLongTensor_desc" + c_desc_ :: Ptr C'THLongTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_desc_ with unused argument (for CTHState) to unify backpack signatures. +c_desc :: Ptr C'THState -> Ptr C'THLongTensor -> IO (Ptr C'THDescBuff) +c_desc = const c_desc_ + +-- | c_sizeDesc : tensor -> THDescBuff +foreign import ccall "THTensor.h THLongTensor_sizeDesc" + c_sizeDesc_ :: Ptr C'THLongTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_sizeDesc_ with unused argument (for CTHState) to unify backpack signatures. +c_sizeDesc :: Ptr C'THState -> Ptr C'THLongTensor -> IO (Ptr C'THDescBuff) +c_sizeDesc = const c_sizeDesc_ + +-- | p_storage : Pointer to function : self -> THStorage * +foreign import ccall "THTensor.h &THLongTensor_storage" + p_storage :: FunPtr (Ptr C'THLongTensor -> IO (Ptr C'THLongStorage)) + +-- | p_storageOffset : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THLongTensor_storageOffset" + p_storageOffset :: FunPtr (Ptr C'THLongTensor -> IO CPtrdiff) + +-- | p_nDimension : Pointer to function : self -> int +foreign import ccall "THTensor.h &THLongTensor_nDimension" + p_nDimension :: FunPtr (Ptr C'THLongTensor -> IO CInt) + +-- | p_size : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THLongTensor_size" + p_size :: FunPtr (Ptr C'THLongTensor -> CInt -> IO CLLong) + +-- | p_stride : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THLongTensor_stride" + p_stride :: FunPtr (Ptr C'THLongTensor -> CInt -> IO CLLong) + +-- | p_newSizeOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THLongTensor_newSizeOf" + p_newSizeOf :: FunPtr (Ptr C'THLongTensor -> IO (Ptr C'THLongStorage)) + +-- | p_newStrideOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THLongTensor_newStrideOf" + p_newStrideOf :: FunPtr (Ptr C'THLongTensor -> IO (Ptr C'THLongStorage)) + +-- | p_data : Pointer to function : self -> real * +foreign import ccall "THTensor.h &THLongTensor_data" + p_data :: FunPtr (Ptr C'THLongTensor -> IO (Ptr CLong)) + +-- | p_setFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THLongTensor_setFlag" + p_setFlag :: FunPtr (Ptr C'THLongTensor -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THLongTensor_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THLongTensor -> CChar -> IO ()) + +-- | p_new : Pointer to function : -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_new" + p_new :: FunPtr (IO (Ptr C'THLongTensor)) + +-- | p_newWithTensor : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithTensor" + p_newWithTensor :: FunPtr (Ptr C'THLongTensor -> IO (Ptr C'THLongTensor)) + +-- | p_newWithStorage : Pointer to function : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithStorage" + p_newWithStorage :: FunPtr (Ptr C'THLongStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor)) + +-- | p_newWithStorage1d : Pointer to function : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithStorage1d" + p_newWithStorage1d :: FunPtr (Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newWithStorage2d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithStorage2d" + p_newWithStorage2d :: FunPtr (Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newWithStorage3d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithStorage3d" + p_newWithStorage3d :: FunPtr (Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newWithStorage4d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithStorage4d" + p_newWithStorage4d :: FunPtr (Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newWithSize : Pointer to function : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithSize" + p_newWithSize :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor)) + +-- | p_newWithSize1d : Pointer to function : size0_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithSize1d" + p_newWithSize1d :: FunPtr (CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newWithSize2d : Pointer to function : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithSize2d" + p_newWithSize2d :: FunPtr (CLLong -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newWithSize3d : Pointer to function : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithSize3d" + p_newWithSize3d :: FunPtr (CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newWithSize4d : Pointer to function : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newWithSize4d" + p_newWithSize4d :: FunPtr (CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newClone : Pointer to function : self -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newClone" + p_newClone :: FunPtr (Ptr C'THLongTensor -> IO (Ptr C'THLongTensor)) + +-- | p_newContiguous : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newContiguous" + p_newContiguous :: FunPtr (Ptr C'THLongTensor -> IO (Ptr C'THLongTensor)) + +-- | p_newSelect : Pointer to function : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newSelect" + p_newSelect :: FunPtr (Ptr C'THLongTensor -> CInt -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newNarrow : Pointer to function : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newNarrow" + p_newNarrow :: FunPtr (Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newTranspose : Pointer to function : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newTranspose" + p_newTranspose :: FunPtr (Ptr C'THLongTensor -> CInt -> CInt -> IO (Ptr C'THLongTensor)) + +-- | p_newUnfold : Pointer to function : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newUnfold" + p_newUnfold :: FunPtr (Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THLongTensor)) + +-- | p_newView : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newView" + p_newView :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor)) + +-- | p_newExpand : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THLongTensor_newExpand" + p_newExpand :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO (Ptr C'THLongTensor)) + +-- | p_expand : Pointer to function : r tensor size -> void +foreign import ccall "THTensor.h &THLongTensor_expand" + p_expand :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_expandNd : Pointer to function : rets ops count -> void +foreign import ccall "THTensor.h &THLongTensor_expandNd" + p_expandNd :: FunPtr (Ptr (Ptr C'THLongTensor) -> Ptr (Ptr C'THLongTensor) -> CInt -> IO ()) + +-- | p_resize : Pointer to function : tensor size stride -> void +foreign import ccall "THTensor.h &THLongTensor_resize" + p_resize :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_resizeAs : Pointer to function : tensor src -> void +foreign import ccall "THTensor.h &THLongTensor_resizeAs" + p_resizeAs :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_resizeNd : Pointer to function : tensor nDimension size stride -> void +foreign import ccall "THTensor.h &THLongTensor_resizeNd" + p_resizeNd :: FunPtr (Ptr C'THLongTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_resize1d : Pointer to function : tensor size0_ -> void +foreign import ccall "THTensor.h &THLongTensor_resize1d" + p_resize1d :: FunPtr (Ptr C'THLongTensor -> CLLong -> IO ()) + +-- | p_resize2d : Pointer to function : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h &THLongTensor_resize2d" + p_resize2d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> IO ()) + +-- | p_resize3d : Pointer to function : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h &THLongTensor_resize3d" + p_resize3d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize4d : Pointer to function : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h &THLongTensor_resize4d" + p_resize4d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize5d : Pointer to function : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h &THLongTensor_resize5d" + p_resize5d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_set : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THLongTensor_set" + p_set :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_setStorage : Pointer to function : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h &THLongTensor_setStorage" + p_setStorage :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_setStorageNd : Pointer to function : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h &THLongTensor_setStorageNd" + p_setStorageNd :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_setStorage1d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h &THLongTensor_setStorage1d" + p_setStorage1d :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage2d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h &THLongTensor_setStorage2d" + p_setStorage2d :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage3d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h &THLongTensor_setStorage3d" + p_setStorage3d :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage4d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h &THLongTensor_setStorage4d" + p_setStorage4d :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_narrow : Pointer to function : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h &THLongTensor_narrow" + p_narrow :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_select : Pointer to function : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h &THLongTensor_select" + p_select :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CLLong -> IO ()) + +-- | p_transpose : Pointer to function : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h &THLongTensor_transpose" + p_transpose :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO ()) + +-- | p_unfold : Pointer to function : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h &THLongTensor_unfold" + p_unfold :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_squeeze : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THLongTensor_squeeze" + p_squeeze :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_squeeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THLongTensor_squeeze1d" + p_squeeze1d :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_unsqueeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THLongTensor_unsqueeze1d" + p_unsqueeze1d :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_isContiguous : Pointer to function : self -> int +foreign import ccall "THTensor.h &THLongTensor_isContiguous" + p_isContiguous :: FunPtr (Ptr C'THLongTensor -> IO CInt) + +-- | p_isSameSizeAs : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THLongTensor_isSameSizeAs" + p_isSameSizeAs :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CInt) + +-- | p_isSetTo : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THLongTensor_isSetTo" + p_isSetTo :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CInt) + +-- | p_isSize : Pointer to function : self dims -> int +foreign import ccall "THTensor.h &THLongTensor_isSize" + p_isSize :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO CInt) + +-- | p_nElement : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THLongTensor_nElement" + p_nElement :: FunPtr (Ptr C'THLongTensor -> IO CPtrdiff) + +-- | p_retain : Pointer to function : self -> void +foreign import ccall "THTensor.h &THLongTensor_retain" + p_retain :: FunPtr (Ptr C'THLongTensor -> IO ()) + +-- | p_free : Pointer to function : self -> void +foreign import ccall "THTensor.h &THLongTensor_free" + p_free :: FunPtr (Ptr C'THLongTensor -> IO ()) + +-- | p_freeCopyTo : Pointer to function : self dst -> void +foreign import ccall "THTensor.h &THLongTensor_freeCopyTo" + p_freeCopyTo :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_set1d : Pointer to function : tensor x0 value -> void +foreign import ccall "THTensor.h &THLongTensor_set1d" + p_set1d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLong -> IO ()) + +-- | p_set2d : Pointer to function : tensor x0 x1 value -> void +foreign import ccall "THTensor.h &THLongTensor_set2d" + p_set2d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> CLong -> IO ()) + +-- | p_set3d : Pointer to function : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h &THLongTensor_set3d" + p_set3d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLong -> IO ()) + +-- | p_set4d : Pointer to function : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h &THLongTensor_set4d" + p_set4d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLong -> IO ()) + +-- | p_get1d : Pointer to function : tensor x0 -> real +foreign import ccall "THTensor.h &THLongTensor_get1d" + p_get1d :: FunPtr (Ptr C'THLongTensor -> CLLong -> IO CLong) + +-- | p_get2d : Pointer to function : tensor x0 x1 -> real +foreign import ccall "THTensor.h &THLongTensor_get2d" + p_get2d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> IO CLong) + +-- | p_get3d : Pointer to function : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h &THLongTensor_get3d" + p_get3d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> IO CLong) + +-- | p_get4d : Pointer to function : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h &THLongTensor_get4d" + p_get4d :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CLong) + +-- | p_desc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THLongTensor_desc" + p_desc :: FunPtr (Ptr C'THLongTensor -> IO (Ptr C'THDescBuff)) + +-- | p_sizeDesc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THLongTensor_sizeDesc" + p_sizeDesc :: FunPtr (Ptr C'THLongTensor -> IO (Ptr C'THDescBuff)) diff --git a/src/Torch/FFI/TH/Long/TensorConv.hs b/src/Torch/FFI/TH/Long/TensorConv.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Long/TensorConv.hs @@ -0,0 +1,272 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.TensorConv where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_validXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_validXCorr2Dptr" + c_validXCorr2Dptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2Dptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2Dptr = const c_validXCorr2Dptr_ + +-- | c_validConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_validConv2Dptr" + c_validConv2Dptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv2Dptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv2Dptr = const c_validConv2Dptr_ + +-- | c_fullXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_fullXCorr2Dptr" + c_fullXCorr2Dptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr2Dptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr2Dptr = const c_fullXCorr2Dptr_ + +-- | c_fullConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_fullConv2Dptr" + c_fullConv2Dptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv2Dptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv2Dptr = const c_fullConv2Dptr_ + +-- | c_validXCorr2DRevptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_validXCorr2DRevptr" + c_validXCorr2DRevptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2DRevptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2DRevptr = const c_validXCorr2DRevptr_ + +-- | c_conv2DRevger : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THLongTensor_conv2DRevger" + c_conv2DRevger_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevger :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> IO () +c_conv2DRevger = const c_conv2DRevger_ + +-- | c_conv2DRevgerm : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THLongTensor_conv2DRevgerm" + c_conv2DRevgerm_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevgerm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevgerm :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> IO () +c_conv2DRevgerm = const c_conv2DRevgerm_ + +-- | c_conv2Dger : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THLongTensor_conv2Dger" + c_conv2Dger_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dger :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dger = const c_conv2Dger_ + +-- | c_conv2Dmv : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THLongTensor_conv2Dmv" + c_conv2Dmv_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmv :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmv = const c_conv2Dmv_ + +-- | c_conv2Dmm : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THLongTensor_conv2Dmm" + c_conv2Dmm_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmm :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmm = const c_conv2Dmm_ + +-- | c_conv2Dmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THLongTensor_conv2Dmul" + c_conv2Dmul_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmul :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmul = const c_conv2Dmul_ + +-- | c_conv2Dcmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THLongTensor_conv2Dcmul" + c_conv2Dcmul_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dcmul :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dcmul = const c_conv2Dcmul_ + +-- | c_validXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_validXCorr3Dptr" + c_validXCorr3Dptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3Dptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3Dptr = const c_validXCorr3Dptr_ + +-- | c_validConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_validConv3Dptr" + c_validConv3Dptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv3Dptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv3Dptr = const c_validConv3Dptr_ + +-- | c_fullXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_fullXCorr3Dptr" + c_fullXCorr3Dptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr3Dptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr3Dptr = const c_fullXCorr3Dptr_ + +-- | c_fullConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_fullConv3Dptr" + c_fullConv3Dptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv3Dptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv3Dptr = const c_fullConv3Dptr_ + +-- | c_validXCorr3DRevptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THLongTensor_validXCorr3DRevptr" + c_validXCorr3DRevptr_ :: Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3DRevptr :: Ptr C'THState -> Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3DRevptr = const c_validXCorr3DRevptr_ + +-- | c_conv3DRevger : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h THLongTensor_conv3DRevger" + c_conv3DRevger_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_conv3DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3DRevger :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> IO () +c_conv3DRevger = const c_conv3DRevger_ + +-- | c_conv3Dger : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THLongTensor_conv3Dger" + c_conv3Dger_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dger :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dger = const c_conv3Dger_ + +-- | c_conv3Dmv : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THLongTensor_conv3Dmv" + c_conv3Dmv_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmv :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmv = const c_conv3Dmv_ + +-- | c_conv3Dmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THLongTensor_conv3Dmul" + c_conv3Dmul_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmul :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmul = const c_conv3Dmul_ + +-- | c_conv3Dcmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THLongTensor_conv3Dcmul" + c_conv3Dcmul_ :: Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dcmul :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dcmul = const c_conv3Dcmul_ + +-- | p_validXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_validXCorr2Dptr" + p_validXCorr2Dptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_validConv2Dptr" + p_validConv2Dptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_fullXCorr2Dptr" + p_fullXCorr2Dptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_fullConv2Dptr" + p_fullConv2Dptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr2DRevptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_validXCorr2DRevptr" + p_validXCorr2DRevptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevger : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv2DRevger" + p_conv2DRevger :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevgerm : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv2DRevgerm" + p_conv2DRevgerm :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2Dger : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv2Dger" + p_conv2Dger :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmv : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv2Dmv" + p_conv2Dmv :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmm : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv2Dmm" + p_conv2Dmm :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv2Dmul" + p_conv2Dmul :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dcmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv2Dcmul" + p_conv2Dcmul :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_validXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_validXCorr3Dptr" + p_validXCorr3Dptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_validConv3Dptr" + p_validConv3Dptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_fullXCorr3Dptr" + p_fullXCorr3Dptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_fullConv3Dptr" + p_fullConv3Dptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr3DRevptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THLongTensor_validXCorr3DRevptr" + p_validXCorr3DRevptr :: FunPtr (Ptr CLong -> CLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> Ptr CLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3DRevger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv3DRevger" + p_conv3DRevger :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3Dger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv3Dger" + p_conv3Dger :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmv : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv3Dmv" + p_conv3Dmv :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv3Dmul" + p_conv3Dmul :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dcmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THLongTensor_conv3Dcmul" + p_conv3Dcmul :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) diff --git a/src/Torch/FFI/TH/Long/TensorCopy.hs b/src/Torch/FFI/TH/Long/TensorCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Long/TensorCopy.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.TensorCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_copy : tensor src -> void +foreign import ccall "THTensorCopy.h THLongTensor_copy" + c_copy_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : tensor src -> void +foreign import ccall "THTensorCopy.h THLongTensor_copyByte" + c_copyByte_ :: Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : tensor src -> void +foreign import ccall "THTensorCopy.h THLongTensor_copyChar" + c_copyChar_ :: Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : tensor src -> void +foreign import ccall "THTensorCopy.h THLongTensor_copyShort" + c_copyShort_ :: Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : tensor src -> void +foreign import ccall "THTensorCopy.h THLongTensor_copyInt" + c_copyInt_ :: Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : tensor src -> void +foreign import ccall "THTensorCopy.h THLongTensor_copyLong" + c_copyLong_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : tensor src -> void +foreign import ccall "THTensorCopy.h THLongTensor_copyFloat" + c_copyFloat_ :: Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : tensor src -> void +foreign import ccall "THTensorCopy.h THLongTensor_copyDouble" + c_copyDouble_ :: Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : tensor src -> void +foreign import ccall "THTensorCopy.h THLongTensor_copyHalf" + c_copyHalf_ :: Ptr C'THLongTensor -> Ptr C'THHalfTensor -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THHalfTensor -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_copy : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THLongTensor_copy" + p_copy :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_copyByte : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THLongTensor_copyByte" + p_copyByte :: FunPtr (Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_copyChar : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THLongTensor_copyChar" + p_copyChar :: FunPtr (Ptr C'THLongTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_copyShort : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THLongTensor_copyShort" + p_copyShort :: FunPtr (Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_copyInt : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THLongTensor_copyInt" + p_copyInt :: FunPtr (Ptr C'THLongTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_copyLong : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THLongTensor_copyLong" + p_copyLong :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_copyFloat : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THLongTensor_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THLongTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_copyDouble : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THLongTensor_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THLongTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_copyHalf : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THLongTensor_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THLongTensor -> Ptr C'THHalfTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Long/TensorMath.hs b/src/Torch/FFI/TH/Long/TensorMath.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Long/TensorMath.hs @@ -0,0 +1,1412 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.TensorMath where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : r_ value -> void +foreign import ccall "THTensorMath.h THLongTensor_fill" + c_fill_ :: Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> IO () +c_fill = const c_fill_ + +-- | c_zero : r_ -> void +foreign import ccall "THTensorMath.h THLongTensor_zero" + c_zero_ :: Ptr C'THLongTensor -> IO () + +-- | alias of c_zero_ with unused argument (for CTHState) to unify backpack signatures. +c_zero :: Ptr C'THState -> Ptr C'THLongTensor -> IO () +c_zero = const c_zero_ + +-- | c_maskedFill : tensor mask value -> void +foreign import ccall "THTensorMath.h THLongTensor_maskedFill" + c_maskedFill_ :: Ptr C'THLongTensor -> Ptr C'THByteTensor -> CLong -> IO () + +-- | alias of c_maskedFill_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedFill :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> CLong -> IO () +c_maskedFill = const c_maskedFill_ + +-- | c_maskedCopy : tensor mask src -> void +foreign import ccall "THTensorMath.h THLongTensor_maskedCopy" + c_maskedCopy_ :: Ptr C'THLongTensor -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_maskedCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedCopy :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> IO () +c_maskedCopy = const c_maskedCopy_ + +-- | c_maskedSelect : tensor src mask -> void +foreign import ccall "THTensorMath.h THLongTensor_maskedSelect" + c_maskedSelect_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_maskedSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedSelect :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO () +c_maskedSelect = const c_maskedSelect_ + +-- | c_nonzero : subscript tensor -> void +foreign import ccall "THTensorMath.h THLongTensor_nonzero" + c_nonzero_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_nonzero_ with unused argument (for CTHState) to unify backpack signatures. +c_nonzero :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_nonzero = const c_nonzero_ + +-- | c_indexSelect : tensor src dim index -> void +foreign import ccall "THTensorMath.h THLongTensor_indexSelect" + c_indexSelect_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_indexSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_indexSelect :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_indexSelect = const c_indexSelect_ + +-- | c_indexCopy : tensor dim index src -> void +foreign import ccall "THTensorMath.h THLongTensor_indexCopy" + c_indexCopy_ :: Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_indexCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_indexCopy :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_indexCopy = const c_indexCopy_ + +-- | c_indexAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THLongTensor_indexAdd" + c_indexAdd_ :: Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_indexAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_indexAdd :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_indexAdd = const c_indexAdd_ + +-- | c_indexFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THLongTensor_indexFill" + c_indexFill_ :: Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_indexFill_ with unused argument (for CTHState) to unify backpack signatures. +c_indexFill :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> CLong -> IO () +c_indexFill = const c_indexFill_ + +-- | c_take : tensor src index -> void +foreign import ccall "THTensorMath.h THLongTensor_take" + c_take_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_take_ with unused argument (for CTHState) to unify backpack signatures. +c_take :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_take = const c_take_ + +-- | c_put : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h THLongTensor_put" + c_put_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_put_ with unused argument (for CTHState) to unify backpack signatures. +c_put :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () +c_put = const c_put_ + +-- | c_gather : tensor src dim index -> void +foreign import ccall "THTensorMath.h THLongTensor_gather" + c_gather_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_gather_ with unused argument (for CTHState) to unify backpack signatures. +c_gather :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_gather = const c_gather_ + +-- | c_scatter : tensor dim index src -> void +foreign import ccall "THTensorMath.h THLongTensor_scatter" + c_scatter_ :: Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_scatter_ with unused argument (for CTHState) to unify backpack signatures. +c_scatter :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_scatter = const c_scatter_ + +-- | c_scatterAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THLongTensor_scatterAdd" + c_scatterAdd_ :: Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_scatterAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterAdd :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_scatterAdd = const c_scatterAdd_ + +-- | c_scatterFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THLongTensor_scatterFill" + c_scatterFill_ :: Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_scatterFill_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterFill :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> CLong -> IO () +c_scatterFill = const c_scatterFill_ + +-- | c_dot : t src -> accreal +foreign import ccall "THTensorMath.h THLongTensor_dot" + c_dot_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CLong + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CLong +c_dot = const c_dot_ + +-- | c_minall : t -> real +foreign import ccall "THTensorMath.h THLongTensor_minall" + c_minall_ :: Ptr C'THLongTensor -> IO CLong + +-- | alias of c_minall_ with unused argument (for CTHState) to unify backpack signatures. +c_minall :: Ptr C'THState -> Ptr C'THLongTensor -> IO CLong +c_minall = const c_minall_ + +-- | c_maxall : t -> real +foreign import ccall "THTensorMath.h THLongTensor_maxall" + c_maxall_ :: Ptr C'THLongTensor -> IO CLong + +-- | alias of c_maxall_ with unused argument (for CTHState) to unify backpack signatures. +c_maxall :: Ptr C'THState -> Ptr C'THLongTensor -> IO CLong +c_maxall = const c_maxall_ + +-- | c_medianall : t -> real +foreign import ccall "THTensorMath.h THLongTensor_medianall" + c_medianall_ :: Ptr C'THLongTensor -> IO CLong + +-- | alias of c_medianall_ with unused argument (for CTHState) to unify backpack signatures. +c_medianall :: Ptr C'THState -> Ptr C'THLongTensor -> IO CLong +c_medianall = const c_medianall_ + +-- | c_sumall : t -> accreal +foreign import ccall "THTensorMath.h THLongTensor_sumall" + c_sumall_ :: Ptr C'THLongTensor -> IO CLong + +-- | alias of c_sumall_ with unused argument (for CTHState) to unify backpack signatures. +c_sumall :: Ptr C'THState -> Ptr C'THLongTensor -> IO CLong +c_sumall = const c_sumall_ + +-- | c_prodall : t -> accreal +foreign import ccall "THTensorMath.h THLongTensor_prodall" + c_prodall_ :: Ptr C'THLongTensor -> IO CLong + +-- | alias of c_prodall_ with unused argument (for CTHState) to unify backpack signatures. +c_prodall :: Ptr C'THState -> Ptr C'THLongTensor -> IO CLong +c_prodall = const c_prodall_ + +-- | c_neg : self src -> void +foreign import ccall "THTensorMath.h THLongTensor_neg" + c_neg_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_neg = const c_neg_ + +-- | c_add : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_add" + c_add_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_add_ with unused argument (for CTHState) to unify backpack signatures. +c_add :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_add = const c_add_ + +-- | c_sub : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_sub" + c_sub_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_sub_ with unused argument (for CTHState) to unify backpack signatures. +c_sub :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_sub = const c_sub_ + +-- | c_add_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THLongTensor_add_scaled" + c_add_scaled_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> CLong -> IO () + +-- | alias of c_add_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_add_scaled :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> CLong -> IO () +c_add_scaled = const c_add_scaled_ + +-- | c_sub_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THLongTensor_sub_scaled" + c_sub_scaled_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> CLong -> IO () + +-- | alias of c_sub_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_sub_scaled :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> CLong -> IO () +c_sub_scaled = const c_sub_scaled_ + +-- | c_mul : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_mul" + c_mul_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_mul_ with unused argument (for CTHState) to unify backpack signatures. +c_mul :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_mul = const c_mul_ + +-- | c_div : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_div" + c_div_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_div_ with unused argument (for CTHState) to unify backpack signatures. +c_div :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_div = const c_div_ + +-- | c_lshift : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_lshift" + c_lshift_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_lshift_ with unused argument (for CTHState) to unify backpack signatures. +c_lshift :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_lshift = const c_lshift_ + +-- | c_rshift : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_rshift" + c_rshift_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_rshift_ with unused argument (for CTHState) to unify backpack signatures. +c_rshift :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_rshift = const c_rshift_ + +-- | c_fmod : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_fmod" + c_fmod_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_fmod_ with unused argument (for CTHState) to unify backpack signatures. +c_fmod :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_fmod = const c_fmod_ + +-- | c_remainder : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_remainder" + c_remainder_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_remainder_ with unused argument (for CTHState) to unify backpack signatures. +c_remainder :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_remainder = const c_remainder_ + +-- | c_clamp : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h THLongTensor_clamp" + c_clamp_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> CLong -> IO () + +-- | alias of c_clamp_ with unused argument (for CTHState) to unify backpack signatures. +c_clamp :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> CLong -> IO () +c_clamp = const c_clamp_ + +-- | c_bitand : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_bitand" + c_bitand_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_bitand_ with unused argument (for CTHState) to unify backpack signatures. +c_bitand :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_bitand = const c_bitand_ + +-- | c_bitor : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_bitor" + c_bitor_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_bitor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitor :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_bitor = const c_bitor_ + +-- | c_bitxor : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_bitxor" + c_bitxor_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_bitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitxor :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_bitxor = const c_bitxor_ + +-- | c_cadd : r_ t value src -> void +foreign import ccall "THTensorMath.h THLongTensor_cadd" + c_cadd_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> IO () +c_cadd = const c_cadd_ + +-- | c_csub : self src1 value src2 -> void +foreign import ccall "THTensorMath.h THLongTensor_csub" + c_csub_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> IO () + +-- | alias of c_csub_ with unused argument (for CTHState) to unify backpack signatures. +c_csub :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> IO () +c_csub = const c_csub_ + +-- | c_cmul : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cmul" + c_cmul_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cmul = const c_cmul_ + +-- | c_cpow : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cpow" + c_cpow_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cpow_ with unused argument (for CTHState) to unify backpack signatures. +c_cpow :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cpow = const c_cpow_ + +-- | c_cdiv : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cdiv" + c_cdiv_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cdiv = const c_cdiv_ + +-- | c_clshift : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_clshift" + c_clshift_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_clshift_ with unused argument (for CTHState) to unify backpack signatures. +c_clshift :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_clshift = const c_clshift_ + +-- | c_crshift : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_crshift" + c_crshift_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_crshift_ with unused argument (for CTHState) to unify backpack signatures. +c_crshift :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_crshift = const c_crshift_ + +-- | c_cfmod : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cfmod" + c_cfmod_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cfmod_ with unused argument (for CTHState) to unify backpack signatures. +c_cfmod :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cfmod = const c_cfmod_ + +-- | c_cremainder : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cremainder" + c_cremainder_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cremainder_ with unused argument (for CTHState) to unify backpack signatures. +c_cremainder :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cremainder = const c_cremainder_ + +-- | c_cbitand : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cbitand" + c_cbitand_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cbitand_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitand :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cbitand = const c_cbitand_ + +-- | c_cbitor : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cbitor" + c_cbitor_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cbitor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitor :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cbitor = const c_cbitor_ + +-- | c_cbitxor : r_ t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cbitxor" + c_cbitxor_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cbitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitxor :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cbitxor = const c_cbitxor_ + +-- | c_addcmul : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THLongTensor_addcmul" + c_addcmul_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_addcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_addcmul :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_addcmul = const c_addcmul_ + +-- | c_addcdiv : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THLongTensor_addcdiv" + c_addcdiv_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_addcdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_addcdiv :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_addcdiv = const c_addcdiv_ + +-- | c_addmv : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h THLongTensor_addmv" + c_addmv_ :: Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_addmv_ with unused argument (for CTHState) to unify backpack signatures. +c_addmv :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_addmv = const c_addmv_ + +-- | c_addmm : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h THLongTensor_addmm" + c_addmm_ :: Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_addmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addmm :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_addmm = const c_addmm_ + +-- | c_addr : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h THLongTensor_addr" + c_addr_ :: Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_addr_ with unused argument (for CTHState) to unify backpack signatures. +c_addr :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_addr = const c_addr_ + +-- | c_addbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THLongTensor_addbmm" + c_addbmm_ :: Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_addbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addbmm :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_addbmm = const c_addbmm_ + +-- | c_baddbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THLongTensor_baddbmm" + c_baddbmm_ :: Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_baddbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_baddbmm :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_baddbmm = const c_baddbmm_ + +-- | c_match : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h THLongTensor_match" + c_match_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_match_ with unused argument (for CTHState) to unify backpack signatures. +c_match :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_match = const c_match_ + +-- | c_numel : t -> ptrdiff_t +foreign import ccall "THTensorMath.h THLongTensor_numel" + c_numel_ :: Ptr C'THLongTensor -> IO CPtrdiff + +-- | alias of c_numel_ with unused argument (for CTHState) to unify backpack signatures. +c_numel :: Ptr C'THState -> Ptr C'THLongTensor -> IO CPtrdiff +c_numel = const c_numel_ + +-- | c_preserveReduceDimSemantics : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h THLongTensor_preserveReduceDimSemantics" + c_preserveReduceDimSemantics_ :: Ptr C'THLongTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_preserveReduceDimSemantics_ with unused argument (for CTHState) to unify backpack signatures. +c_preserveReduceDimSemantics :: Ptr C'THState -> Ptr C'THLongTensor -> CInt -> CInt -> CInt -> IO () +c_preserveReduceDimSemantics = const c_preserveReduceDimSemantics_ + +-- | c_max : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THLongTensor_max" + c_max_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () + +-- | alias of c_max_ with unused argument (for CTHState) to unify backpack signatures. +c_max :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () +c_max = const c_max_ + +-- | c_min : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THLongTensor_min" + c_min_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () + +-- | alias of c_min_ with unused argument (for CTHState) to unify backpack signatures. +c_min :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () +c_min = const c_min_ + +-- | c_kthvalue : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h THLongTensor_kthvalue" + c_kthvalue_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CInt -> CInt -> IO () + +-- | alias of c_kthvalue_ with unused argument (for CTHState) to unify backpack signatures. +c_kthvalue :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CInt -> CInt -> IO () +c_kthvalue = const c_kthvalue_ + +-- | c_mode : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THLongTensor_mode" + c_mode_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () + +-- | alias of c_mode_ with unused argument (for CTHState) to unify backpack signatures. +c_mode :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () +c_mode = const c_mode_ + +-- | c_median : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THLongTensor_median" + c_median_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () + +-- | alias of c_median_ with unused argument (for CTHState) to unify backpack signatures. +c_median :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () +c_median = const c_median_ + +-- | c_sum : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THLongTensor_sum" + c_sum_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () + +-- | alias of c_sum_ with unused argument (for CTHState) to unify backpack signatures. +c_sum :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () +c_sum = const c_sum_ + +-- | c_prod : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THLongTensor_prod" + c_prod_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () + +-- | alias of c_prod_ with unused argument (for CTHState) to unify backpack signatures. +c_prod :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () +c_prod = const c_prod_ + +-- | c_cumsum : r_ t dimension -> void +foreign import ccall "THTensorMath.h THLongTensor_cumsum" + c_cumsum_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_cumsum_ with unused argument (for CTHState) to unify backpack signatures. +c_cumsum :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () +c_cumsum = const c_cumsum_ + +-- | c_cumprod : r_ t dimension -> void +foreign import ccall "THTensorMath.h THLongTensor_cumprod" + c_cumprod_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_cumprod_ with unused argument (for CTHState) to unify backpack signatures. +c_cumprod :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () +c_cumprod = const c_cumprod_ + +-- | c_sign : r_ t -> void +foreign import ccall "THTensorMath.h THLongTensor_sign" + c_sign_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_sign_ with unused argument (for CTHState) to unify backpack signatures. +c_sign :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_sign = const c_sign_ + +-- | c_trace : t -> accreal +foreign import ccall "THTensorMath.h THLongTensor_trace" + c_trace_ :: Ptr C'THLongTensor -> IO CLong + +-- | alias of c_trace_ with unused argument (for CTHState) to unify backpack signatures. +c_trace :: Ptr C'THState -> Ptr C'THLongTensor -> IO CLong +c_trace = const c_trace_ + +-- | c_cross : r_ a b dimension -> void +foreign import ccall "THTensorMath.h THLongTensor_cross" + c_cross_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_cross_ with unused argument (for CTHState) to unify backpack signatures. +c_cross :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () +c_cross = const c_cross_ + +-- | c_cmax : r t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cmax" + c_cmax_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cmax_ with unused argument (for CTHState) to unify backpack signatures. +c_cmax :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cmax = const c_cmax_ + +-- | c_cmin : r t src -> void +foreign import ccall "THTensorMath.h THLongTensor_cmin" + c_cmin_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_cmin_ with unused argument (for CTHState) to unify backpack signatures. +c_cmin :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_cmin = const c_cmin_ + +-- | c_cmaxValue : r t value -> void +foreign import ccall "THTensorMath.h THLongTensor_cmaxValue" + c_cmaxValue_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_cmaxValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cmaxValue :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_cmaxValue = const c_cmaxValue_ + +-- | c_cminValue : r t value -> void +foreign import ccall "THTensorMath.h THLongTensor_cminValue" + c_cminValue_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_cminValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cminValue :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_cminValue = const c_cminValue_ + +-- | c_zeros : r_ size -> void +foreign import ccall "THTensorMath.h THLongTensor_zeros" + c_zeros_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_zeros_ with unused argument (for CTHState) to unify backpack signatures. +c_zeros :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO () +c_zeros = const c_zeros_ + +-- | c_zerosLike : r_ input -> void +foreign import ccall "THTensorMath.h THLongTensor_zerosLike" + c_zerosLike_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_zerosLike_ with unused argument (for CTHState) to unify backpack signatures. +c_zerosLike :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_zerosLike = const c_zerosLike_ + +-- | c_ones : r_ size -> void +foreign import ccall "THTensorMath.h THLongTensor_ones" + c_ones_ :: Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_ones_ with unused argument (for CTHState) to unify backpack signatures. +c_ones :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO () +c_ones = const c_ones_ + +-- | c_onesLike : r_ input -> void +foreign import ccall "THTensorMath.h THLongTensor_onesLike" + c_onesLike_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_onesLike_ with unused argument (for CTHState) to unify backpack signatures. +c_onesLike :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_onesLike = const c_onesLike_ + +-- | c_diag : r_ t k -> void +foreign import ccall "THTensorMath.h THLongTensor_diag" + c_diag_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_diag_ with unused argument (for CTHState) to unify backpack signatures. +c_diag :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () +c_diag = const c_diag_ + +-- | c_eye : r_ n m -> void +foreign import ccall "THTensorMath.h THLongTensor_eye" + c_eye_ :: Ptr C'THLongTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_eye_ with unused argument (for CTHState) to unify backpack signatures. +c_eye :: Ptr C'THState -> Ptr C'THLongTensor -> CLLong -> CLLong -> IO () +c_eye = const c_eye_ + +-- | c_arange : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THLongTensor_arange" + c_arange_ :: Ptr C'THLongTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_arange_ with unused argument (for CTHState) to unify backpack signatures. +c_arange :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> CLong -> IO () +c_arange = const c_arange_ + +-- | c_range : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THLongTensor_range" + c_range_ :: Ptr C'THLongTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_range_ with unused argument (for CTHState) to unify backpack signatures. +c_range :: Ptr C'THState -> Ptr C'THLongTensor -> CLong -> CLong -> CLong -> IO () +c_range = const c_range_ + +-- | c_randperm : r_ _generator n -> void +foreign import ccall "THTensorMath.h THLongTensor_randperm" + c_randperm_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_randperm_ with unused argument (for CTHState) to unify backpack signatures. +c_randperm :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_randperm = const c_randperm_ + +-- | c_reshape : r_ t size -> void +foreign import ccall "THTensorMath.h THLongTensor_reshape" + c_reshape_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_reshape_ with unused argument (for CTHState) to unify backpack signatures. +c_reshape :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO () +c_reshape = const c_reshape_ + +-- | c_sort : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h THLongTensor_sort" + c_sort_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () + +-- | alias of c_sort_ with unused argument (for CTHState) to unify backpack signatures. +c_sort :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO () +c_sort = const c_sort_ + +-- | c_topk : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h THLongTensor_topk" + c_topk_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_topk_ with unused argument (for CTHState) to unify backpack signatures. +c_topk :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CInt -> CInt -> CInt -> IO () +c_topk = const c_topk_ + +-- | c_tril : r_ t k -> void +foreign import ccall "THTensorMath.h THLongTensor_tril" + c_tril_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> IO () + +-- | alias of c_tril_ with unused argument (for CTHState) to unify backpack signatures. +c_tril :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> IO () +c_tril = const c_tril_ + +-- | c_triu : r_ t k -> void +foreign import ccall "THTensorMath.h THLongTensor_triu" + c_triu_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> IO () + +-- | alias of c_triu_ with unused argument (for CTHState) to unify backpack signatures. +c_triu :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> IO () +c_triu = const c_triu_ + +-- | c_cat : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h THLongTensor_cat" + c_cat_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () + +-- | alias of c_cat_ with unused argument (for CTHState) to unify backpack signatures. +c_cat :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO () +c_cat = const c_cat_ + +-- | c_catArray : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h THLongTensor_catArray" + c_catArray_ :: Ptr C'THLongTensor -> Ptr (Ptr C'THLongTensor) -> CInt -> CInt -> IO () + +-- | alias of c_catArray_ with unused argument (for CTHState) to unify backpack signatures. +c_catArray :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr (Ptr C'THLongTensor) -> CInt -> CInt -> IO () +c_catArray = const c_catArray_ + +-- | c_equal : ta tb -> int +foreign import ccall "THTensorMath.h THLongTensor_equal" + c_equal_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CInt + +-- | alias of c_equal_ with unused argument (for CTHState) to unify backpack signatures. +c_equal :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CInt +c_equal = const c_equal_ + +-- | c_ltValue : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_ltValue" + c_ltValue_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_ltValue_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_ltValue = const c_ltValue_ + +-- | c_leValue : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_leValue" + c_leValue_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_leValue_ with unused argument (for CTHState) to unify backpack signatures. +c_leValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_leValue = const c_leValue_ + +-- | c_gtValue : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_gtValue" + c_gtValue_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_gtValue_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_gtValue = const c_gtValue_ + +-- | c_geValue : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_geValue" + c_geValue_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_geValue_ with unused argument (for CTHState) to unify backpack signatures. +c_geValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_geValue = const c_geValue_ + +-- | c_neValue : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_neValue" + c_neValue_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_neValue_ with unused argument (for CTHState) to unify backpack signatures. +c_neValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_neValue = const c_neValue_ + +-- | c_eqValue : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_eqValue" + c_eqValue_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_eqValue_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_eqValue = const c_eqValue_ + +-- | c_ltValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_ltValueT" + c_ltValueT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_ltValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValueT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_ltValueT = const c_ltValueT_ + +-- | c_leValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_leValueT" + c_leValueT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_leValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_leValueT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_leValueT = const c_leValueT_ + +-- | c_gtValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_gtValueT" + c_gtValueT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_gtValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValueT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_gtValueT = const c_gtValueT_ + +-- | c_geValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_geValueT" + c_geValueT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_geValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_geValueT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_geValueT = const c_geValueT_ + +-- | c_neValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_neValueT" + c_neValueT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_neValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_neValueT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_neValueT = const c_neValueT_ + +-- | c_eqValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THLongTensor_eqValueT" + c_eqValueT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () + +-- | alias of c_eqValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValueT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO () +c_eqValueT = const c_eqValueT_ + +-- | c_ltTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_ltTensor" + c_ltTensor_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_ltTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_ltTensor = const c_ltTensor_ + +-- | c_leTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_leTensor" + c_leTensor_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_leTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_leTensor = const c_leTensor_ + +-- | c_gtTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_gtTensor" + c_gtTensor_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_gtTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_gtTensor = const c_gtTensor_ + +-- | c_geTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_geTensor" + c_geTensor_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_geTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_geTensor = const c_geTensor_ + +-- | c_neTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_neTensor" + c_neTensor_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_neTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_neTensor = const c_neTensor_ + +-- | c_eqTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_eqTensor" + c_eqTensor_ :: Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_eqTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_eqTensor = const c_eqTensor_ + +-- | c_ltTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_ltTensorT" + c_ltTensorT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_ltTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensorT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_ltTensorT = const c_ltTensorT_ + +-- | c_leTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_leTensorT" + c_leTensorT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_leTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensorT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_leTensorT = const c_leTensorT_ + +-- | c_gtTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_gtTensorT" + c_gtTensorT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_gtTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensorT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_gtTensorT = const c_gtTensorT_ + +-- | c_geTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_geTensorT" + c_geTensorT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_geTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensorT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_geTensorT = const c_geTensorT_ + +-- | c_neTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_neTensorT" + c_neTensorT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_neTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensorT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_neTensorT = const c_neTensorT_ + +-- | c_eqTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THLongTensor_eqTensorT" + c_eqTensorT_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_eqTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensorT :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_eqTensorT = const c_eqTensorT_ + +-- | c_abs : r_ t -> void +foreign import ccall "THTensorMath.h THLongTensor_abs" + c_abs_ :: Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO () +c_abs = const c_abs_ + +-- | p_fill : Pointer to function : r_ value -> void +foreign import ccall "THTensorMath.h &THLongTensor_fill" + p_fill :: FunPtr (Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_zero : Pointer to function : r_ -> void +foreign import ccall "THTensorMath.h &THLongTensor_zero" + p_zero :: FunPtr (Ptr C'THLongTensor -> IO ()) + +-- | p_maskedFill : Pointer to function : tensor mask value -> void +foreign import ccall "THTensorMath.h &THLongTensor_maskedFill" + p_maskedFill :: FunPtr (Ptr C'THLongTensor -> Ptr C'THByteTensor -> CLong -> IO ()) + +-- | p_maskedCopy : Pointer to function : tensor mask src -> void +foreign import ccall "THTensorMath.h &THLongTensor_maskedCopy" + p_maskedCopy :: FunPtr (Ptr C'THLongTensor -> Ptr C'THByteTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_maskedSelect : Pointer to function : tensor src mask -> void +foreign import ccall "THTensorMath.h &THLongTensor_maskedSelect" + p_maskedSelect :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_nonzero : Pointer to function : subscript tensor -> void +foreign import ccall "THTensorMath.h &THLongTensor_nonzero" + p_nonzero :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexSelect : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THLongTensor_indexSelect" + p_indexSelect :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexCopy : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THLongTensor_indexCopy" + p_indexCopy :: FunPtr (Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THLongTensor_indexAdd" + p_indexAdd :: FunPtr (Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THLongTensor_indexFill" + p_indexFill :: FunPtr (Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_take : Pointer to function : tensor src index -> void +foreign import ccall "THTensorMath.h &THLongTensor_take" + p_take :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_put : Pointer to function : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h &THLongTensor_put" + p_put :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_gather : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THLongTensor_gather" + p_gather :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_scatter : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THLongTensor_scatter" + p_scatter :: FunPtr (Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_scatterAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THLongTensor_scatterAdd" + p_scatterAdd :: FunPtr (Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_scatterFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THLongTensor_scatterFill" + p_scatterFill :: FunPtr (Ptr C'THLongTensor -> CInt -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_dot : Pointer to function : t src -> accreal +foreign import ccall "THTensorMath.h &THLongTensor_dot" + p_dot :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CLong) + +-- | p_minall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THLongTensor_minall" + p_minall :: FunPtr (Ptr C'THLongTensor -> IO CLong) + +-- | p_maxall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THLongTensor_maxall" + p_maxall :: FunPtr (Ptr C'THLongTensor -> IO CLong) + +-- | p_medianall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THLongTensor_medianall" + p_medianall :: FunPtr (Ptr C'THLongTensor -> IO CLong) + +-- | p_sumall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THLongTensor_sumall" + p_sumall :: FunPtr (Ptr C'THLongTensor -> IO CLong) + +-- | p_prodall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THLongTensor_prodall" + p_prodall :: FunPtr (Ptr C'THLongTensor -> IO CLong) + +-- | p_neg : Pointer to function : self src -> void +foreign import ccall "THTensorMath.h &THLongTensor_neg" + p_neg :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_add : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_add" + p_add :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_sub : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_sub" + p_sub :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_add_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THLongTensor_add_scaled" + p_add_scaled :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> CLong -> IO ()) + +-- | p_sub_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THLongTensor_sub_scaled" + p_sub_scaled :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> CLong -> IO ()) + +-- | p_mul : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_mul" + p_mul :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_div : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_div" + p_div :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_lshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_lshift" + p_lshift :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_rshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_rshift" + p_rshift :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_fmod : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_fmod" + p_fmod :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_remainder : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_remainder" + p_remainder :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_clamp : Pointer to function : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h &THLongTensor_clamp" + p_clamp :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> CLong -> IO ()) + +-- | p_bitand : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_bitand" + p_bitand :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_bitor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_bitor" + p_bitor :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_bitxor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_bitxor" + p_bitxor :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_cadd : Pointer to function : r_ t value src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cadd" + p_cadd :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> IO ()) + +-- | p_csub : Pointer to function : self src1 value src2 -> void +foreign import ccall "THTensorMath.h &THLongTensor_csub" + p_csub :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> IO ()) + +-- | p_cmul : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cmul" + p_cmul :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_cpow : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cpow" + p_cpow :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_cdiv : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cdiv" + p_cdiv :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_clshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_clshift" + p_clshift :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_crshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_crshift" + p_crshift :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_cfmod : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cfmod" + p_cfmod :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_cremainder : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cremainder" + p_cremainder :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_cbitand : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cbitand" + p_cbitand :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_cbitor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cbitor" + p_cbitor :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_cbitxor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cbitxor" + p_cbitxor :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_addcmul : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THLongTensor_addcmul" + p_addcmul :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_addcdiv : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THLongTensor_addcdiv" + p_addcdiv :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_addmv : Pointer to function : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h &THLongTensor_addmv" + p_addmv :: FunPtr (Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_addmm : Pointer to function : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h &THLongTensor_addmm" + p_addmm :: FunPtr (Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_addr : Pointer to function : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h &THLongTensor_addr" + p_addr :: FunPtr (Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_addbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THLongTensor_addbmm" + p_addbmm :: FunPtr (Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_baddbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THLongTensor_baddbmm" + p_baddbmm :: FunPtr (Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> CLong -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_match : Pointer to function : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h &THLongTensor_match" + p_match :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_numel : Pointer to function : t -> ptrdiff_t +foreign import ccall "THTensorMath.h &THLongTensor_numel" + p_numel :: FunPtr (Ptr C'THLongTensor -> IO CPtrdiff) + +-- | p_preserveReduceDimSemantics : Pointer to function : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h &THLongTensor_preserveReduceDimSemantics" + p_preserveReduceDimSemantics :: FunPtr (Ptr C'THLongTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_max : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THLongTensor_max" + p_max :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO ()) + +-- | p_min : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THLongTensor_min" + p_min :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO ()) + +-- | p_kthvalue : Pointer to function : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h &THLongTensor_kthvalue" + p_kthvalue :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CInt -> CInt -> IO ()) + +-- | p_mode : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THLongTensor_mode" + p_mode :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO ()) + +-- | p_median : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THLongTensor_median" + p_median :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO ()) + +-- | p_sum : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THLongTensor_sum" + p_sum :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO ()) + +-- | p_prod : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THLongTensor_prod" + p_prod :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO ()) + +-- | p_cumsum : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THLongTensor_cumsum" + p_cumsum :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_cumprod : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THLongTensor_cumprod" + p_cumprod :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_sign : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THLongTensor_sign" + p_sign :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_trace : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THLongTensor_trace" + p_trace :: FunPtr (Ptr C'THLongTensor -> IO CLong) + +-- | p_cross : Pointer to function : r_ a b dimension -> void +foreign import ccall "THTensorMath.h &THLongTensor_cross" + p_cross :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_cmax : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cmax" + p_cmax :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_cmin : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THLongTensor_cmin" + p_cmin :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_cmaxValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_cmaxValue" + p_cmaxValue :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_cminValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_cminValue" + p_cminValue :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_zeros : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THLongTensor_zeros" + p_zeros :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_zerosLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THLongTensor_zerosLike" + p_zerosLike :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_ones : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THLongTensor_ones" + p_ones :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_onesLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THLongTensor_onesLike" + p_onesLike :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_diag : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THLongTensor_diag" + p_diag :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_eye : Pointer to function : r_ n m -> void +foreign import ccall "THTensorMath.h &THLongTensor_eye" + p_eye :: FunPtr (Ptr C'THLongTensor -> CLLong -> CLLong -> IO ()) + +-- | p_arange : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THLongTensor_arange" + p_arange :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_range : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THLongTensor_range" + p_range :: FunPtr (Ptr C'THLongTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_randperm : Pointer to function : r_ _generator n -> void +foreign import ccall "THTensorMath.h &THLongTensor_randperm" + p_randperm :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_reshape : Pointer to function : r_ t size -> void +foreign import ccall "THTensorMath.h &THLongTensor_reshape" + p_reshape :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_sort : Pointer to function : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h &THLongTensor_sort" + p_sort :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> CInt -> IO ()) + +-- | p_topk : Pointer to function : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h &THLongTensor_topk" + p_topk :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> CInt -> CInt -> CInt -> IO ()) + +-- | p_tril : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THLongTensor_tril" + p_tril :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> IO ()) + +-- | p_triu : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THLongTensor_triu" + p_triu :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLLong -> IO ()) + +-- | p_cat : Pointer to function : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h &THLongTensor_cat" + p_cat :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> CInt -> IO ()) + +-- | p_catArray : Pointer to function : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h &THLongTensor_catArray" + p_catArray :: FunPtr (Ptr C'THLongTensor -> Ptr (Ptr C'THLongTensor) -> CInt -> CInt -> IO ()) + +-- | p_equal : Pointer to function : ta tb -> int +foreign import ccall "THTensorMath.h &THLongTensor_equal" + p_equal :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO CInt) + +-- | p_ltValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_ltValue" + p_ltValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_leValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_leValue" + p_leValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_gtValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_gtValue" + p_gtValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_geValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_geValue" + p_geValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_neValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_neValue" + p_neValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_eqValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_eqValue" + p_eqValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_ltValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_ltValueT" + p_ltValueT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_leValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_leValueT" + p_leValueT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_gtValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_gtValueT" + p_gtValueT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_geValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_geValueT" + p_geValueT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_neValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_neValueT" + p_neValueT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_eqValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THLongTensor_eqValueT" + p_eqValueT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> CLong -> IO ()) + +-- | p_ltTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_ltTensor" + p_ltTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_leTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_leTensor" + p_leTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_gtTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_gtTensor" + p_gtTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_geTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_geTensor" + p_geTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_neTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_neTensor" + p_neTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_eqTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_eqTensor" + p_eqTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_ltTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_ltTensorT" + p_ltTensorT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_leTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_leTensorT" + p_leTensorT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_gtTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_gtTensorT" + p_gtTensorT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_geTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_geTensorT" + p_geTensorT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_neTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_neTensorT" + p_neTensorT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_eqTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THLongTensor_eqTensorT" + p_eqTensorT :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_abs : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THLongTensor_abs" + p_abs :: FunPtr (Ptr C'THLongTensor -> Ptr C'THLongTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Long/TensorRandom.hs b/src/Torch/FFI/TH/Long/TensorRandom.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Long/TensorRandom.hs @@ -0,0 +1,92 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.TensorRandom where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_random : self _generator -> void +foreign import ccall "THTensorRandom.h THLongTensor_random" + c_random_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> IO () + +-- | alias of c_random_ with unused argument (for CTHState) to unify backpack signatures. +c_random :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> IO () +c_random = const c_random_ + +-- | c_clampedRandom : self _generator min max -> void +foreign import ccall "THTensorRandom.h THLongTensor_clampedRandom" + c_clampedRandom_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () + +-- | alias of c_clampedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_clampedRandom :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () +c_clampedRandom = const c_clampedRandom_ + +-- | c_cappedRandom : self _generator max -> void +foreign import ccall "THTensorRandom.h THLongTensor_cappedRandom" + c_cappedRandom_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_cappedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_cappedRandom :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_cappedRandom = const c_cappedRandom_ + +-- | c_geometric : self _generator p -> void +foreign import ccall "THTensorRandom.h THLongTensor_geometric" + c_geometric_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_geometric_ with unused argument (for CTHState) to unify backpack signatures. +c_geometric :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_geometric = const c_geometric_ + +-- | c_bernoulli : self _generator p -> void +foreign import ccall "THTensorRandom.h THLongTensor_bernoulli" + c_bernoulli_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_bernoulli_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_bernoulli = const c_bernoulli_ + +-- | c_bernoulli_FloatTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THLongTensor_bernoulli_FloatTensor" + c_bernoulli_FloatTensor_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_bernoulli_FloatTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_FloatTensor :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () +c_bernoulli_FloatTensor = const c_bernoulli_FloatTensor_ + +-- | c_bernoulli_DoubleTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THLongTensor_bernoulli_DoubleTensor" + c_bernoulli_DoubleTensor_ :: Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_bernoulli_DoubleTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_DoubleTensor :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () +c_bernoulli_DoubleTensor = const c_bernoulli_DoubleTensor_ + +-- | p_random : Pointer to function : self _generator -> void +foreign import ccall "THTensorRandom.h &THLongTensor_random" + p_random :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> IO ()) + +-- | p_clampedRandom : Pointer to function : self _generator min max -> void +foreign import ccall "THTensorRandom.h &THLongTensor_clampedRandom" + p_clampedRandom :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO ()) + +-- | p_cappedRandom : Pointer to function : self _generator max -> void +foreign import ccall "THTensorRandom.h &THLongTensor_cappedRandom" + p_cappedRandom :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_geometric : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THLongTensor_geometric" + p_geometric :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THLongTensor_bernoulli" + p_bernoulli :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli_FloatTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THLongTensor_bernoulli_FloatTensor" + p_bernoulli_FloatTensor :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO ()) + +-- | p_bernoulli_DoubleTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THLongTensor_bernoulli_DoubleTensor" + p_bernoulli_DoubleTensor :: FunPtr (Ptr C'THLongTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Long/Vector.hs b/src/Torch/FFI/TH/Long/Vector.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Long/Vector.hs @@ -0,0 +1,140 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Long.Vector where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : x c n -> void +foreign import ccall "THVector.h THLongVector_fill" + c_fill_ :: Ptr CLong -> CLong -> CPtrdiff -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr CLong -> CLong -> CPtrdiff -> IO () +c_fill = const c_fill_ + +-- | c_cadd : z x y c n -> void +foreign import ccall "THVector.h THLongVector_cadd" + c_cadd_ :: Ptr CLong -> Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr CLong -> Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO () +c_cadd = const c_cadd_ + +-- | c_adds : y x c n -> void +foreign import ccall "THVector.h THLongVector_adds" + c_adds_ :: Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO () + +-- | alias of c_adds_ with unused argument (for CTHState) to unify backpack signatures. +c_adds :: Ptr C'THState -> Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO () +c_adds = const c_adds_ + +-- | c_cmul : z x y n -> void +foreign import ccall "THVector.h THLongVector_cmul" + c_cmul_ :: Ptr CLong -> Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr CLong -> Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () +c_cmul = const c_cmul_ + +-- | c_muls : y x c n -> void +foreign import ccall "THVector.h THLongVector_muls" + c_muls_ :: Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO () + +-- | alias of c_muls_ with unused argument (for CTHState) to unify backpack signatures. +c_muls :: Ptr C'THState -> Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO () +c_muls = const c_muls_ + +-- | c_cdiv : z x y n -> void +foreign import ccall "THVector.h THLongVector_cdiv" + c_cdiv_ :: Ptr CLong -> Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr CLong -> Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () +c_cdiv = const c_cdiv_ + +-- | c_divs : y x c n -> void +foreign import ccall "THVector.h THLongVector_divs" + c_divs_ :: Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO () + +-- | alias of c_divs_ with unused argument (for CTHState) to unify backpack signatures. +c_divs :: Ptr C'THState -> Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO () +c_divs = const c_divs_ + +-- | c_copy : y x n -> void +foreign import ccall "THVector.h THLongVector_copy" + c_copy_ :: Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () +c_copy = const c_copy_ + +-- | c_neg : y x n -> void +foreign import ccall "THVector.h THLongVector_neg" + c_neg_ :: Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () +c_neg = const c_neg_ + +-- | c_normal_fill : data size generator mean stddev -> void +foreign import ccall "THVector.h THLongVector_normal_fill" + c_normal_fill_ :: Ptr CLong -> CLLong -> Ptr C'THGenerator -> CLong -> CLong -> IO () + +-- | alias of c_normal_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_fill :: Ptr C'THState -> Ptr CLong -> CLLong -> Ptr C'THGenerator -> CLong -> CLong -> IO () +c_normal_fill = const c_normal_fill_ + +-- | c_abs : y x n -> void +foreign import ccall "THVector.h THLongVector_abs" + c_abs_ :: Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr CLong -> Ptr CLong -> CPtrdiff -> IO () +c_abs = const c_abs_ + +-- | p_fill : Pointer to function : x c n -> void +foreign import ccall "THVector.h &THLongVector_fill" + p_fill :: FunPtr (Ptr CLong -> CLong -> CPtrdiff -> IO ()) + +-- | p_cadd : Pointer to function : z x y c n -> void +foreign import ccall "THVector.h &THLongVector_cadd" + p_cadd :: FunPtr (Ptr CLong -> Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO ()) + +-- | p_adds : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THLongVector_adds" + p_adds :: FunPtr (Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO ()) + +-- | p_cmul : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THLongVector_cmul" + p_cmul :: FunPtr (Ptr CLong -> Ptr CLong -> Ptr CLong -> CPtrdiff -> IO ()) + +-- | p_muls : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THLongVector_muls" + p_muls :: FunPtr (Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO ()) + +-- | p_cdiv : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THLongVector_cdiv" + p_cdiv :: FunPtr (Ptr CLong -> Ptr CLong -> Ptr CLong -> CPtrdiff -> IO ()) + +-- | p_divs : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THLongVector_divs" + p_divs :: FunPtr (Ptr CLong -> Ptr CLong -> CLong -> CPtrdiff -> IO ()) + +-- | p_copy : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THLongVector_copy" + p_copy :: FunPtr (Ptr CLong -> Ptr CLong -> CPtrdiff -> IO ()) + +-- | p_neg : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THLongVector_neg" + p_neg :: FunPtr (Ptr CLong -> Ptr CLong -> CPtrdiff -> IO ()) + +-- | p_normal_fill : Pointer to function : data size generator mean stddev -> void +foreign import ccall "THVector.h &THLongVector_normal_fill" + p_normal_fill :: FunPtr (Ptr CLong -> CLLong -> Ptr C'THGenerator -> CLong -> CLong -> IO ()) + +-- | p_abs : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THLongVector_abs" + p_abs :: FunPtr (Ptr CLong -> Ptr CLong -> CPtrdiff -> IO ()) diff --git a/src/Torch/FFI/TH/MemoryFile.hs b/src/Torch/FFI/TH/MemoryFile.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/MemoryFile.hs @@ -0,0 +1,40 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.MemoryFile where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_THMemoryFile_newWithStorage : storage mode -> THFile * +foreign import ccall "THMemoryFile.h THMemoryFile_newWithStorage" + c_THMemoryFile_newWithStorage :: Ptr C'THCharStorage -> Ptr CChar -> IO (Ptr C'THFile) + +-- | c_THMemoryFile_new : mode -> THFile * +foreign import ccall "THMemoryFile.h THMemoryFile_new" + c_THMemoryFile_new :: Ptr CChar -> IO (Ptr C'THFile) + +-- | c_THMemoryFile_storage : self -> THCharStorage * +foreign import ccall "THMemoryFile.h THMemoryFile_storage" + c_THMemoryFile_storage :: Ptr C'THFile -> IO (Ptr C'THCharStorage) + +-- | c_THMemoryFile_longSize : self size -> void +foreign import ccall "THMemoryFile.h THMemoryFile_longSize" + c_THMemoryFile_longSize :: Ptr C'THFile -> CInt -> IO () + +-- | p_THMemoryFile_newWithStorage : Pointer to function : storage mode -> THFile * +foreign import ccall "THMemoryFile.h &THMemoryFile_newWithStorage" + p_THMemoryFile_newWithStorage :: FunPtr (Ptr C'THCharStorage -> Ptr CChar -> IO (Ptr C'THFile)) + +-- | p_THMemoryFile_new : Pointer to function : mode -> THFile * +foreign import ccall "THMemoryFile.h &THMemoryFile_new" + p_THMemoryFile_new :: FunPtr (Ptr CChar -> IO (Ptr C'THFile)) + +-- | p_THMemoryFile_storage : Pointer to function : self -> THCharStorage * +foreign import ccall "THMemoryFile.h &THMemoryFile_storage" + p_THMemoryFile_storage :: FunPtr (Ptr C'THFile -> IO (Ptr C'THCharStorage)) + +-- | p_THMemoryFile_longSize : Pointer to function : self size -> void +foreign import ccall "THMemoryFile.h &THMemoryFile_longSize" + p_THMemoryFile_longSize :: FunPtr (Ptr C'THFile -> CInt -> IO ()) diff --git a/src/Torch/FFI/TH/Random.hs b/src/Torch/FFI/TH/Random.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Random.hs @@ -0,0 +1,152 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Random where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_THGenerator_new : -> THGenerator * +foreign import ccall "THRandom.h THGenerator_new" + c_THGenerator_new :: IO (Ptr C'THGenerator) + +-- | c_THGenerator_copy : self from -> THGenerator * +foreign import ccall "THRandom.h THGenerator_copy" + c_THGenerator_copy :: Ptr C'THGenerator -> Ptr C'THGenerator -> IO (Ptr C'THGenerator) + +-- | c_THGenerator_free : gen -> void +foreign import ccall "THRandom.h THGenerator_free" + c_THGenerator_free :: Ptr C'THGenerator -> IO () + +-- | c_THRandom_seed : _generator -> uint64_t +foreign import ccall "THRandom.h THRandom_seed" + c_THRandom_seed :: Ptr C'THGenerator -> IO CULong + +-- | c_THRandom_manualSeed : _generator the_seed_ -> void +foreign import ccall "THRandom.h THRandom_manualSeed" + c_THRandom_manualSeed :: Ptr C'THGenerator -> CULong -> IO () + +-- | c_THRandom_initialSeed : _generator -> uint64_t +foreign import ccall "THRandom.h THRandom_initialSeed" + c_THRandom_initialSeed :: Ptr C'THGenerator -> IO CULong + +-- | c_THRandom_random : _generator -> uint64_t +foreign import ccall "THRandom.h THRandom_random" + c_THRandom_random :: Ptr C'THGenerator -> IO CULong + +-- | c_THRandom_random64 : _generator -> uint64_t +foreign import ccall "THRandom.h THRandom_random64" + c_THRandom_random64 :: Ptr C'THGenerator -> IO CULong + +-- | c_THRandom_standard_uniform : _generator -> double +foreign import ccall "THRandom.h THRandom_standard_uniform" + c_THRandom_standard_uniform :: Ptr C'THGenerator -> IO CDouble + +-- | c_THRandom_uniform : _generator a b -> double +foreign import ccall "THRandom.h THRandom_uniform" + c_THRandom_uniform :: Ptr C'THGenerator -> CDouble -> CDouble -> IO CDouble + +-- | c_THRandom_uniformFloat : _generator a b -> float +foreign import ccall "THRandom.h THRandom_uniformFloat" + c_THRandom_uniformFloat :: Ptr C'THGenerator -> CFloat -> CFloat -> IO CFloat + +-- | c_THRandom_normal : _generator mean stdv -> double +foreign import ccall "THRandom.h THRandom_normal" + c_THRandom_normal :: Ptr C'THGenerator -> CDouble -> CDouble -> IO CDouble + +-- | c_THRandom_exponential : _generator lambda -> double +foreign import ccall "THRandom.h THRandom_exponential" + c_THRandom_exponential :: Ptr C'THGenerator -> CDouble -> IO CDouble + +-- | c_THRandom_standard_gamma : _generator alpha -> double +foreign import ccall "THRandom.h THRandom_standard_gamma" + c_THRandom_standard_gamma :: Ptr C'THGenerator -> CDouble -> IO CDouble + +-- | c_THRandom_cauchy : _generator median sigma -> double +foreign import ccall "THRandom.h THRandom_cauchy" + c_THRandom_cauchy :: Ptr C'THGenerator -> CDouble -> CDouble -> IO CDouble + +-- | c_THRandom_logNormal : _generator mean stdv -> double +foreign import ccall "THRandom.h THRandom_logNormal" + c_THRandom_logNormal :: Ptr C'THGenerator -> CDouble -> CDouble -> IO CDouble + +-- | c_THRandom_geometric : _generator p -> int +foreign import ccall "THRandom.h THRandom_geometric" + c_THRandom_geometric :: Ptr C'THGenerator -> CDouble -> IO CInt + +-- | c_THRandom_bernoulli : _generator p -> int +foreign import ccall "THRandom.h THRandom_bernoulli" + c_THRandom_bernoulli :: Ptr C'THGenerator -> CDouble -> IO CInt + +-- | p_THGenerator_new : Pointer to function : -> THGenerator * +foreign import ccall "THRandom.h &THGenerator_new" + p_THGenerator_new :: FunPtr (IO (Ptr C'THGenerator)) + +-- | p_THGenerator_copy : Pointer to function : self from -> THGenerator * +foreign import ccall "THRandom.h &THGenerator_copy" + p_THGenerator_copy :: FunPtr (Ptr C'THGenerator -> Ptr C'THGenerator -> IO (Ptr C'THGenerator)) + +-- | p_THGenerator_free : Pointer to function : gen -> void +foreign import ccall "THRandom.h &THGenerator_free" + p_THGenerator_free :: FunPtr (Ptr C'THGenerator -> IO ()) + +-- | p_THRandom_seed : Pointer to function : _generator -> uint64_t +foreign import ccall "THRandom.h &THRandom_seed" + p_THRandom_seed :: FunPtr (Ptr C'THGenerator -> IO CULong) + +-- | p_THRandom_manualSeed : Pointer to function : _generator the_seed_ -> void +foreign import ccall "THRandom.h &THRandom_manualSeed" + p_THRandom_manualSeed :: FunPtr (Ptr C'THGenerator -> CULong -> IO ()) + +-- | p_THRandom_initialSeed : Pointer to function : _generator -> uint64_t +foreign import ccall "THRandom.h &THRandom_initialSeed" + p_THRandom_initialSeed :: FunPtr (Ptr C'THGenerator -> IO CULong) + +-- | p_THRandom_random : Pointer to function : _generator -> uint64_t +foreign import ccall "THRandom.h &THRandom_random" + p_THRandom_random :: FunPtr (Ptr C'THGenerator -> IO CULong) + +-- | p_THRandom_random64 : Pointer to function : _generator -> uint64_t +foreign import ccall "THRandom.h &THRandom_random64" + p_THRandom_random64 :: FunPtr (Ptr C'THGenerator -> IO CULong) + +-- | p_THRandom_standard_uniform : Pointer to function : _generator -> double +foreign import ccall "THRandom.h &THRandom_standard_uniform" + p_THRandom_standard_uniform :: FunPtr (Ptr C'THGenerator -> IO CDouble) + +-- | p_THRandom_uniform : Pointer to function : _generator a b -> double +foreign import ccall "THRandom.h &THRandom_uniform" + p_THRandom_uniform :: FunPtr (Ptr C'THGenerator -> CDouble -> CDouble -> IO CDouble) + +-- | p_THRandom_uniformFloat : Pointer to function : _generator a b -> float +foreign import ccall "THRandom.h &THRandom_uniformFloat" + p_THRandom_uniformFloat :: FunPtr (Ptr C'THGenerator -> CFloat -> CFloat -> IO CFloat) + +-- | p_THRandom_normal : Pointer to function : _generator mean stdv -> double +foreign import ccall "THRandom.h &THRandom_normal" + p_THRandom_normal :: FunPtr (Ptr C'THGenerator -> CDouble -> CDouble -> IO CDouble) + +-- | p_THRandom_exponential : Pointer to function : _generator lambda -> double +foreign import ccall "THRandom.h &THRandom_exponential" + p_THRandom_exponential :: FunPtr (Ptr C'THGenerator -> CDouble -> IO CDouble) + +-- | p_THRandom_standard_gamma : Pointer to function : _generator alpha -> double +foreign import ccall "THRandom.h &THRandom_standard_gamma" + p_THRandom_standard_gamma :: FunPtr (Ptr C'THGenerator -> CDouble -> IO CDouble) + +-- | p_THRandom_cauchy : Pointer to function : _generator median sigma -> double +foreign import ccall "THRandom.h &THRandom_cauchy" + p_THRandom_cauchy :: FunPtr (Ptr C'THGenerator -> CDouble -> CDouble -> IO CDouble) + +-- | p_THRandom_logNormal : Pointer to function : _generator mean stdv -> double +foreign import ccall "THRandom.h &THRandom_logNormal" + p_THRandom_logNormal :: FunPtr (Ptr C'THGenerator -> CDouble -> CDouble -> IO CDouble) + +-- | p_THRandom_geometric : Pointer to function : _generator p -> int +foreign import ccall "THRandom.h &THRandom_geometric" + p_THRandom_geometric :: FunPtr (Ptr C'THGenerator -> CDouble -> IO CInt) + +-- | p_THRandom_bernoulli : Pointer to function : _generator p -> int +foreign import ccall "THRandom.h &THRandom_bernoulli" + p_THRandom_bernoulli :: FunPtr (Ptr C'THGenerator -> CDouble -> IO CInt) diff --git a/src/Torch/FFI/TH/Short/Blas.hs b/src/Torch/FFI/TH/Short/Blas.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Short/Blas.hs @@ -0,0 +1,104 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.Blas where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_swap : n x incx y incy -> void +foreign import ccall "THBlas.h THShortBlas_swap" + c_swap_ :: CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO () +c_swap = const c_swap_ + +-- | c_scal : n a x incx -> void +foreign import ccall "THBlas.h THShortBlas_scal" + c_scal_ :: CLLong -> CShort -> Ptr CShort -> CLLong -> IO () + +-- | alias of c_scal_ with unused argument (for CTHState) to unify backpack signatures. +c_scal :: Ptr C'THState -> CLLong -> CShort -> Ptr CShort -> CLLong -> IO () +c_scal = const c_scal_ + +-- | c_copy : n x incx y incy -> void +foreign import ccall "THBlas.h THShortBlas_copy" + c_copy_ :: CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO () +c_copy = const c_copy_ + +-- | c_axpy : n a x incx y incy -> void +foreign import ccall "THBlas.h THShortBlas_axpy" + c_axpy_ :: CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO () + +-- | alias of c_axpy_ with unused argument (for CTHState) to unify backpack signatures. +c_axpy :: Ptr C'THState -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO () +c_axpy = const c_axpy_ + +-- | c_dot : n x incx y incy -> real +foreign import ccall "THBlas.h THShortBlas_dot" + c_dot_ :: CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO CShort + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO CShort +c_dot = const c_dot_ + +-- | c_gemv : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h THShortBlas_gemv" + c_gemv_ :: CChar -> CLLong -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> CShort -> Ptr CShort -> CLLong -> IO () + +-- | alias of c_gemv_ with unused argument (for CTHState) to unify backpack signatures. +c_gemv :: Ptr C'THState -> CChar -> CLLong -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> CShort -> Ptr CShort -> CLLong -> IO () +c_gemv = const c_gemv_ + +-- | c_ger : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h THShortBlas_ger" + c_ger_ :: CLLong -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO () + +-- | alias of c_ger_ with unused argument (for CTHState) to unify backpack signatures. +c_ger :: Ptr C'THState -> CLLong -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO () +c_ger = const c_ger_ + +-- | c_gemm : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h THShortBlas_gemm" + c_gemm_ :: CChar -> CChar -> CLLong -> CLLong -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> CShort -> Ptr CShort -> CLLong -> IO () + +-- | alias of c_gemm_ with unused argument (for CTHState) to unify backpack signatures. +c_gemm :: Ptr C'THState -> CChar -> CChar -> CLLong -> CLLong -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> CShort -> Ptr CShort -> CLLong -> IO () +c_gemm = const c_gemm_ + +-- | p_swap : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THShortBlas_swap" + p_swap :: FunPtr (CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO ()) + +-- | p_scal : Pointer to function : n a x incx -> void +foreign import ccall "THBlas.h &THShortBlas_scal" + p_scal :: FunPtr (CLLong -> CShort -> Ptr CShort -> CLLong -> IO ()) + +-- | p_copy : Pointer to function : n x incx y incy -> void +foreign import ccall "THBlas.h &THShortBlas_copy" + p_copy :: FunPtr (CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO ()) + +-- | p_axpy : Pointer to function : n a x incx y incy -> void +foreign import ccall "THBlas.h &THShortBlas_axpy" + p_axpy :: FunPtr (CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO ()) + +-- | p_dot : Pointer to function : n x incx y incy -> real +foreign import ccall "THBlas.h &THShortBlas_dot" + p_dot :: FunPtr (CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO CShort) + +-- | p_gemv : Pointer to function : trans m n alpha a lda x incx beta y incy -> void +foreign import ccall "THBlas.h &THShortBlas_gemv" + p_gemv :: FunPtr (CChar -> CLLong -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> CShort -> Ptr CShort -> CLLong -> IO ()) + +-- | p_ger : Pointer to function : m n alpha x incx y incy a lda -> void +foreign import ccall "THBlas.h &THShortBlas_ger" + p_ger :: FunPtr (CLLong -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> IO ()) + +-- | p_gemm : Pointer to function : transa transb m n k alpha a lda b ldb beta c ldc -> void +foreign import ccall "THBlas.h &THShortBlas_gemm" + p_gemm :: FunPtr (CChar -> CChar -> CLLong -> CLLong -> CLLong -> CShort -> Ptr CShort -> CLLong -> Ptr CShort -> CLLong -> CShort -> Ptr CShort -> CLLong -> IO ()) diff --git a/src/Torch/FFI/TH/Short/Storage.hs b/src/Torch/FFI/TH/Short/Storage.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Short/Storage.hs @@ -0,0 +1,260 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.Storage where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_data : -> real * +foreign import ccall "THStorage.h THShortStorage_data" + c_data_ :: Ptr C'THShortStorage -> IO (Ptr CShort) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THShortStorage -> IO (Ptr CShort) +c_data = const c_data_ + +-- | c_size : -> ptrdiff_t +foreign import ccall "THStorage.h THShortStorage_size" + c_size_ :: Ptr C'THShortStorage -> IO CPtrdiff + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THShortStorage -> IO CPtrdiff +c_size = const c_size_ + +-- | c_set : -> void +foreign import ccall "THStorage.h THShortStorage_set" + c_set_ :: Ptr C'THShortStorage -> CPtrdiff -> CShort -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THShortStorage -> CPtrdiff -> CShort -> IO () +c_set = const c_set_ + +-- | c_get : -> real +foreign import ccall "THStorage.h THShortStorage_get" + c_get_ :: Ptr C'THShortStorage -> CPtrdiff -> IO CShort + +-- | alias of c_get_ with unused argument (for CTHState) to unify backpack signatures. +c_get :: Ptr C'THState -> Ptr C'THShortStorage -> CPtrdiff -> IO CShort +c_get = const c_get_ + +-- | c_new : -> THStorage * +foreign import ccall "THStorage.h THShortStorage_new" + c_new_ :: IO (Ptr C'THShortStorage) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THShortStorage) +c_new = const c_new_ + +-- | c_newWithSize : size -> THStorage * +foreign import ccall "THStorage.h THShortStorage_newWithSize" + c_newWithSize_ :: CPtrdiff -> IO (Ptr C'THShortStorage) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> CPtrdiff -> IO (Ptr C'THShortStorage) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1 : -> THStorage * +foreign import ccall "THStorage.h THShortStorage_newWithSize1" + c_newWithSize1_ :: CShort -> IO (Ptr C'THShortStorage) + +-- | alias of c_newWithSize1_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1 :: Ptr C'THState -> CShort -> IO (Ptr C'THShortStorage) +c_newWithSize1 = const c_newWithSize1_ + +-- | c_newWithSize2 : -> THStorage * +foreign import ccall "THStorage.h THShortStorage_newWithSize2" + c_newWithSize2_ :: CShort -> CShort -> IO (Ptr C'THShortStorage) + +-- | alias of c_newWithSize2_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2 :: Ptr C'THState -> CShort -> CShort -> IO (Ptr C'THShortStorage) +c_newWithSize2 = const c_newWithSize2_ + +-- | c_newWithSize3 : -> THStorage * +foreign import ccall "THStorage.h THShortStorage_newWithSize3" + c_newWithSize3_ :: CShort -> CShort -> CShort -> IO (Ptr C'THShortStorage) + +-- | alias of c_newWithSize3_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3 :: Ptr C'THState -> CShort -> CShort -> CShort -> IO (Ptr C'THShortStorage) +c_newWithSize3 = const c_newWithSize3_ + +-- | c_newWithSize4 : -> THStorage * +foreign import ccall "THStorage.h THShortStorage_newWithSize4" + c_newWithSize4_ :: CShort -> CShort -> CShort -> CShort -> IO (Ptr C'THShortStorage) + +-- | alias of c_newWithSize4_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4 :: Ptr C'THState -> CShort -> CShort -> CShort -> CShort -> IO (Ptr C'THShortStorage) +c_newWithSize4 = const c_newWithSize4_ + +-- | c_newWithMapping : filename size flags -> THStorage * +foreign import ccall "THStorage.h THShortStorage_newWithMapping" + c_newWithMapping_ :: Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THShortStorage) + +-- | alias of c_newWithMapping_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithMapping :: Ptr C'THState -> Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THShortStorage) +c_newWithMapping = const c_newWithMapping_ + +-- | c_newWithData : data size -> THStorage * +foreign import ccall "THStorage.h THShortStorage_newWithData" + c_newWithData_ :: Ptr CShort -> CPtrdiff -> IO (Ptr C'THShortStorage) + +-- | alias of c_newWithData_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithData :: Ptr C'THState -> Ptr CShort -> CPtrdiff -> IO (Ptr C'THShortStorage) +c_newWithData = const c_newWithData_ + +-- | c_newWithAllocator : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THShortStorage_newWithAllocator" + c_newWithAllocator_ :: CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THShortStorage) + +-- | alias of c_newWithAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithAllocator :: Ptr C'THState -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THShortStorage) +c_newWithAllocator = const c_newWithAllocator_ + +-- | c_newWithDataAndAllocator : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h THShortStorage_newWithDataAndAllocator" + c_newWithDataAndAllocator_ :: Ptr CShort -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THShortStorage) + +-- | alias of c_newWithDataAndAllocator_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithDataAndAllocator :: Ptr C'THState -> Ptr CShort -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THShortStorage) +c_newWithDataAndAllocator = const c_newWithDataAndAllocator_ + +-- | c_setFlag : storage flag -> void +foreign import ccall "THStorage.h THShortStorage_setFlag" + c_setFlag_ :: Ptr C'THShortStorage -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THShortStorage -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : storage flag -> void +foreign import ccall "THStorage.h THShortStorage_clearFlag" + c_clearFlag_ :: Ptr C'THShortStorage -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THShortStorage -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_retain : storage -> void +foreign import ccall "THStorage.h THShortStorage_retain" + c_retain_ :: Ptr C'THShortStorage -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THShortStorage -> IO () +c_retain = const c_retain_ + +-- | c_swap : storage1 storage2 -> void +foreign import ccall "THStorage.h THShortStorage_swap" + c_swap_ :: Ptr C'THShortStorage -> Ptr C'THShortStorage -> IO () + +-- | alias of c_swap_ with unused argument (for CTHState) to unify backpack signatures. +c_swap :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THShortStorage -> IO () +c_swap = const c_swap_ + +-- | c_free : storage -> void +foreign import ccall "THStorage.h THShortStorage_free" + c_free_ :: Ptr C'THShortStorage -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THShortStorage -> IO () +c_free = const c_free_ + +-- | c_resize : storage size -> void +foreign import ccall "THStorage.h THShortStorage_resize" + c_resize_ :: Ptr C'THShortStorage -> CPtrdiff -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THShortStorage -> CPtrdiff -> IO () +c_resize = const c_resize_ + +-- | c_fill : storage value -> void +foreign import ccall "THStorage.h THShortStorage_fill" + c_fill_ :: Ptr C'THShortStorage -> CShort -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THShortStorage -> CShort -> IO () +c_fill = const c_fill_ + +-- | p_data : Pointer to function : -> real * +foreign import ccall "THStorage.h &THShortStorage_data" + p_data :: FunPtr (Ptr C'THShortStorage -> IO (Ptr CShort)) + +-- | p_size : Pointer to function : -> ptrdiff_t +foreign import ccall "THStorage.h &THShortStorage_size" + p_size :: FunPtr (Ptr C'THShortStorage -> IO CPtrdiff) + +-- | p_set : Pointer to function : -> void +foreign import ccall "THStorage.h &THShortStorage_set" + p_set :: FunPtr (Ptr C'THShortStorage -> CPtrdiff -> CShort -> IO ()) + +-- | p_get : Pointer to function : -> real +foreign import ccall "THStorage.h &THShortStorage_get" + p_get :: FunPtr (Ptr C'THShortStorage -> CPtrdiff -> IO CShort) + +-- | p_new : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_new" + p_new :: FunPtr (IO (Ptr C'THShortStorage)) + +-- | p_newWithSize : Pointer to function : size -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_newWithSize" + p_newWithSize :: FunPtr (CPtrdiff -> IO (Ptr C'THShortStorage)) + +-- | p_newWithSize1 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_newWithSize1" + p_newWithSize1 :: FunPtr (CShort -> IO (Ptr C'THShortStorage)) + +-- | p_newWithSize2 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_newWithSize2" + p_newWithSize2 :: FunPtr (CShort -> CShort -> IO (Ptr C'THShortStorage)) + +-- | p_newWithSize3 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_newWithSize3" + p_newWithSize3 :: FunPtr (CShort -> CShort -> CShort -> IO (Ptr C'THShortStorage)) + +-- | p_newWithSize4 : Pointer to function : -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_newWithSize4" + p_newWithSize4 :: FunPtr (CShort -> CShort -> CShort -> CShort -> IO (Ptr C'THShortStorage)) + +-- | p_newWithMapping : Pointer to function : filename size flags -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_newWithMapping" + p_newWithMapping :: FunPtr (Ptr CChar -> CPtrdiff -> CInt -> IO (Ptr C'THShortStorage)) + +-- | p_newWithData : Pointer to function : data size -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_newWithData" + p_newWithData :: FunPtr (Ptr CShort -> CPtrdiff -> IO (Ptr C'THShortStorage)) + +-- | p_newWithAllocator : Pointer to function : size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_newWithAllocator" + p_newWithAllocator :: FunPtr (CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THShortStorage)) + +-- | p_newWithDataAndAllocator : Pointer to function : data size allocator allocatorContext -> THStorage * +foreign import ccall "THStorage.h &THShortStorage_newWithDataAndAllocator" + p_newWithDataAndAllocator :: FunPtr (Ptr CShort -> CPtrdiff -> Ptr C'THAllocator -> Ptr () -> IO (Ptr C'THShortStorage)) + +-- | p_setFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THShortStorage_setFlag" + p_setFlag :: FunPtr (Ptr C'THShortStorage -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : storage flag -> void +foreign import ccall "THStorage.h &THShortStorage_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THShortStorage -> CChar -> IO ()) + +-- | p_retain : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THShortStorage_retain" + p_retain :: FunPtr (Ptr C'THShortStorage -> IO ()) + +-- | p_swap : Pointer to function : storage1 storage2 -> void +foreign import ccall "THStorage.h &THShortStorage_swap" + p_swap :: FunPtr (Ptr C'THShortStorage -> Ptr C'THShortStorage -> IO ()) + +-- | p_free : Pointer to function : storage -> void +foreign import ccall "THStorage.h &THShortStorage_free" + p_free :: FunPtr (Ptr C'THShortStorage -> IO ()) + +-- | p_resize : Pointer to function : storage size -> void +foreign import ccall "THStorage.h &THShortStorage_resize" + p_resize :: FunPtr (Ptr C'THShortStorage -> CPtrdiff -> IO ()) + +-- | p_fill : Pointer to function : storage value -> void +foreign import ccall "THStorage.h &THShortStorage_fill" + p_fill :: FunPtr (Ptr C'THShortStorage -> CShort -> IO ()) diff --git a/src/Torch/FFI/TH/Short/StorageCopy.hs b/src/Torch/FFI/TH/Short/StorageCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Short/StorageCopy.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.StorageCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_rawCopy : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_rawCopy" + c_rawCopy_ :: Ptr C'THShortStorage -> Ptr CShort -> IO () + +-- | alias of c_rawCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_rawCopy :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr CShort -> IO () +c_rawCopy = const c_rawCopy_ + +-- | c_copy : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_copy" + c_copy_ :: Ptr C'THShortStorage -> Ptr C'THShortStorage -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THShortStorage -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_copyByte" + c_copyByte_ :: Ptr C'THShortStorage -> Ptr C'THByteStorage -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THByteStorage -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_copyChar" + c_copyChar_ :: Ptr C'THShortStorage -> Ptr C'THCharStorage -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THCharStorage -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_copyShort" + c_copyShort_ :: Ptr C'THShortStorage -> Ptr C'THShortStorage -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THShortStorage -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_copyInt" + c_copyInt_ :: Ptr C'THShortStorage -> Ptr C'THIntStorage -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THIntStorage -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_copyLong" + c_copyLong_ :: Ptr C'THShortStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THLongStorage -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_copyFloat" + c_copyFloat_ :: Ptr C'THShortStorage -> Ptr C'THFloatStorage -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THFloatStorage -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_copyDouble" + c_copyDouble_ :: Ptr C'THShortStorage -> Ptr C'THDoubleStorage -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THDoubleStorage -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : storage src -> void +foreign import ccall "THStorageCopy.h THShortStorage_copyHalf" + c_copyHalf_ :: Ptr C'THShortStorage -> Ptr C'THHalfStorage -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THShortStorage -> Ptr C'THHalfStorage -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_rawCopy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_rawCopy" + p_rawCopy :: FunPtr (Ptr C'THShortStorage -> Ptr CShort -> IO ()) + +-- | p_copy : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_copy" + p_copy :: FunPtr (Ptr C'THShortStorage -> Ptr C'THShortStorage -> IO ()) + +-- | p_copyByte : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_copyByte" + p_copyByte :: FunPtr (Ptr C'THShortStorage -> Ptr C'THByteStorage -> IO ()) + +-- | p_copyChar : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_copyChar" + p_copyChar :: FunPtr (Ptr C'THShortStorage -> Ptr C'THCharStorage -> IO ()) + +-- | p_copyShort : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_copyShort" + p_copyShort :: FunPtr (Ptr C'THShortStorage -> Ptr C'THShortStorage -> IO ()) + +-- | p_copyInt : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_copyInt" + p_copyInt :: FunPtr (Ptr C'THShortStorage -> Ptr C'THIntStorage -> IO ()) + +-- | p_copyLong : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_copyLong" + p_copyLong :: FunPtr (Ptr C'THShortStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_copyFloat : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THShortStorage -> Ptr C'THFloatStorage -> IO ()) + +-- | p_copyDouble : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THShortStorage -> Ptr C'THDoubleStorage -> IO ()) + +-- | p_copyHalf : Pointer to function : storage src -> void +foreign import ccall "THStorageCopy.h &THShortStorage_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THShortStorage -> Ptr C'THHalfStorage -> IO ()) diff --git a/src/Torch/FFI/TH/Short/Tensor.hs b/src/Torch/FFI/TH/Short/Tensor.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Short/Tensor.hs @@ -0,0 +1,872 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.Tensor where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_storage : self -> THStorage * +foreign import ccall "THTensor.h THShortTensor_storage" + c_storage_ :: Ptr C'THShortTensor -> IO (Ptr C'THShortStorage) + +-- | alias of c_storage_ with unused argument (for CTHState) to unify backpack signatures. +c_storage :: Ptr C'THState -> Ptr C'THShortTensor -> IO (Ptr C'THShortStorage) +c_storage = const c_storage_ + +-- | c_storageOffset : self -> ptrdiff_t +foreign import ccall "THTensor.h THShortTensor_storageOffset" + c_storageOffset_ :: Ptr C'THShortTensor -> IO CPtrdiff + +-- | alias of c_storageOffset_ with unused argument (for CTHState) to unify backpack signatures. +c_storageOffset :: Ptr C'THState -> Ptr C'THShortTensor -> IO CPtrdiff +c_storageOffset = const c_storageOffset_ + +-- | c_nDimension : self -> int +foreign import ccall "THTensor.h THShortTensor_nDimension" + c_nDimension_ :: Ptr C'THShortTensor -> IO CInt + +-- | alias of c_nDimension_ with unused argument (for CTHState) to unify backpack signatures. +c_nDimension :: Ptr C'THState -> Ptr C'THShortTensor -> IO CInt +c_nDimension = const c_nDimension_ + +-- | c_size : self dim -> int64_t +foreign import ccall "THTensor.h THShortTensor_size" + c_size_ :: Ptr C'THShortTensor -> CInt -> IO CLLong + +-- | alias of c_size_ with unused argument (for CTHState) to unify backpack signatures. +c_size :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> IO CLLong +c_size = const c_size_ + +-- | c_stride : self dim -> int64_t +foreign import ccall "THTensor.h THShortTensor_stride" + c_stride_ :: Ptr C'THShortTensor -> CInt -> IO CLLong + +-- | alias of c_stride_ with unused argument (for CTHState) to unify backpack signatures. +c_stride :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> IO CLLong +c_stride = const c_stride_ + +-- | c_newSizeOf : self -> THLongStorage * +foreign import ccall "THTensor.h THShortTensor_newSizeOf" + c_newSizeOf_ :: Ptr C'THShortTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newSizeOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newSizeOf :: Ptr C'THState -> Ptr C'THShortTensor -> IO (Ptr C'THLongStorage) +c_newSizeOf = const c_newSizeOf_ + +-- | c_newStrideOf : self -> THLongStorage * +foreign import ccall "THTensor.h THShortTensor_newStrideOf" + c_newStrideOf_ :: Ptr C'THShortTensor -> IO (Ptr C'THLongStorage) + +-- | alias of c_newStrideOf_ with unused argument (for CTHState) to unify backpack signatures. +c_newStrideOf :: Ptr C'THState -> Ptr C'THShortTensor -> IO (Ptr C'THLongStorage) +c_newStrideOf = const c_newStrideOf_ + +-- | c_data : self -> real * +foreign import ccall "THTensor.h THShortTensor_data" + c_data_ :: Ptr C'THShortTensor -> IO (Ptr CShort) + +-- | alias of c_data_ with unused argument (for CTHState) to unify backpack signatures. +c_data :: Ptr C'THState -> Ptr C'THShortTensor -> IO (Ptr CShort) +c_data = const c_data_ + +-- | c_setFlag : self flag -> void +foreign import ccall "THTensor.h THShortTensor_setFlag" + c_setFlag_ :: Ptr C'THShortTensor -> CChar -> IO () + +-- | alias of c_setFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_setFlag :: Ptr C'THState -> Ptr C'THShortTensor -> CChar -> IO () +c_setFlag = const c_setFlag_ + +-- | c_clearFlag : self flag -> void +foreign import ccall "THTensor.h THShortTensor_clearFlag" + c_clearFlag_ :: Ptr C'THShortTensor -> CChar -> IO () + +-- | alias of c_clearFlag_ with unused argument (for CTHState) to unify backpack signatures. +c_clearFlag :: Ptr C'THState -> Ptr C'THShortTensor -> CChar -> IO () +c_clearFlag = const c_clearFlag_ + +-- | c_new : -> THTensor * +foreign import ccall "THTensor.h THShortTensor_new" + c_new_ :: IO (Ptr C'THShortTensor) + +-- | alias of c_new_ with unused argument (for CTHState) to unify backpack signatures. +c_new :: Ptr C'THState -> IO (Ptr C'THShortTensor) +c_new = const c_new_ + +-- | c_newWithTensor : tensor -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithTensor" + c_newWithTensor_ :: Ptr C'THShortTensor -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithTensor :: Ptr C'THState -> Ptr C'THShortTensor -> IO (Ptr C'THShortTensor) +c_newWithTensor = const c_newWithTensor_ + +-- | c_newWithStorage : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithStorage" + c_newWithStorage_ :: Ptr C'THShortStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage :: Ptr C'THState -> Ptr C'THShortStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor) +c_newWithStorage = const c_newWithStorage_ + +-- | c_newWithStorage1d : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithStorage1d" + c_newWithStorage1d_ :: Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage1d :: Ptr C'THState -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) +c_newWithStorage1d = const c_newWithStorage1d_ + +-- | c_newWithStorage2d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithStorage2d" + c_newWithStorage2d_ :: Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage2d :: Ptr C'THState -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) +c_newWithStorage2d = const c_newWithStorage2d_ + +-- | c_newWithStorage3d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithStorage3d" + c_newWithStorage3d_ :: Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage3d :: Ptr C'THState -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) +c_newWithStorage3d = const c_newWithStorage3d_ + +-- | c_newWithStorage4d : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithStorage4d" + c_newWithStorage4d_ :: Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithStorage4d :: Ptr C'THState -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) +c_newWithStorage4d = const c_newWithStorage4d_ + +-- | c_newWithSize : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithSize" + c_newWithSize_ :: Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithSize_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize :: Ptr C'THState -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor) +c_newWithSize = const c_newWithSize_ + +-- | c_newWithSize1d : size0_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithSize1d" + c_newWithSize1d_ :: CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithSize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize1d :: Ptr C'THState -> CLLong -> IO (Ptr C'THShortTensor) +c_newWithSize1d = const c_newWithSize1d_ + +-- | c_newWithSize2d : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithSize2d" + c_newWithSize2d_ :: CLLong -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithSize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize2d :: Ptr C'THState -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) +c_newWithSize2d = const c_newWithSize2d_ + +-- | c_newWithSize3d : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithSize3d" + c_newWithSize3d_ :: CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithSize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize3d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) +c_newWithSize3d = const c_newWithSize3d_ + +-- | c_newWithSize4d : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newWithSize4d" + c_newWithSize4d_ :: CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newWithSize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_newWithSize4d :: Ptr C'THState -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) +c_newWithSize4d = const c_newWithSize4d_ + +-- | c_newClone : self -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newClone" + c_newClone_ :: Ptr C'THShortTensor -> IO (Ptr C'THShortTensor) + +-- | alias of c_newClone_ with unused argument (for CTHState) to unify backpack signatures. +c_newClone :: Ptr C'THState -> Ptr C'THShortTensor -> IO (Ptr C'THShortTensor) +c_newClone = const c_newClone_ + +-- | c_newContiguous : tensor -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newContiguous" + c_newContiguous_ :: Ptr C'THShortTensor -> IO (Ptr C'THShortTensor) + +-- | alias of c_newContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_newContiguous :: Ptr C'THState -> Ptr C'THShortTensor -> IO (Ptr C'THShortTensor) +c_newContiguous = const c_newContiguous_ + +-- | c_newSelect : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newSelect" + c_newSelect_ :: Ptr C'THShortTensor -> CInt -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_newSelect :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> CLLong -> IO (Ptr C'THShortTensor) +c_newSelect = const c_newSelect_ + +-- | c_newNarrow : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newNarrow" + c_newNarrow_ :: Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newNarrow_ with unused argument (for CTHState) to unify backpack signatures. +c_newNarrow :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) +c_newNarrow = const c_newNarrow_ + +-- | c_newTranspose : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newTranspose" + c_newTranspose_ :: Ptr C'THShortTensor -> CInt -> CInt -> IO (Ptr C'THShortTensor) + +-- | alias of c_newTranspose_ with unused argument (for CTHState) to unify backpack signatures. +c_newTranspose :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> CInt -> IO (Ptr C'THShortTensor) +c_newTranspose = const c_newTranspose_ + +-- | c_newUnfold : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newUnfold" + c_newUnfold_ :: Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) + +-- | alias of c_newUnfold_ with unused argument (for CTHState) to unify backpack signatures. +c_newUnfold :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THShortTensor) +c_newUnfold = const c_newUnfold_ + +-- | c_newView : tensor size -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newView" + c_newView_ :: Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor) + +-- | alias of c_newView_ with unused argument (for CTHState) to unify backpack signatures. +c_newView :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor) +c_newView = const c_newView_ + +-- | c_newExpand : tensor size -> THTensor * +foreign import ccall "THTensor.h THShortTensor_newExpand" + c_newExpand_ :: Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor) + +-- | alias of c_newExpand_ with unused argument (for CTHState) to unify backpack signatures. +c_newExpand :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor) +c_newExpand = const c_newExpand_ + +-- | c_expand : r tensor size -> void +foreign import ccall "THTensor.h THShortTensor_expand" + c_expand_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_expand_ with unused argument (for CTHState) to unify backpack signatures. +c_expand :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO () +c_expand = const c_expand_ + +-- | c_expandNd : rets ops count -> void +foreign import ccall "THTensor.h THShortTensor_expandNd" + c_expandNd_ :: Ptr (Ptr C'THShortTensor) -> Ptr (Ptr C'THShortTensor) -> CInt -> IO () + +-- | alias of c_expandNd_ with unused argument (for CTHState) to unify backpack signatures. +c_expandNd :: Ptr C'THState -> Ptr (Ptr C'THShortTensor) -> Ptr (Ptr C'THShortTensor) -> CInt -> IO () +c_expandNd = const c_expandNd_ + +-- | c_resize : tensor size stride -> void +foreign import ccall "THTensor.h THShortTensor_resize" + c_resize_ :: Ptr C'THShortTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_resize_ with unused argument (for CTHState) to unify backpack signatures. +c_resize :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_resize = const c_resize_ + +-- | c_resizeAs : tensor src -> void +foreign import ccall "THTensor.h THShortTensor_resizeAs" + c_resizeAs_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_resizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeAs :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_resizeAs = const c_resizeAs_ + +-- | c_resizeNd : tensor nDimension size stride -> void +foreign import ccall "THTensor.h THShortTensor_resizeNd" + c_resizeNd_ :: Ptr C'THShortTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_resizeNd_ with unused argument (for CTHState) to unify backpack signatures. +c_resizeNd :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_resizeNd = const c_resizeNd_ + +-- | c_resize1d : tensor size0_ -> void +foreign import ccall "THTensor.h THShortTensor_resize1d" + c_resize1d_ :: Ptr C'THShortTensor -> CLLong -> IO () + +-- | alias of c_resize1d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize1d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> IO () +c_resize1d = const c_resize1d_ + +-- | c_resize2d : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h THShortTensor_resize2d" + c_resize2d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_resize2d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize2d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> IO () +c_resize2d = const c_resize2d_ + +-- | c_resize3d : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h THShortTensor_resize3d" + c_resize3d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize3d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize3d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> IO () +c_resize3d = const c_resize3d_ + +-- | c_resize4d : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h THShortTensor_resize4d" + c_resize4d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize4d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize4d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize4d = const c_resize4d_ + +-- | c_resize5d : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h THShortTensor_resize5d" + c_resize5d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_resize5d_ with unused argument (for CTHState) to unify backpack signatures. +c_resize5d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_resize5d = const c_resize5d_ + +-- | c_set : self src -> void +foreign import ccall "THTensor.h THShortTensor_set" + c_set_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_set_ with unused argument (for CTHState) to unify backpack signatures. +c_set :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_set = const c_set_ + +-- | c_setStorage : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h THShortTensor_setStorage" + c_setStorage_ :: Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () + +-- | alias of c_setStorage_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO () +c_setStorage = const c_setStorage_ + +-- | c_setStorageNd : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h THShortTensor_setStorageNd" + c_setStorageNd_ :: Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () + +-- | alias of c_setStorageNd_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorageNd :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO () +c_setStorageNd = const c_setStorageNd_ + +-- | c_setStorage1d : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h THShortTensor_setStorage1d" + c_setStorage1d_ :: Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage1d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage1d :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> IO () +c_setStorage1d = const c_setStorage1d_ + +-- | c_setStorage2d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h THShortTensor_setStorage2d" + c_setStorage2d_ :: Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage2d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage2d :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage2d = const c_setStorage2d_ + +-- | c_setStorage3d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h THShortTensor_setStorage3d" + c_setStorage3d_ :: Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage3d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage3d :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage3d = const c_setStorage3d_ + +-- | c_setStorage4d : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h THShortTensor_setStorage4d" + c_setStorage4d_ :: Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_setStorage4d_ with unused argument (for CTHState) to unify backpack signatures. +c_setStorage4d :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_setStorage4d = const c_setStorage4d_ + +-- | c_narrow : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h THShortTensor_narrow" + c_narrow_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_narrow_ with unused argument (for CTHState) to unify backpack signatures. +c_narrow :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO () +c_narrow = const c_narrow_ + +-- | c_select : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h THShortTensor_select" + c_select_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CLLong -> IO () + +-- | alias of c_select_ with unused argument (for CTHState) to unify backpack signatures. +c_select :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CLLong -> IO () +c_select = const c_select_ + +-- | c_transpose : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h THShortTensor_transpose" + c_transpose_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () + +-- | alias of c_transpose_ with unused argument (for CTHState) to unify backpack signatures. +c_transpose :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () +c_transpose = const c_transpose_ + +-- | c_unfold : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h THShortTensor_unfold" + c_unfold_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO () + +-- | alias of c_unfold_ with unused argument (for CTHState) to unify backpack signatures. +c_unfold :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO () +c_unfold = const c_unfold_ + +-- | c_squeeze : self src -> void +foreign import ccall "THTensor.h THShortTensor_squeeze" + c_squeeze_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_squeeze_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_squeeze = const c_squeeze_ + +-- | c_squeeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THShortTensor_squeeze1d" + c_squeeze1d_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () + +-- | alias of c_squeeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_squeeze1d :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () +c_squeeze1d = const c_squeeze1d_ + +-- | c_unsqueeze1d : self src dimension_ -> void +foreign import ccall "THTensor.h THShortTensor_unsqueeze1d" + c_unsqueeze1d_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () + +-- | alias of c_unsqueeze1d_ with unused argument (for CTHState) to unify backpack signatures. +c_unsqueeze1d :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () +c_unsqueeze1d = const c_unsqueeze1d_ + +-- | c_isContiguous : self -> int +foreign import ccall "THTensor.h THShortTensor_isContiguous" + c_isContiguous_ :: Ptr C'THShortTensor -> IO CInt + +-- | alias of c_isContiguous_ with unused argument (for CTHState) to unify backpack signatures. +c_isContiguous :: Ptr C'THState -> Ptr C'THShortTensor -> IO CInt +c_isContiguous = const c_isContiguous_ + +-- | c_isSameSizeAs : self src -> int +foreign import ccall "THTensor.h THShortTensor_isSameSizeAs" + c_isSameSizeAs_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CInt + +-- | alias of c_isSameSizeAs_ with unused argument (for CTHState) to unify backpack signatures. +c_isSameSizeAs :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CInt +c_isSameSizeAs = const c_isSameSizeAs_ + +-- | c_isSetTo : self src -> int +foreign import ccall "THTensor.h THShortTensor_isSetTo" + c_isSetTo_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CInt + +-- | alias of c_isSetTo_ with unused argument (for CTHState) to unify backpack signatures. +c_isSetTo :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CInt +c_isSetTo = const c_isSetTo_ + +-- | c_isSize : self dims -> int +foreign import ccall "THTensor.h THShortTensor_isSize" + c_isSize_ :: Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO CInt + +-- | alias of c_isSize_ with unused argument (for CTHState) to unify backpack signatures. +c_isSize :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO CInt +c_isSize = const c_isSize_ + +-- | c_nElement : self -> ptrdiff_t +foreign import ccall "THTensor.h THShortTensor_nElement" + c_nElement_ :: Ptr C'THShortTensor -> IO CPtrdiff + +-- | alias of c_nElement_ with unused argument (for CTHState) to unify backpack signatures. +c_nElement :: Ptr C'THState -> Ptr C'THShortTensor -> IO CPtrdiff +c_nElement = const c_nElement_ + +-- | c_retain : self -> void +foreign import ccall "THTensor.h THShortTensor_retain" + c_retain_ :: Ptr C'THShortTensor -> IO () + +-- | alias of c_retain_ with unused argument (for CTHState) to unify backpack signatures. +c_retain :: Ptr C'THState -> Ptr C'THShortTensor -> IO () +c_retain = const c_retain_ + +-- | c_free : self -> void +foreign import ccall "THTensor.h THShortTensor_free" + c_free_ :: Ptr C'THShortTensor -> IO () + +-- | alias of c_free_ with unused argument (for CTHState) to unify backpack signatures. +c_free :: Ptr C'THState -> Ptr C'THShortTensor -> IO () +c_free = const c_free_ + +-- | c_freeCopyTo : self dst -> void +foreign import ccall "THTensor.h THShortTensor_freeCopyTo" + c_freeCopyTo_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_freeCopyTo_ with unused argument (for CTHState) to unify backpack signatures. +c_freeCopyTo :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_freeCopyTo = const c_freeCopyTo_ + +-- | c_set1d : tensor x0 value -> void +foreign import ccall "THTensor.h THShortTensor_set1d" + c_set1d_ :: Ptr C'THShortTensor -> CLLong -> CShort -> IO () + +-- | alias of c_set1d_ with unused argument (for CTHState) to unify backpack signatures. +c_set1d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CShort -> IO () +c_set1d = const c_set1d_ + +-- | c_set2d : tensor x0 x1 value -> void +foreign import ccall "THTensor.h THShortTensor_set2d" + c_set2d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> CShort -> IO () + +-- | alias of c_set2d_ with unused argument (for CTHState) to unify backpack signatures. +c_set2d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> CShort -> IO () +c_set2d = const c_set2d_ + +-- | c_set3d : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h THShortTensor_set3d" + c_set3d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CShort -> IO () + +-- | alias of c_set3d_ with unused argument (for CTHState) to unify backpack signatures. +c_set3d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CShort -> IO () +c_set3d = const c_set3d_ + +-- | c_set4d : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h THShortTensor_set4d" + c_set4d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CShort -> IO () + +-- | alias of c_set4d_ with unused argument (for CTHState) to unify backpack signatures. +c_set4d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CShort -> IO () +c_set4d = const c_set4d_ + +-- | c_get1d : tensor x0 -> real +foreign import ccall "THTensor.h THShortTensor_get1d" + c_get1d_ :: Ptr C'THShortTensor -> CLLong -> IO CShort + +-- | alias of c_get1d_ with unused argument (for CTHState) to unify backpack signatures. +c_get1d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> IO CShort +c_get1d = const c_get1d_ + +-- | c_get2d : tensor x0 x1 -> real +foreign import ccall "THTensor.h THShortTensor_get2d" + c_get2d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> IO CShort + +-- | alias of c_get2d_ with unused argument (for CTHState) to unify backpack signatures. +c_get2d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> IO CShort +c_get2d = const c_get2d_ + +-- | c_get3d : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h THShortTensor_get3d" + c_get3d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> IO CShort + +-- | alias of c_get3d_ with unused argument (for CTHState) to unify backpack signatures. +c_get3d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> IO CShort +c_get3d = const c_get3d_ + +-- | c_get4d : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h THShortTensor_get4d" + c_get4d_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CShort + +-- | alias of c_get4d_ with unused argument (for CTHState) to unify backpack signatures. +c_get4d :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CShort +c_get4d = const c_get4d_ + +-- | c_desc : tensor -> THDescBuff +foreign import ccall "THTensor.h THShortTensor_desc" + c_desc_ :: Ptr C'THShortTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_desc_ with unused argument (for CTHState) to unify backpack signatures. +c_desc :: Ptr C'THState -> Ptr C'THShortTensor -> IO (Ptr C'THDescBuff) +c_desc = const c_desc_ + +-- | c_sizeDesc : tensor -> THDescBuff +foreign import ccall "THTensor.h THShortTensor_sizeDesc" + c_sizeDesc_ :: Ptr C'THShortTensor -> IO (Ptr C'THDescBuff) + +-- | alias of c_sizeDesc_ with unused argument (for CTHState) to unify backpack signatures. +c_sizeDesc :: Ptr C'THState -> Ptr C'THShortTensor -> IO (Ptr C'THDescBuff) +c_sizeDesc = const c_sizeDesc_ + +-- | p_storage : Pointer to function : self -> THStorage * +foreign import ccall "THTensor.h &THShortTensor_storage" + p_storage :: FunPtr (Ptr C'THShortTensor -> IO (Ptr C'THShortStorage)) + +-- | p_storageOffset : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THShortTensor_storageOffset" + p_storageOffset :: FunPtr (Ptr C'THShortTensor -> IO CPtrdiff) + +-- | p_nDimension : Pointer to function : self -> int +foreign import ccall "THTensor.h &THShortTensor_nDimension" + p_nDimension :: FunPtr (Ptr C'THShortTensor -> IO CInt) + +-- | p_size : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THShortTensor_size" + p_size :: FunPtr (Ptr C'THShortTensor -> CInt -> IO CLLong) + +-- | p_stride : Pointer to function : self dim -> int64_t +foreign import ccall "THTensor.h &THShortTensor_stride" + p_stride :: FunPtr (Ptr C'THShortTensor -> CInt -> IO CLLong) + +-- | p_newSizeOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THShortTensor_newSizeOf" + p_newSizeOf :: FunPtr (Ptr C'THShortTensor -> IO (Ptr C'THLongStorage)) + +-- | p_newStrideOf : Pointer to function : self -> THLongStorage * +foreign import ccall "THTensor.h &THShortTensor_newStrideOf" + p_newStrideOf :: FunPtr (Ptr C'THShortTensor -> IO (Ptr C'THLongStorage)) + +-- | p_data : Pointer to function : self -> real * +foreign import ccall "THTensor.h &THShortTensor_data" + p_data :: FunPtr (Ptr C'THShortTensor -> IO (Ptr CShort)) + +-- | p_setFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THShortTensor_setFlag" + p_setFlag :: FunPtr (Ptr C'THShortTensor -> CChar -> IO ()) + +-- | p_clearFlag : Pointer to function : self flag -> void +foreign import ccall "THTensor.h &THShortTensor_clearFlag" + p_clearFlag :: FunPtr (Ptr C'THShortTensor -> CChar -> IO ()) + +-- | p_new : Pointer to function : -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_new" + p_new :: FunPtr (IO (Ptr C'THShortTensor)) + +-- | p_newWithTensor : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithTensor" + p_newWithTensor :: FunPtr (Ptr C'THShortTensor -> IO (Ptr C'THShortTensor)) + +-- | p_newWithStorage : Pointer to function : storage_ storageOffset_ size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithStorage" + p_newWithStorage :: FunPtr (Ptr C'THShortStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor)) + +-- | p_newWithStorage1d : Pointer to function : storage_ storageOffset_ size0_ stride0_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithStorage1d" + p_newWithStorage1d :: FunPtr (Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newWithStorage2d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithStorage2d" + p_newWithStorage2d :: FunPtr (Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newWithStorage3d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithStorage3d" + p_newWithStorage3d :: FunPtr (Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newWithStorage4d : Pointer to function : storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithStorage4d" + p_newWithStorage4d :: FunPtr (Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newWithSize : Pointer to function : size_ stride_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithSize" + p_newWithSize :: FunPtr (Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor)) + +-- | p_newWithSize1d : Pointer to function : size0_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithSize1d" + p_newWithSize1d :: FunPtr (CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newWithSize2d : Pointer to function : size0_ size1_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithSize2d" + p_newWithSize2d :: FunPtr (CLLong -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newWithSize3d : Pointer to function : size0_ size1_ size2_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithSize3d" + p_newWithSize3d :: FunPtr (CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newWithSize4d : Pointer to function : size0_ size1_ size2_ size3_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newWithSize4d" + p_newWithSize4d :: FunPtr (CLLong -> CLLong -> CLLong -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newClone : Pointer to function : self -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newClone" + p_newClone :: FunPtr (Ptr C'THShortTensor -> IO (Ptr C'THShortTensor)) + +-- | p_newContiguous : Pointer to function : tensor -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newContiguous" + p_newContiguous :: FunPtr (Ptr C'THShortTensor -> IO (Ptr C'THShortTensor)) + +-- | p_newSelect : Pointer to function : tensor dimension_ sliceIndex_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newSelect" + p_newSelect :: FunPtr (Ptr C'THShortTensor -> CInt -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newNarrow : Pointer to function : tensor dimension_ firstIndex_ size_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newNarrow" + p_newNarrow :: FunPtr (Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newTranspose : Pointer to function : tensor dimension1_ dimension2_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newTranspose" + p_newTranspose :: FunPtr (Ptr C'THShortTensor -> CInt -> CInt -> IO (Ptr C'THShortTensor)) + +-- | p_newUnfold : Pointer to function : tensor dimension_ size_ step_ -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newUnfold" + p_newUnfold :: FunPtr (Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO (Ptr C'THShortTensor)) + +-- | p_newView : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newView" + p_newView :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor)) + +-- | p_newExpand : Pointer to function : tensor size -> THTensor * +foreign import ccall "THTensor.h &THShortTensor_newExpand" + p_newExpand :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO (Ptr C'THShortTensor)) + +-- | p_expand : Pointer to function : r tensor size -> void +foreign import ccall "THTensor.h &THShortTensor_expand" + p_expand :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_expandNd : Pointer to function : rets ops count -> void +foreign import ccall "THTensor.h &THShortTensor_expandNd" + p_expandNd :: FunPtr (Ptr (Ptr C'THShortTensor) -> Ptr (Ptr C'THShortTensor) -> CInt -> IO ()) + +-- | p_resize : Pointer to function : tensor size stride -> void +foreign import ccall "THTensor.h &THShortTensor_resize" + p_resize :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_resizeAs : Pointer to function : tensor src -> void +foreign import ccall "THTensor.h &THShortTensor_resizeAs" + p_resizeAs :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_resizeNd : Pointer to function : tensor nDimension size stride -> void +foreign import ccall "THTensor.h &THShortTensor_resizeNd" + p_resizeNd :: FunPtr (Ptr C'THShortTensor -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_resize1d : Pointer to function : tensor size0_ -> void +foreign import ccall "THTensor.h &THShortTensor_resize1d" + p_resize1d :: FunPtr (Ptr C'THShortTensor -> CLLong -> IO ()) + +-- | p_resize2d : Pointer to function : tensor size0_ size1_ -> void +foreign import ccall "THTensor.h &THShortTensor_resize2d" + p_resize2d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> IO ()) + +-- | p_resize3d : Pointer to function : tensor size0_ size1_ size2_ -> void +foreign import ccall "THTensor.h &THShortTensor_resize3d" + p_resize3d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize4d : Pointer to function : tensor size0_ size1_ size2_ size3_ -> void +foreign import ccall "THTensor.h &THShortTensor_resize4d" + p_resize4d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_resize5d : Pointer to function : tensor size0_ size1_ size2_ size3_ size4_ -> void +foreign import ccall "THTensor.h &THShortTensor_resize5d" + p_resize5d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_set : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THShortTensor_set" + p_set :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_setStorage : Pointer to function : self storage_ storageOffset_ size_ stride_ -> void +foreign import ccall "THTensor.h &THShortTensor_setStorage" + p_setStorage :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> Ptr C'THLongStorage -> Ptr C'THLongStorage -> IO ()) + +-- | p_setStorageNd : Pointer to function : self storage_ storageOffset_ nDimension size stride -> void +foreign import ccall "THTensor.h &THShortTensor_setStorageNd" + p_setStorageNd :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CInt -> Ptr CLLong -> Ptr CLLong -> IO ()) + +-- | p_setStorage1d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ -> void +foreign import ccall "THTensor.h &THShortTensor_setStorage1d" + p_setStorage1d :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage2d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ -> void +foreign import ccall "THTensor.h &THShortTensor_setStorage2d" + p_setStorage2d :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage3d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ -> void +foreign import ccall "THTensor.h &THShortTensor_setStorage3d" + p_setStorage3d :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_setStorage4d : Pointer to function : self storage_ storageOffset_ size0_ stride0_ size1_ stride1_ size2_ stride2_ size3_ stride3_ -> void +foreign import ccall "THTensor.h &THShortTensor_setStorage4d" + p_setStorage4d :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortStorage -> CPtrdiff -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_narrow : Pointer to function : self src dimension_ firstIndex_ size_ -> void +foreign import ccall "THTensor.h &THShortTensor_narrow" + p_narrow :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_select : Pointer to function : self src dimension_ sliceIndex_ -> void +foreign import ccall "THTensor.h &THShortTensor_select" + p_select :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CLLong -> IO ()) + +-- | p_transpose : Pointer to function : self src dimension1_ dimension2_ -> void +foreign import ccall "THTensor.h &THShortTensor_transpose" + p_transpose :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO ()) + +-- | p_unfold : Pointer to function : self src dimension_ size_ step_ -> void +foreign import ccall "THTensor.h &THShortTensor_unfold" + p_unfold :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CLLong -> CLLong -> IO ()) + +-- | p_squeeze : Pointer to function : self src -> void +foreign import ccall "THTensor.h &THShortTensor_squeeze" + p_squeeze :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_squeeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THShortTensor_squeeze1d" + p_squeeze1d :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO ()) + +-- | p_unsqueeze1d : Pointer to function : self src dimension_ -> void +foreign import ccall "THTensor.h &THShortTensor_unsqueeze1d" + p_unsqueeze1d :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO ()) + +-- | p_isContiguous : Pointer to function : self -> int +foreign import ccall "THTensor.h &THShortTensor_isContiguous" + p_isContiguous :: FunPtr (Ptr C'THShortTensor -> IO CInt) + +-- | p_isSameSizeAs : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THShortTensor_isSameSizeAs" + p_isSameSizeAs :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CInt) + +-- | p_isSetTo : Pointer to function : self src -> int +foreign import ccall "THTensor.h &THShortTensor_isSetTo" + p_isSetTo :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CInt) + +-- | p_isSize : Pointer to function : self dims -> int +foreign import ccall "THTensor.h &THShortTensor_isSize" + p_isSize :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO CInt) + +-- | p_nElement : Pointer to function : self -> ptrdiff_t +foreign import ccall "THTensor.h &THShortTensor_nElement" + p_nElement :: FunPtr (Ptr C'THShortTensor -> IO CPtrdiff) + +-- | p_retain : Pointer to function : self -> void +foreign import ccall "THTensor.h &THShortTensor_retain" + p_retain :: FunPtr (Ptr C'THShortTensor -> IO ()) + +-- | p_free : Pointer to function : self -> void +foreign import ccall "THTensor.h &THShortTensor_free" + p_free :: FunPtr (Ptr C'THShortTensor -> IO ()) + +-- | p_freeCopyTo : Pointer to function : self dst -> void +foreign import ccall "THTensor.h &THShortTensor_freeCopyTo" + p_freeCopyTo :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_set1d : Pointer to function : tensor x0 value -> void +foreign import ccall "THTensor.h &THShortTensor_set1d" + p_set1d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CShort -> IO ()) + +-- | p_set2d : Pointer to function : tensor x0 x1 value -> void +foreign import ccall "THTensor.h &THShortTensor_set2d" + p_set2d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> CShort -> IO ()) + +-- | p_set3d : Pointer to function : tensor x0 x1 x2 value -> void +foreign import ccall "THTensor.h &THShortTensor_set3d" + p_set3d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CShort -> IO ()) + +-- | p_set4d : Pointer to function : tensor x0 x1 x2 x3 value -> void +foreign import ccall "THTensor.h &THShortTensor_set4d" + p_set4d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> CShort -> IO ()) + +-- | p_get1d : Pointer to function : tensor x0 -> real +foreign import ccall "THTensor.h &THShortTensor_get1d" + p_get1d :: FunPtr (Ptr C'THShortTensor -> CLLong -> IO CShort) + +-- | p_get2d : Pointer to function : tensor x0 x1 -> real +foreign import ccall "THTensor.h &THShortTensor_get2d" + p_get2d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> IO CShort) + +-- | p_get3d : Pointer to function : tensor x0 x1 x2 -> real +foreign import ccall "THTensor.h &THShortTensor_get3d" + p_get3d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> IO CShort) + +-- | p_get4d : Pointer to function : tensor x0 x1 x2 x3 -> real +foreign import ccall "THTensor.h &THShortTensor_get4d" + p_get4d :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> CLLong -> IO CShort) + +-- | p_desc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THShortTensor_desc" + p_desc :: FunPtr (Ptr C'THShortTensor -> IO (Ptr C'THDescBuff)) + +-- | p_sizeDesc : Pointer to function : tensor -> THDescBuff +foreign import ccall "THTensor.h &THShortTensor_sizeDesc" + p_sizeDesc :: FunPtr (Ptr C'THShortTensor -> IO (Ptr C'THDescBuff)) diff --git a/src/Torch/FFI/TH/Short/TensorConv.hs b/src/Torch/FFI/TH/Short/TensorConv.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Short/TensorConv.hs @@ -0,0 +1,272 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.TensorConv where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_validXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_validXCorr2Dptr" + c_validXCorr2Dptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2Dptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2Dptr = const c_validXCorr2Dptr_ + +-- | c_validConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_validConv2Dptr" + c_validConv2Dptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv2Dptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv2Dptr = const c_validConv2Dptr_ + +-- | c_fullXCorr2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_fullXCorr2Dptr" + c_fullXCorr2Dptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr2Dptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr2Dptr = const c_fullXCorr2Dptr_ + +-- | c_fullConv2Dptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_fullConv2Dptr" + c_fullConv2Dptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv2Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv2Dptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv2Dptr = const c_fullConv2Dptr_ + +-- | c_validXCorr2DRevptr : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_validXCorr2DRevptr" + c_validXCorr2DRevptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr2DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr2DRevptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr2DRevptr = const c_validXCorr2DRevptr_ + +-- | c_conv2DRevger : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THShortTensor_conv2DRevger" + c_conv2DRevger_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevger :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> IO () +c_conv2DRevger = const c_conv2DRevger_ + +-- | c_conv2DRevgerm : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h THShortTensor_conv2DRevgerm" + c_conv2DRevgerm_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_conv2DRevgerm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2DRevgerm :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> IO () +c_conv2DRevgerm = const c_conv2DRevgerm_ + +-- | c_conv2Dger : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THShortTensor_conv2Dger" + c_conv2Dger_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dger :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dger = const c_conv2Dger_ + +-- | c_conv2Dmv : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THShortTensor_conv2Dmv" + c_conv2Dmv_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmv :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmv = const c_conv2Dmv_ + +-- | c_conv2Dmm : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THShortTensor_conv2Dmm" + c_conv2Dmm_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmm_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmm :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmm = const c_conv2Dmm_ + +-- | c_conv2Dmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THShortTensor_conv2Dmul" + c_conv2Dmul_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dmul :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dmul = const c_conv2Dmul_ + +-- | c_conv2Dcmul : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h THShortTensor_conv2Dcmul" + c_conv2Dcmul_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv2Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv2Dcmul :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv2Dcmul = const c_conv2Dcmul_ + +-- | c_validXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_validXCorr3Dptr" + c_validXCorr3Dptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3Dptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3Dptr = const c_validXCorr3Dptr_ + +-- | c_validConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_validConv3Dptr" + c_validConv3Dptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validConv3Dptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validConv3Dptr = const c_validConv3Dptr_ + +-- | c_fullXCorr3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_fullXCorr3Dptr" + c_fullXCorr3Dptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullXCorr3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullXCorr3Dptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullXCorr3Dptr = const c_fullXCorr3Dptr_ + +-- | c_fullConv3Dptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_fullConv3Dptr" + c_fullConv3Dptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_fullConv3Dptr_ with unused argument (for CTHState) to unify backpack signatures. +c_fullConv3Dptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_fullConv3Dptr = const c_fullConv3Dptr_ + +-- | c_validXCorr3DRevptr : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h THShortTensor_validXCorr3DRevptr" + c_validXCorr3DRevptr_ :: Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_validXCorr3DRevptr_ with unused argument (for CTHState) to unify backpack signatures. +c_validXCorr3DRevptr :: Ptr C'THState -> Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO () +c_validXCorr3DRevptr = const c_validXCorr3DRevptr_ + +-- | c_conv3DRevger : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h THShortTensor_conv3DRevger" + c_conv3DRevger_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> IO () + +-- | alias of c_conv3DRevger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3DRevger :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> IO () +c_conv3DRevger = const c_conv3DRevger_ + +-- | c_conv3Dger : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THShortTensor_conv3Dger" + c_conv3Dger_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dger_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dger :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dger = const c_conv3Dger_ + +-- | c_conv3Dmv : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THShortTensor_conv3Dmv" + c_conv3Dmv_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmv_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmv :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmv = const c_conv3Dmv_ + +-- | c_conv3Dmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THShortTensor_conv3Dmul" + c_conv3Dmul_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dmul :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dmul = const c_conv3Dmul_ + +-- | c_conv3Dcmul : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h THShortTensor_conv3Dcmul" + c_conv3Dcmul_ :: Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () + +-- | alias of c_conv3Dcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_conv3Dcmul :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO () +c_conv3Dcmul = const c_conv3Dcmul_ + +-- | p_validXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_validXCorr2Dptr" + p_validXCorr2Dptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_validConv2Dptr" + p_validConv2Dptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_fullXCorr2Dptr" + p_fullXCorr2Dptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv2Dptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_fullConv2Dptr" + p_fullConv2Dptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr2DRevptr : Pointer to function : r_ alpha t_ ir ic k_ kr kc sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_validXCorr2DRevptr" + p_validXCorr2DRevptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevger : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv2DRevger" + p_conv2DRevger :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2DRevgerm : Pointer to function : r_ beta alpha t_ k_ srow scol -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv2DRevgerm" + p_conv2DRevgerm :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> IO ()) + +-- | p_conv2Dger : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv2Dger" + p_conv2Dger :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmv : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv2Dmv" + p_conv2Dmv :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmm : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv2Dmm" + p_conv2Dmm :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv2Dmul" + p_conv2Dmul :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv2Dcmul : Pointer to function : r_ beta alpha t_ k_ srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv2Dcmul" + p_conv2Dcmul :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_validXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_validXCorr3Dptr" + p_validXCorr3Dptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_validConv3Dptr" + p_validConv3Dptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullXCorr3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_fullXCorr3Dptr" + p_fullXCorr3Dptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_fullConv3Dptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_fullConv3Dptr" + p_fullConv3Dptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_validXCorr3DRevptr : Pointer to function : r_ alpha t_ it ir ic k_ kt kr kc st sr sc -> void +foreign import ccall "THTensorConv.h &THShortTensor_validXCorr3DRevptr" + p_validXCorr3DRevptr :: FunPtr (Ptr CShort -> CShort -> Ptr CShort -> CLLong -> CLLong -> CLLong -> Ptr CShort -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3DRevger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv3DRevger" + p_conv3DRevger :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> IO ()) + +-- | p_conv3Dger : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv3Dger" + p_conv3Dger :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmv : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv3Dmv" + p_conv3Dmv :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv3Dmul" + p_conv3Dmul :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) + +-- | p_conv3Dcmul : Pointer to function : r_ beta alpha t_ k_ sdepth srow scol vf xc -> void +foreign import ccall "THTensorConv.h &THShortTensor_conv3Dcmul" + p_conv3Dcmul :: FunPtr (Ptr C'THShortTensor -> CShort -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> CLLong -> CLLong -> Ptr CChar -> Ptr CChar -> IO ()) diff --git a/src/Torch/FFI/TH/Short/TensorCopy.hs b/src/Torch/FFI/TH/Short/TensorCopy.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Short/TensorCopy.hs @@ -0,0 +1,116 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.TensorCopy where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_copy : tensor src -> void +foreign import ccall "THTensorCopy.h THShortTensor_copy" + c_copy_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_copy = const c_copy_ + +-- | c_copyByte : tensor src -> void +foreign import ccall "THTensorCopy.h THShortTensor_copyByte" + c_copyByte_ :: Ptr C'THShortTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_copyByte_ with unused argument (for CTHState) to unify backpack signatures. +c_copyByte :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THByteTensor -> IO () +c_copyByte = const c_copyByte_ + +-- | c_copyChar : tensor src -> void +foreign import ccall "THTensorCopy.h THShortTensor_copyChar" + c_copyChar_ :: Ptr C'THShortTensor -> Ptr C'THCharTensor -> IO () + +-- | alias of c_copyChar_ with unused argument (for CTHState) to unify backpack signatures. +c_copyChar :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THCharTensor -> IO () +c_copyChar = const c_copyChar_ + +-- | c_copyShort : tensor src -> void +foreign import ccall "THTensorCopy.h THShortTensor_copyShort" + c_copyShort_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_copyShort_ with unused argument (for CTHState) to unify backpack signatures. +c_copyShort :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_copyShort = const c_copyShort_ + +-- | c_copyInt : tensor src -> void +foreign import ccall "THTensorCopy.h THShortTensor_copyInt" + c_copyInt_ :: Ptr C'THShortTensor -> Ptr C'THIntTensor -> IO () + +-- | alias of c_copyInt_ with unused argument (for CTHState) to unify backpack signatures. +c_copyInt :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THIntTensor -> IO () +c_copyInt = const c_copyInt_ + +-- | c_copyLong : tensor src -> void +foreign import ccall "THTensorCopy.h THShortTensor_copyLong" + c_copyLong_ :: Ptr C'THShortTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_copyLong_ with unused argument (for CTHState) to unify backpack signatures. +c_copyLong :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> IO () +c_copyLong = const c_copyLong_ + +-- | c_copyFloat : tensor src -> void +foreign import ccall "THTensorCopy.h THShortTensor_copyFloat" + c_copyFloat_ :: Ptr C'THShortTensor -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_copyFloat_ with unused argument (for CTHState) to unify backpack signatures. +c_copyFloat :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THFloatTensor -> IO () +c_copyFloat = const c_copyFloat_ + +-- | c_copyDouble : tensor src -> void +foreign import ccall "THTensorCopy.h THShortTensor_copyDouble" + c_copyDouble_ :: Ptr C'THShortTensor -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_copyDouble_ with unused argument (for CTHState) to unify backpack signatures. +c_copyDouble :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THDoubleTensor -> IO () +c_copyDouble = const c_copyDouble_ + +-- | c_copyHalf : tensor src -> void +foreign import ccall "THTensorCopy.h THShortTensor_copyHalf" + c_copyHalf_ :: Ptr C'THShortTensor -> Ptr C'THHalfTensor -> IO () + +-- | alias of c_copyHalf_ with unused argument (for CTHState) to unify backpack signatures. +c_copyHalf :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THHalfTensor -> IO () +c_copyHalf = const c_copyHalf_ + +-- | p_copy : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THShortTensor_copy" + p_copy :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_copyByte : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THShortTensor_copyByte" + p_copyByte :: FunPtr (Ptr C'THShortTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_copyChar : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THShortTensor_copyChar" + p_copyChar :: FunPtr (Ptr C'THShortTensor -> Ptr C'THCharTensor -> IO ()) + +-- | p_copyShort : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THShortTensor_copyShort" + p_copyShort :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_copyInt : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THShortTensor_copyInt" + p_copyInt :: FunPtr (Ptr C'THShortTensor -> Ptr C'THIntTensor -> IO ()) + +-- | p_copyLong : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THShortTensor_copyLong" + p_copyLong :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_copyFloat : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THShortTensor_copyFloat" + p_copyFloat :: FunPtr (Ptr C'THShortTensor -> Ptr C'THFloatTensor -> IO ()) + +-- | p_copyDouble : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THShortTensor_copyDouble" + p_copyDouble :: FunPtr (Ptr C'THShortTensor -> Ptr C'THDoubleTensor -> IO ()) + +-- | p_copyHalf : Pointer to function : tensor src -> void +foreign import ccall "THTensorCopy.h &THShortTensor_copyHalf" + p_copyHalf :: FunPtr (Ptr C'THShortTensor -> Ptr C'THHalfTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Short/TensorMath.hs b/src/Torch/FFI/TH/Short/TensorMath.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Short/TensorMath.hs @@ -0,0 +1,1412 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.TensorMath where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : r_ value -> void +foreign import ccall "THTensorMath.h THShortTensor_fill" + c_fill_ :: Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> IO () +c_fill = const c_fill_ + +-- | c_zero : r_ -> void +foreign import ccall "THTensorMath.h THShortTensor_zero" + c_zero_ :: Ptr C'THShortTensor -> IO () + +-- | alias of c_zero_ with unused argument (for CTHState) to unify backpack signatures. +c_zero :: Ptr C'THState -> Ptr C'THShortTensor -> IO () +c_zero = const c_zero_ + +-- | c_maskedFill : tensor mask value -> void +foreign import ccall "THTensorMath.h THShortTensor_maskedFill" + c_maskedFill_ :: Ptr C'THShortTensor -> Ptr C'THByteTensor -> CShort -> IO () + +-- | alias of c_maskedFill_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedFill :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THByteTensor -> CShort -> IO () +c_maskedFill = const c_maskedFill_ + +-- | c_maskedCopy : tensor mask src -> void +foreign import ccall "THTensorMath.h THShortTensor_maskedCopy" + c_maskedCopy_ :: Ptr C'THShortTensor -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_maskedCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedCopy :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> IO () +c_maskedCopy = const c_maskedCopy_ + +-- | c_maskedSelect : tensor src mask -> void +foreign import ccall "THTensorMath.h THShortTensor_maskedSelect" + c_maskedSelect_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THByteTensor -> IO () + +-- | alias of c_maskedSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_maskedSelect :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THByteTensor -> IO () +c_maskedSelect = const c_maskedSelect_ + +-- | c_nonzero : subscript tensor -> void +foreign import ccall "THTensorMath.h THShortTensor_nonzero" + c_nonzero_ :: Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_nonzero_ with unused argument (for CTHState) to unify backpack signatures. +c_nonzero :: Ptr C'THState -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () +c_nonzero = const c_nonzero_ + +-- | c_indexSelect : tensor src dim index -> void +foreign import ccall "THTensorMath.h THShortTensor_indexSelect" + c_indexSelect_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_indexSelect_ with unused argument (for CTHState) to unify backpack signatures. +c_indexSelect :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_indexSelect = const c_indexSelect_ + +-- | c_indexCopy : tensor dim index src -> void +foreign import ccall "THTensorMath.h THShortTensor_indexCopy" + c_indexCopy_ :: Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_indexCopy_ with unused argument (for CTHState) to unify backpack signatures. +c_indexCopy :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () +c_indexCopy = const c_indexCopy_ + +-- | c_indexAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THShortTensor_indexAdd" + c_indexAdd_ :: Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_indexAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_indexAdd :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () +c_indexAdd = const c_indexAdd_ + +-- | c_indexFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THShortTensor_indexFill" + c_indexFill_ :: Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> CShort -> IO () + +-- | alias of c_indexFill_ with unused argument (for CTHState) to unify backpack signatures. +c_indexFill :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> CShort -> IO () +c_indexFill = const c_indexFill_ + +-- | c_take : tensor src index -> void +foreign import ccall "THTensorMath.h THShortTensor_take" + c_take_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> IO () + +-- | alias of c_take_ with unused argument (for CTHState) to unify backpack signatures. +c_take :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> IO () +c_take = const c_take_ + +-- | c_put : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h THShortTensor_put" + c_put_ :: Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> IO () + +-- | alias of c_put_ with unused argument (for CTHState) to unify backpack signatures. +c_put :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> IO () +c_put = const c_put_ + +-- | c_gather : tensor src dim index -> void +foreign import ccall "THTensorMath.h THShortTensor_gather" + c_gather_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> IO () + +-- | alias of c_gather_ with unused argument (for CTHState) to unify backpack signatures. +c_gather :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> IO () +c_gather = const c_gather_ + +-- | c_scatter : tensor dim index src -> void +foreign import ccall "THTensorMath.h THShortTensor_scatter" + c_scatter_ :: Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_scatter_ with unused argument (for CTHState) to unify backpack signatures. +c_scatter :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () +c_scatter = const c_scatter_ + +-- | c_scatterAdd : tensor dim index src -> void +foreign import ccall "THTensorMath.h THShortTensor_scatterAdd" + c_scatterAdd_ :: Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_scatterAdd_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterAdd :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO () +c_scatterAdd = const c_scatterAdd_ + +-- | c_scatterFill : tensor dim index val -> void +foreign import ccall "THTensorMath.h THShortTensor_scatterFill" + c_scatterFill_ :: Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> CShort -> IO () + +-- | alias of c_scatterFill_ with unused argument (for CTHState) to unify backpack signatures. +c_scatterFill :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> CShort -> IO () +c_scatterFill = const c_scatterFill_ + +-- | c_dot : t src -> accreal +foreign import ccall "THTensorMath.h THShortTensor_dot" + c_dot_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CLong + +-- | alias of c_dot_ with unused argument (for CTHState) to unify backpack signatures. +c_dot :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CLong +c_dot = const c_dot_ + +-- | c_minall : t -> real +foreign import ccall "THTensorMath.h THShortTensor_minall" + c_minall_ :: Ptr C'THShortTensor -> IO CShort + +-- | alias of c_minall_ with unused argument (for CTHState) to unify backpack signatures. +c_minall :: Ptr C'THState -> Ptr C'THShortTensor -> IO CShort +c_minall = const c_minall_ + +-- | c_maxall : t -> real +foreign import ccall "THTensorMath.h THShortTensor_maxall" + c_maxall_ :: Ptr C'THShortTensor -> IO CShort + +-- | alias of c_maxall_ with unused argument (for CTHState) to unify backpack signatures. +c_maxall :: Ptr C'THState -> Ptr C'THShortTensor -> IO CShort +c_maxall = const c_maxall_ + +-- | c_medianall : t -> real +foreign import ccall "THTensorMath.h THShortTensor_medianall" + c_medianall_ :: Ptr C'THShortTensor -> IO CShort + +-- | alias of c_medianall_ with unused argument (for CTHState) to unify backpack signatures. +c_medianall :: Ptr C'THState -> Ptr C'THShortTensor -> IO CShort +c_medianall = const c_medianall_ + +-- | c_sumall : t -> accreal +foreign import ccall "THTensorMath.h THShortTensor_sumall" + c_sumall_ :: Ptr C'THShortTensor -> IO CLong + +-- | alias of c_sumall_ with unused argument (for CTHState) to unify backpack signatures. +c_sumall :: Ptr C'THState -> Ptr C'THShortTensor -> IO CLong +c_sumall = const c_sumall_ + +-- | c_prodall : t -> accreal +foreign import ccall "THTensorMath.h THShortTensor_prodall" + c_prodall_ :: Ptr C'THShortTensor -> IO CLong + +-- | alias of c_prodall_ with unused argument (for CTHState) to unify backpack signatures. +c_prodall :: Ptr C'THState -> Ptr C'THShortTensor -> IO CLong +c_prodall = const c_prodall_ + +-- | c_neg : self src -> void +foreign import ccall "THTensorMath.h THShortTensor_neg" + c_neg_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_neg = const c_neg_ + +-- | c_add : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_add" + c_add_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_add_ with unused argument (for CTHState) to unify backpack signatures. +c_add :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_add = const c_add_ + +-- | c_sub : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_sub" + c_sub_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_sub_ with unused argument (for CTHState) to unify backpack signatures. +c_sub :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_sub = const c_sub_ + +-- | c_add_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THShortTensor_add_scaled" + c_add_scaled_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> CShort -> IO () + +-- | alias of c_add_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_add_scaled :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> CShort -> IO () +c_add_scaled = const c_add_scaled_ + +-- | c_sub_scaled : r_ t value alpha -> void +foreign import ccall "THTensorMath.h THShortTensor_sub_scaled" + c_sub_scaled_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> CShort -> IO () + +-- | alias of c_sub_scaled_ with unused argument (for CTHState) to unify backpack signatures. +c_sub_scaled :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> CShort -> IO () +c_sub_scaled = const c_sub_scaled_ + +-- | c_mul : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_mul" + c_mul_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_mul_ with unused argument (for CTHState) to unify backpack signatures. +c_mul :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_mul = const c_mul_ + +-- | c_div : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_div" + c_div_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_div_ with unused argument (for CTHState) to unify backpack signatures. +c_div :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_div = const c_div_ + +-- | c_lshift : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_lshift" + c_lshift_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_lshift_ with unused argument (for CTHState) to unify backpack signatures. +c_lshift :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_lshift = const c_lshift_ + +-- | c_rshift : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_rshift" + c_rshift_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_rshift_ with unused argument (for CTHState) to unify backpack signatures. +c_rshift :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_rshift = const c_rshift_ + +-- | c_fmod : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_fmod" + c_fmod_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_fmod_ with unused argument (for CTHState) to unify backpack signatures. +c_fmod :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_fmod = const c_fmod_ + +-- | c_remainder : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_remainder" + c_remainder_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_remainder_ with unused argument (for CTHState) to unify backpack signatures. +c_remainder :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_remainder = const c_remainder_ + +-- | c_clamp : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h THShortTensor_clamp" + c_clamp_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> CShort -> IO () + +-- | alias of c_clamp_ with unused argument (for CTHState) to unify backpack signatures. +c_clamp :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> CShort -> IO () +c_clamp = const c_clamp_ + +-- | c_bitand : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_bitand" + c_bitand_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_bitand_ with unused argument (for CTHState) to unify backpack signatures. +c_bitand :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_bitand = const c_bitand_ + +-- | c_bitor : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_bitor" + c_bitor_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_bitor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitor :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_bitor = const c_bitor_ + +-- | c_bitxor : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_bitxor" + c_bitxor_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_bitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_bitxor :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_bitxor = const c_bitxor_ + +-- | c_cadd : r_ t value src -> void +foreign import ccall "THTensorMath.h THShortTensor_cadd" + c_cadd_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> IO () +c_cadd = const c_cadd_ + +-- | c_csub : self src1 value src2 -> void +foreign import ccall "THTensorMath.h THShortTensor_csub" + c_csub_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> IO () + +-- | alias of c_csub_ with unused argument (for CTHState) to unify backpack signatures. +c_csub :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> IO () +c_csub = const c_csub_ + +-- | c_cmul : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cmul" + c_cmul_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cmul = const c_cmul_ + +-- | c_cpow : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cpow" + c_cpow_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cpow_ with unused argument (for CTHState) to unify backpack signatures. +c_cpow :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cpow = const c_cpow_ + +-- | c_cdiv : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cdiv" + c_cdiv_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cdiv = const c_cdiv_ + +-- | c_clshift : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_clshift" + c_clshift_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_clshift_ with unused argument (for CTHState) to unify backpack signatures. +c_clshift :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_clshift = const c_clshift_ + +-- | c_crshift : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_crshift" + c_crshift_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_crshift_ with unused argument (for CTHState) to unify backpack signatures. +c_crshift :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_crshift = const c_crshift_ + +-- | c_cfmod : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cfmod" + c_cfmod_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cfmod_ with unused argument (for CTHState) to unify backpack signatures. +c_cfmod :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cfmod = const c_cfmod_ + +-- | c_cremainder : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cremainder" + c_cremainder_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cremainder_ with unused argument (for CTHState) to unify backpack signatures. +c_cremainder :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cremainder = const c_cremainder_ + +-- | c_cbitand : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cbitand" + c_cbitand_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cbitand_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitand :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cbitand = const c_cbitand_ + +-- | c_cbitor : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cbitor" + c_cbitor_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cbitor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitor :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cbitor = const c_cbitor_ + +-- | c_cbitxor : r_ t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cbitxor" + c_cbitxor_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cbitxor_ with unused argument (for CTHState) to unify backpack signatures. +c_cbitxor :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cbitxor = const c_cbitxor_ + +-- | c_addcmul : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THShortTensor_addcmul" + c_addcmul_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_addcmul_ with unused argument (for CTHState) to unify backpack signatures. +c_addcmul :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_addcmul = const c_addcmul_ + +-- | c_addcdiv : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h THShortTensor_addcdiv" + c_addcdiv_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_addcdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_addcdiv :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_addcdiv = const c_addcdiv_ + +-- | c_addmv : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h THShortTensor_addmv" + c_addmv_ :: Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_addmv_ with unused argument (for CTHState) to unify backpack signatures. +c_addmv :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_addmv = const c_addmv_ + +-- | c_addmm : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h THShortTensor_addmm" + c_addmm_ :: Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_addmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addmm :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_addmm = const c_addmm_ + +-- | c_addr : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h THShortTensor_addr" + c_addr_ :: Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_addr_ with unused argument (for CTHState) to unify backpack signatures. +c_addr :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_addr = const c_addr_ + +-- | c_addbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THShortTensor_addbmm" + c_addbmm_ :: Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_addbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_addbmm :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_addbmm = const c_addbmm_ + +-- | c_baddbmm : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h THShortTensor_baddbmm" + c_baddbmm_ :: Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_baddbmm_ with unused argument (for CTHState) to unify backpack signatures. +c_baddbmm :: Ptr C'THState -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_baddbmm = const c_baddbmm_ + +-- | c_match : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h THShortTensor_match" + c_match_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_match_ with unused argument (for CTHState) to unify backpack signatures. +c_match :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_match = const c_match_ + +-- | c_numel : t -> ptrdiff_t +foreign import ccall "THTensorMath.h THShortTensor_numel" + c_numel_ :: Ptr C'THShortTensor -> IO CPtrdiff + +-- | alias of c_numel_ with unused argument (for CTHState) to unify backpack signatures. +c_numel :: Ptr C'THState -> Ptr C'THShortTensor -> IO CPtrdiff +c_numel = const c_numel_ + +-- | c_preserveReduceDimSemantics : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h THShortTensor_preserveReduceDimSemantics" + c_preserveReduceDimSemantics_ :: Ptr C'THShortTensor -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_preserveReduceDimSemantics_ with unused argument (for CTHState) to unify backpack signatures. +c_preserveReduceDimSemantics :: Ptr C'THState -> Ptr C'THShortTensor -> CInt -> CInt -> CInt -> IO () +c_preserveReduceDimSemantics = const c_preserveReduceDimSemantics_ + +-- | c_max : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THShortTensor_max" + c_max_ :: Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () + +-- | alias of c_max_ with unused argument (for CTHState) to unify backpack signatures. +c_max :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () +c_max = const c_max_ + +-- | c_min : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THShortTensor_min" + c_min_ :: Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () + +-- | alias of c_min_ with unused argument (for CTHState) to unify backpack signatures. +c_min :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () +c_min = const c_min_ + +-- | c_kthvalue : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h THShortTensor_kthvalue" + c_kthvalue_ :: Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CLLong -> CInt -> CInt -> IO () + +-- | alias of c_kthvalue_ with unused argument (for CTHState) to unify backpack signatures. +c_kthvalue :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CLLong -> CInt -> CInt -> IO () +c_kthvalue = const c_kthvalue_ + +-- | c_mode : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THShortTensor_mode" + c_mode_ :: Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () + +-- | alias of c_mode_ with unused argument (for CTHState) to unify backpack signatures. +c_mode :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () +c_mode = const c_mode_ + +-- | c_median : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THShortTensor_median" + c_median_ :: Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () + +-- | alias of c_median_ with unused argument (for CTHState) to unify backpack signatures. +c_median :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () +c_median = const c_median_ + +-- | c_sum : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THShortTensor_sum" + c_sum_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () + +-- | alias of c_sum_ with unused argument (for CTHState) to unify backpack signatures. +c_sum :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () +c_sum = const c_sum_ + +-- | c_prod : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h THShortTensor_prod" + c_prod_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () + +-- | alias of c_prod_ with unused argument (for CTHState) to unify backpack signatures. +c_prod :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () +c_prod = const c_prod_ + +-- | c_cumsum : r_ t dimension -> void +foreign import ccall "THTensorMath.h THShortTensor_cumsum" + c_cumsum_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () + +-- | alias of c_cumsum_ with unused argument (for CTHState) to unify backpack signatures. +c_cumsum :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () +c_cumsum = const c_cumsum_ + +-- | c_cumprod : r_ t dimension -> void +foreign import ccall "THTensorMath.h THShortTensor_cumprod" + c_cumprod_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () + +-- | alias of c_cumprod_ with unused argument (for CTHState) to unify backpack signatures. +c_cumprod :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () +c_cumprod = const c_cumprod_ + +-- | c_sign : r_ t -> void +foreign import ccall "THTensorMath.h THShortTensor_sign" + c_sign_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_sign_ with unused argument (for CTHState) to unify backpack signatures. +c_sign :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_sign = const c_sign_ + +-- | c_trace : t -> accreal +foreign import ccall "THTensorMath.h THShortTensor_trace" + c_trace_ :: Ptr C'THShortTensor -> IO CLong + +-- | alias of c_trace_ with unused argument (for CTHState) to unify backpack signatures. +c_trace :: Ptr C'THState -> Ptr C'THShortTensor -> IO CLong +c_trace = const c_trace_ + +-- | c_cross : r_ a b dimension -> void +foreign import ccall "THTensorMath.h THShortTensor_cross" + c_cross_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () + +-- | alias of c_cross_ with unused argument (for CTHState) to unify backpack signatures. +c_cross :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () +c_cross = const c_cross_ + +-- | c_cmax : r t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cmax" + c_cmax_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cmax_ with unused argument (for CTHState) to unify backpack signatures. +c_cmax :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cmax = const c_cmax_ + +-- | c_cmin : r t src -> void +foreign import ccall "THTensorMath.h THShortTensor_cmin" + c_cmin_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_cmin_ with unused argument (for CTHState) to unify backpack signatures. +c_cmin :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_cmin = const c_cmin_ + +-- | c_cmaxValue : r t value -> void +foreign import ccall "THTensorMath.h THShortTensor_cmaxValue" + c_cmaxValue_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_cmaxValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cmaxValue :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_cmaxValue = const c_cmaxValue_ + +-- | c_cminValue : r t value -> void +foreign import ccall "THTensorMath.h THShortTensor_cminValue" + c_cminValue_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_cminValue_ with unused argument (for CTHState) to unify backpack signatures. +c_cminValue :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_cminValue = const c_cminValue_ + +-- | c_zeros : r_ size -> void +foreign import ccall "THTensorMath.h THShortTensor_zeros" + c_zeros_ :: Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_zeros_ with unused argument (for CTHState) to unify backpack signatures. +c_zeros :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO () +c_zeros = const c_zeros_ + +-- | c_zerosLike : r_ input -> void +foreign import ccall "THTensorMath.h THShortTensor_zerosLike" + c_zerosLike_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_zerosLike_ with unused argument (for CTHState) to unify backpack signatures. +c_zerosLike :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_zerosLike = const c_zerosLike_ + +-- | c_ones : r_ size -> void +foreign import ccall "THTensorMath.h THShortTensor_ones" + c_ones_ :: Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_ones_ with unused argument (for CTHState) to unify backpack signatures. +c_ones :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO () +c_ones = const c_ones_ + +-- | c_onesLike : r_ input -> void +foreign import ccall "THTensorMath.h THShortTensor_onesLike" + c_onesLike_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_onesLike_ with unused argument (for CTHState) to unify backpack signatures. +c_onesLike :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_onesLike = const c_onesLike_ + +-- | c_diag : r_ t k -> void +foreign import ccall "THTensorMath.h THShortTensor_diag" + c_diag_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () + +-- | alias of c_diag_ with unused argument (for CTHState) to unify backpack signatures. +c_diag :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () +c_diag = const c_diag_ + +-- | c_eye : r_ n m -> void +foreign import ccall "THTensorMath.h THShortTensor_eye" + c_eye_ :: Ptr C'THShortTensor -> CLLong -> CLLong -> IO () + +-- | alias of c_eye_ with unused argument (for CTHState) to unify backpack signatures. +c_eye :: Ptr C'THState -> Ptr C'THShortTensor -> CLLong -> CLLong -> IO () +c_eye = const c_eye_ + +-- | c_arange : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THShortTensor_arange" + c_arange_ :: Ptr C'THShortTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_arange_ with unused argument (for CTHState) to unify backpack signatures. +c_arange :: Ptr C'THState -> Ptr C'THShortTensor -> CLong -> CLong -> CLong -> IO () +c_arange = const c_arange_ + +-- | c_range : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h THShortTensor_range" + c_range_ :: Ptr C'THShortTensor -> CLong -> CLong -> CLong -> IO () + +-- | alias of c_range_ with unused argument (for CTHState) to unify backpack signatures. +c_range :: Ptr C'THState -> Ptr C'THShortTensor -> CLong -> CLong -> CLong -> IO () +c_range = const c_range_ + +-- | c_randperm : r_ _generator n -> void +foreign import ccall "THTensorMath.h THShortTensor_randperm" + c_randperm_ :: Ptr C'THShortTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_randperm_ with unused argument (for CTHState) to unify backpack signatures. +c_randperm :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_randperm = const c_randperm_ + +-- | c_reshape : r_ t size -> void +foreign import ccall "THTensorMath.h THShortTensor_reshape" + c_reshape_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO () + +-- | alias of c_reshape_ with unused argument (for CTHState) to unify backpack signatures. +c_reshape :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO () +c_reshape = const c_reshape_ + +-- | c_sort : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h THShortTensor_sort" + c_sort_ :: Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () + +-- | alias of c_sort_ with unused argument (for CTHState) to unify backpack signatures. +c_sort :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO () +c_sort = const c_sort_ + +-- | c_topk : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h THShortTensor_topk" + c_topk_ :: Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CLLong -> CInt -> CInt -> CInt -> IO () + +-- | alias of c_topk_ with unused argument (for CTHState) to unify backpack signatures. +c_topk :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CLLong -> CInt -> CInt -> CInt -> IO () +c_topk = const c_topk_ + +-- | c_tril : r_ t k -> void +foreign import ccall "THTensorMath.h THShortTensor_tril" + c_tril_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> IO () + +-- | alias of c_tril_ with unused argument (for CTHState) to unify backpack signatures. +c_tril :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> IO () +c_tril = const c_tril_ + +-- | c_triu : r_ t k -> void +foreign import ccall "THTensorMath.h THShortTensor_triu" + c_triu_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> IO () + +-- | alias of c_triu_ with unused argument (for CTHState) to unify backpack signatures. +c_triu :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> IO () +c_triu = const c_triu_ + +-- | c_cat : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h THShortTensor_cat" + c_cat_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () + +-- | alias of c_cat_ with unused argument (for CTHState) to unify backpack signatures. +c_cat :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO () +c_cat = const c_cat_ + +-- | c_catArray : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h THShortTensor_catArray" + c_catArray_ :: Ptr C'THShortTensor -> Ptr (Ptr C'THShortTensor) -> CInt -> CInt -> IO () + +-- | alias of c_catArray_ with unused argument (for CTHState) to unify backpack signatures. +c_catArray :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr (Ptr C'THShortTensor) -> CInt -> CInt -> IO () +c_catArray = const c_catArray_ + +-- | c_equal : ta tb -> int +foreign import ccall "THTensorMath.h THShortTensor_equal" + c_equal_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CInt + +-- | alias of c_equal_ with unused argument (for CTHState) to unify backpack signatures. +c_equal :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CInt +c_equal = const c_equal_ + +-- | c_ltValue : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_ltValue" + c_ltValue_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_ltValue_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_ltValue = const c_ltValue_ + +-- | c_leValue : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_leValue" + c_leValue_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_leValue_ with unused argument (for CTHState) to unify backpack signatures. +c_leValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_leValue = const c_leValue_ + +-- | c_gtValue : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_gtValue" + c_gtValue_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_gtValue_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_gtValue = const c_gtValue_ + +-- | c_geValue : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_geValue" + c_geValue_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_geValue_ with unused argument (for CTHState) to unify backpack signatures. +c_geValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_geValue = const c_geValue_ + +-- | c_neValue : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_neValue" + c_neValue_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_neValue_ with unused argument (for CTHState) to unify backpack signatures. +c_neValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_neValue = const c_neValue_ + +-- | c_eqValue : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_eqValue" + c_eqValue_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_eqValue_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValue :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_eqValue = const c_eqValue_ + +-- | c_ltValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_ltValueT" + c_ltValueT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_ltValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltValueT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_ltValueT = const c_ltValueT_ + +-- | c_leValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_leValueT" + c_leValueT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_leValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_leValueT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_leValueT = const c_leValueT_ + +-- | c_gtValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_gtValueT" + c_gtValueT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_gtValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtValueT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_gtValueT = const c_gtValueT_ + +-- | c_geValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_geValueT" + c_geValueT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_geValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_geValueT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_geValueT = const c_geValueT_ + +-- | c_neValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_neValueT" + c_neValueT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_neValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_neValueT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_neValueT = const c_neValueT_ + +-- | c_eqValueT : r_ t value -> void +foreign import ccall "THTensorMath.h THShortTensor_eqValueT" + c_eqValueT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () + +-- | alias of c_eqValueT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqValueT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO () +c_eqValueT = const c_eqValueT_ + +-- | c_ltTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_ltTensor" + c_ltTensor_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_ltTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_ltTensor = const c_ltTensor_ + +-- | c_leTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_leTensor" + c_leTensor_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_leTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_leTensor = const c_leTensor_ + +-- | c_gtTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_gtTensor" + c_gtTensor_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_gtTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_gtTensor = const c_gtTensor_ + +-- | c_geTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_geTensor" + c_geTensor_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_geTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_geTensor = const c_geTensor_ + +-- | c_neTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_neTensor" + c_neTensor_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_neTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_neTensor = const c_neTensor_ + +-- | c_eqTensor : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_eqTensor" + c_eqTensor_ :: Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_eqTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensor :: Ptr C'THState -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_eqTensor = const c_eqTensor_ + +-- | c_ltTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_ltTensorT" + c_ltTensorT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_ltTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_ltTensorT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_ltTensorT = const c_ltTensorT_ + +-- | c_leTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_leTensorT" + c_leTensorT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_leTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_leTensorT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_leTensorT = const c_leTensorT_ + +-- | c_gtTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_gtTensorT" + c_gtTensorT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_gtTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_gtTensorT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_gtTensorT = const c_gtTensorT_ + +-- | c_geTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_geTensorT" + c_geTensorT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_geTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_geTensorT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_geTensorT = const c_geTensorT_ + +-- | c_neTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_neTensorT" + c_neTensorT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_neTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_neTensorT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_neTensorT = const c_neTensorT_ + +-- | c_eqTensorT : r_ ta tb -> void +foreign import ccall "THTensorMath.h THShortTensor_eqTensorT" + c_eqTensorT_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_eqTensorT_ with unused argument (for CTHState) to unify backpack signatures. +c_eqTensorT :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_eqTensorT = const c_eqTensorT_ + +-- | c_abs : r_ t -> void +foreign import ccall "THTensorMath.h THShortTensor_abs" + c_abs_ :: Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO () +c_abs = const c_abs_ + +-- | p_fill : Pointer to function : r_ value -> void +foreign import ccall "THTensorMath.h &THShortTensor_fill" + p_fill :: FunPtr (Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_zero : Pointer to function : r_ -> void +foreign import ccall "THTensorMath.h &THShortTensor_zero" + p_zero :: FunPtr (Ptr C'THShortTensor -> IO ()) + +-- | p_maskedFill : Pointer to function : tensor mask value -> void +foreign import ccall "THTensorMath.h &THShortTensor_maskedFill" + p_maskedFill :: FunPtr (Ptr C'THShortTensor -> Ptr C'THByteTensor -> CShort -> IO ()) + +-- | p_maskedCopy : Pointer to function : tensor mask src -> void +foreign import ccall "THTensorMath.h &THShortTensor_maskedCopy" + p_maskedCopy :: FunPtr (Ptr C'THShortTensor -> Ptr C'THByteTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_maskedSelect : Pointer to function : tensor src mask -> void +foreign import ccall "THTensorMath.h &THShortTensor_maskedSelect" + p_maskedSelect :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THByteTensor -> IO ()) + +-- | p_nonzero : Pointer to function : subscript tensor -> void +foreign import ccall "THTensorMath.h &THShortTensor_nonzero" + p_nonzero :: FunPtr (Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_indexSelect : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THShortTensor_indexSelect" + p_indexSelect :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_indexCopy : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THShortTensor_indexCopy" + p_indexCopy :: FunPtr (Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_indexAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THShortTensor_indexAdd" + p_indexAdd :: FunPtr (Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_indexFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THShortTensor_indexFill" + p_indexFill :: FunPtr (Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> CShort -> IO ()) + +-- | p_take : Pointer to function : tensor src index -> void +foreign import ccall "THTensorMath.h &THShortTensor_take" + p_take :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THLongTensor -> IO ()) + +-- | p_put : Pointer to function : tensor index src accumulate -> void +foreign import ccall "THTensorMath.h &THShortTensor_put" + p_put :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> IO ()) + +-- | p_gather : Pointer to function : tensor src dim index -> void +foreign import ccall "THTensorMath.h &THShortTensor_gather" + p_gather :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> IO ()) + +-- | p_scatter : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THShortTensor_scatter" + p_scatter :: FunPtr (Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_scatterAdd : Pointer to function : tensor dim index src -> void +foreign import ccall "THTensorMath.h &THShortTensor_scatterAdd" + p_scatterAdd :: FunPtr (Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_scatterFill : Pointer to function : tensor dim index val -> void +foreign import ccall "THTensorMath.h &THShortTensor_scatterFill" + p_scatterFill :: FunPtr (Ptr C'THShortTensor -> CInt -> Ptr C'THLongTensor -> CShort -> IO ()) + +-- | p_dot : Pointer to function : t src -> accreal +foreign import ccall "THTensorMath.h &THShortTensor_dot" + p_dot :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CLong) + +-- | p_minall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THShortTensor_minall" + p_minall :: FunPtr (Ptr C'THShortTensor -> IO CShort) + +-- | p_maxall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THShortTensor_maxall" + p_maxall :: FunPtr (Ptr C'THShortTensor -> IO CShort) + +-- | p_medianall : Pointer to function : t -> real +foreign import ccall "THTensorMath.h &THShortTensor_medianall" + p_medianall :: FunPtr (Ptr C'THShortTensor -> IO CShort) + +-- | p_sumall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THShortTensor_sumall" + p_sumall :: FunPtr (Ptr C'THShortTensor -> IO CLong) + +-- | p_prodall : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THShortTensor_prodall" + p_prodall :: FunPtr (Ptr C'THShortTensor -> IO CLong) + +-- | p_neg : Pointer to function : self src -> void +foreign import ccall "THTensorMath.h &THShortTensor_neg" + p_neg :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_add : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_add" + p_add :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_sub : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_sub" + p_sub :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_add_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THShortTensor_add_scaled" + p_add_scaled :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> CShort -> IO ()) + +-- | p_sub_scaled : Pointer to function : r_ t value alpha -> void +foreign import ccall "THTensorMath.h &THShortTensor_sub_scaled" + p_sub_scaled :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> CShort -> IO ()) + +-- | p_mul : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_mul" + p_mul :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_div : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_div" + p_div :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_lshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_lshift" + p_lshift :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_rshift : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_rshift" + p_rshift :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_fmod : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_fmod" + p_fmod :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_remainder : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_remainder" + p_remainder :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_clamp : Pointer to function : r_ t min_value max_value -> void +foreign import ccall "THTensorMath.h &THShortTensor_clamp" + p_clamp :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> CShort -> IO ()) + +-- | p_bitand : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_bitand" + p_bitand :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_bitor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_bitor" + p_bitor :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_bitxor : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_bitxor" + p_bitxor :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_cadd : Pointer to function : r_ t value src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cadd" + p_cadd :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> IO ()) + +-- | p_csub : Pointer to function : self src1 value src2 -> void +foreign import ccall "THTensorMath.h &THShortTensor_csub" + p_csub :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> IO ()) + +-- | p_cmul : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cmul" + p_cmul :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_cpow : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cpow" + p_cpow :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_cdiv : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cdiv" + p_cdiv :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_clshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_clshift" + p_clshift :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_crshift : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_crshift" + p_crshift :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_cfmod : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cfmod" + p_cfmod :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_cremainder : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cremainder" + p_cremainder :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_cbitand : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cbitand" + p_cbitand :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_cbitor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cbitor" + p_cbitor :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_cbitxor : Pointer to function : r_ t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cbitxor" + p_cbitxor :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_addcmul : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THShortTensor_addcmul" + p_addcmul :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_addcdiv : Pointer to function : r_ t value src1 src2 -> void +foreign import ccall "THTensorMath.h &THShortTensor_addcdiv" + p_addcdiv :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_addmv : Pointer to function : r_ beta t alpha mat vec -> void +foreign import ccall "THTensorMath.h &THShortTensor_addmv" + p_addmv :: FunPtr (Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_addmm : Pointer to function : r_ beta t alpha mat1 mat2 -> void +foreign import ccall "THTensorMath.h &THShortTensor_addmm" + p_addmm :: FunPtr (Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_addr : Pointer to function : r_ beta t alpha vec1 vec2 -> void +foreign import ccall "THTensorMath.h &THShortTensor_addr" + p_addr :: FunPtr (Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_addbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THShortTensor_addbmm" + p_addbmm :: FunPtr (Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_baddbmm : Pointer to function : r_ beta t alpha batch1 batch2 -> void +foreign import ccall "THTensorMath.h &THShortTensor_baddbmm" + p_baddbmm :: FunPtr (Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> CShort -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_match : Pointer to function : r_ m1 m2 gain -> void +foreign import ccall "THTensorMath.h &THShortTensor_match" + p_match :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_numel : Pointer to function : t -> ptrdiff_t +foreign import ccall "THTensorMath.h &THShortTensor_numel" + p_numel :: FunPtr (Ptr C'THShortTensor -> IO CPtrdiff) + +-- | p_preserveReduceDimSemantics : Pointer to function : r_ in_dims reduce_dimension keepdim -> void +foreign import ccall "THTensorMath.h &THShortTensor_preserveReduceDimSemantics" + p_preserveReduceDimSemantics :: FunPtr (Ptr C'THShortTensor -> CInt -> CInt -> CInt -> IO ()) + +-- | p_max : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THShortTensor_max" + p_max :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO ()) + +-- | p_min : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THShortTensor_min" + p_min :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO ()) + +-- | p_kthvalue : Pointer to function : values_ indices_ t k dimension keepdim -> void +foreign import ccall "THTensorMath.h &THShortTensor_kthvalue" + p_kthvalue :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CLLong -> CInt -> CInt -> IO ()) + +-- | p_mode : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THShortTensor_mode" + p_mode :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO ()) + +-- | p_median : Pointer to function : values_ indices_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THShortTensor_median" + p_median :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO ()) + +-- | p_sum : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THShortTensor_sum" + p_sum :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO ()) + +-- | p_prod : Pointer to function : r_ t dimension keepdim -> void +foreign import ccall "THTensorMath.h &THShortTensor_prod" + p_prod :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO ()) + +-- | p_cumsum : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THShortTensor_cumsum" + p_cumsum :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO ()) + +-- | p_cumprod : Pointer to function : r_ t dimension -> void +foreign import ccall "THTensorMath.h &THShortTensor_cumprod" + p_cumprod :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO ()) + +-- | p_sign : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THShortTensor_sign" + p_sign :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_trace : Pointer to function : t -> accreal +foreign import ccall "THTensorMath.h &THShortTensor_trace" + p_trace :: FunPtr (Ptr C'THShortTensor -> IO CLong) + +-- | p_cross : Pointer to function : r_ a b dimension -> void +foreign import ccall "THTensorMath.h &THShortTensor_cross" + p_cross :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO ()) + +-- | p_cmax : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cmax" + p_cmax :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_cmin : Pointer to function : r t src -> void +foreign import ccall "THTensorMath.h &THShortTensor_cmin" + p_cmin :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_cmaxValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_cmaxValue" + p_cmaxValue :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_cminValue : Pointer to function : r t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_cminValue" + p_cminValue :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_zeros : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THShortTensor_zeros" + p_zeros :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_zerosLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THShortTensor_zerosLike" + p_zerosLike :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_ones : Pointer to function : r_ size -> void +foreign import ccall "THTensorMath.h &THShortTensor_ones" + p_ones :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_onesLike : Pointer to function : r_ input -> void +foreign import ccall "THTensorMath.h &THShortTensor_onesLike" + p_onesLike :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_diag : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THShortTensor_diag" + p_diag :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO ()) + +-- | p_eye : Pointer to function : r_ n m -> void +foreign import ccall "THTensorMath.h &THShortTensor_eye" + p_eye :: FunPtr (Ptr C'THShortTensor -> CLLong -> CLLong -> IO ()) + +-- | p_arange : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THShortTensor_arange" + p_arange :: FunPtr (Ptr C'THShortTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_range : Pointer to function : r_ xmin xmax step -> void +foreign import ccall "THTensorMath.h &THShortTensor_range" + p_range :: FunPtr (Ptr C'THShortTensor -> CLong -> CLong -> CLong -> IO ()) + +-- | p_randperm : Pointer to function : r_ _generator n -> void +foreign import ccall "THTensorMath.h &THShortTensor_randperm" + p_randperm :: FunPtr (Ptr C'THShortTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_reshape : Pointer to function : r_ t size -> void +foreign import ccall "THTensorMath.h &THShortTensor_reshape" + p_reshape :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THLongStorage -> IO ()) + +-- | p_sort : Pointer to function : rt_ ri_ t dimension descendingOrder -> void +foreign import ccall "THTensorMath.h &THShortTensor_sort" + p_sort :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CInt -> CInt -> IO ()) + +-- | p_topk : Pointer to function : rt_ ri_ t k dim dir sorted -> void +foreign import ccall "THTensorMath.h &THShortTensor_topk" + p_topk :: FunPtr (Ptr C'THShortTensor -> Ptr C'THLongTensor -> Ptr C'THShortTensor -> CLLong -> CInt -> CInt -> CInt -> IO ()) + +-- | p_tril : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THShortTensor_tril" + p_tril :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> IO ()) + +-- | p_triu : Pointer to function : r_ t k -> void +foreign import ccall "THTensorMath.h &THShortTensor_triu" + p_triu :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CLLong -> IO ()) + +-- | p_cat : Pointer to function : r_ ta tb dimension -> void +foreign import ccall "THTensorMath.h &THShortTensor_cat" + p_cat :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> CInt -> IO ()) + +-- | p_catArray : Pointer to function : result inputs numInputs dimension -> void +foreign import ccall "THTensorMath.h &THShortTensor_catArray" + p_catArray :: FunPtr (Ptr C'THShortTensor -> Ptr (Ptr C'THShortTensor) -> CInt -> CInt -> IO ()) + +-- | p_equal : Pointer to function : ta tb -> int +foreign import ccall "THTensorMath.h &THShortTensor_equal" + p_equal :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO CInt) + +-- | p_ltValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_ltValue" + p_ltValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_leValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_leValue" + p_leValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_gtValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_gtValue" + p_gtValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_geValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_geValue" + p_geValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_neValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_neValue" + p_neValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_eqValue : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_eqValue" + p_eqValue :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_ltValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_ltValueT" + p_ltValueT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_leValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_leValueT" + p_leValueT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_gtValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_gtValueT" + p_gtValueT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_geValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_geValueT" + p_geValueT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_neValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_neValueT" + p_neValueT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_eqValueT : Pointer to function : r_ t value -> void +foreign import ccall "THTensorMath.h &THShortTensor_eqValueT" + p_eqValueT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> CShort -> IO ()) + +-- | p_ltTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_ltTensor" + p_ltTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_leTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_leTensor" + p_leTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_gtTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_gtTensor" + p_gtTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_geTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_geTensor" + p_geTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_neTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_neTensor" + p_neTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_eqTensor : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_eqTensor" + p_eqTensor :: FunPtr (Ptr C'THByteTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_ltTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_ltTensorT" + p_ltTensorT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_leTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_leTensorT" + p_leTensorT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_gtTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_gtTensorT" + p_gtTensorT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_geTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_geTensorT" + p_geTensorT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_neTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_neTensorT" + p_neTensorT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_eqTensorT : Pointer to function : r_ ta tb -> void +foreign import ccall "THTensorMath.h &THShortTensor_eqTensorT" + p_eqTensorT :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) + +-- | p_abs : Pointer to function : r_ t -> void +foreign import ccall "THTensorMath.h &THShortTensor_abs" + p_abs :: FunPtr (Ptr C'THShortTensor -> Ptr C'THShortTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Short/TensorRandom.hs b/src/Torch/FFI/TH/Short/TensorRandom.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Short/TensorRandom.hs @@ -0,0 +1,92 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.TensorRandom where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_random : self _generator -> void +foreign import ccall "THTensorRandom.h THShortTensor_random" + c_random_ :: Ptr C'THShortTensor -> Ptr C'THGenerator -> IO () + +-- | alias of c_random_ with unused argument (for CTHState) to unify backpack signatures. +c_random :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THGenerator -> IO () +c_random = const c_random_ + +-- | c_clampedRandom : self _generator min max -> void +foreign import ccall "THTensorRandom.h THShortTensor_clampedRandom" + c_clampedRandom_ :: Ptr C'THShortTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () + +-- | alias of c_clampedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_clampedRandom :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO () +c_clampedRandom = const c_clampedRandom_ + +-- | c_cappedRandom : self _generator max -> void +foreign import ccall "THTensorRandom.h THShortTensor_cappedRandom" + c_cappedRandom_ :: Ptr C'THShortTensor -> Ptr C'THGenerator -> CLLong -> IO () + +-- | alias of c_cappedRandom_ with unused argument (for CTHState) to unify backpack signatures. +c_cappedRandom :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THGenerator -> CLLong -> IO () +c_cappedRandom = const c_cappedRandom_ + +-- | c_geometric : self _generator p -> void +foreign import ccall "THTensorRandom.h THShortTensor_geometric" + c_geometric_ :: Ptr C'THShortTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_geometric_ with unused argument (for CTHState) to unify backpack signatures. +c_geometric :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_geometric = const c_geometric_ + +-- | c_bernoulli : self _generator p -> void +foreign import ccall "THTensorRandom.h THShortTensor_bernoulli" + c_bernoulli_ :: Ptr C'THShortTensor -> Ptr C'THGenerator -> CDouble -> IO () + +-- | alias of c_bernoulli_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THGenerator -> CDouble -> IO () +c_bernoulli = const c_bernoulli_ + +-- | c_bernoulli_FloatTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THShortTensor_bernoulli_FloatTensor" + c_bernoulli_FloatTensor_ :: Ptr C'THShortTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () + +-- | alias of c_bernoulli_FloatTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_FloatTensor :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO () +c_bernoulli_FloatTensor = const c_bernoulli_FloatTensor_ + +-- | c_bernoulli_DoubleTensor : self _generator p -> void +foreign import ccall "THTensorRandom.h THShortTensor_bernoulli_DoubleTensor" + c_bernoulli_DoubleTensor_ :: Ptr C'THShortTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () + +-- | alias of c_bernoulli_DoubleTensor_ with unused argument (for CTHState) to unify backpack signatures. +c_bernoulli_DoubleTensor :: Ptr C'THState -> Ptr C'THShortTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO () +c_bernoulli_DoubleTensor = const c_bernoulli_DoubleTensor_ + +-- | p_random : Pointer to function : self _generator -> void +foreign import ccall "THTensorRandom.h &THShortTensor_random" + p_random :: FunPtr (Ptr C'THShortTensor -> Ptr C'THGenerator -> IO ()) + +-- | p_clampedRandom : Pointer to function : self _generator min max -> void +foreign import ccall "THTensorRandom.h &THShortTensor_clampedRandom" + p_clampedRandom :: FunPtr (Ptr C'THShortTensor -> Ptr C'THGenerator -> CLLong -> CLLong -> IO ()) + +-- | p_cappedRandom : Pointer to function : self _generator max -> void +foreign import ccall "THTensorRandom.h &THShortTensor_cappedRandom" + p_cappedRandom :: FunPtr (Ptr C'THShortTensor -> Ptr C'THGenerator -> CLLong -> IO ()) + +-- | p_geometric : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THShortTensor_geometric" + p_geometric :: FunPtr (Ptr C'THShortTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THShortTensor_bernoulli" + p_bernoulli :: FunPtr (Ptr C'THShortTensor -> Ptr C'THGenerator -> CDouble -> IO ()) + +-- | p_bernoulli_FloatTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THShortTensor_bernoulli_FloatTensor" + p_bernoulli_FloatTensor :: FunPtr (Ptr C'THShortTensor -> Ptr C'THGenerator -> Ptr C'THFloatTensor -> IO ()) + +-- | p_bernoulli_DoubleTensor : Pointer to function : self _generator p -> void +foreign import ccall "THTensorRandom.h &THShortTensor_bernoulli_DoubleTensor" + p_bernoulli_DoubleTensor :: FunPtr (Ptr C'THShortTensor -> Ptr C'THGenerator -> Ptr C'THDoubleTensor -> IO ()) diff --git a/src/Torch/FFI/TH/Short/Vector.hs b/src/Torch/FFI/TH/Short/Vector.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Short/Vector.hs @@ -0,0 +1,140 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Short.Vector where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_fill : x c n -> void +foreign import ccall "THVector.h THShortVector_fill" + c_fill_ :: Ptr CShort -> CShort -> CPtrdiff -> IO () + +-- | alias of c_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_fill :: Ptr C'THState -> Ptr CShort -> CShort -> CPtrdiff -> IO () +c_fill = const c_fill_ + +-- | c_cadd : z x y c n -> void +foreign import ccall "THVector.h THShortVector_cadd" + c_cadd_ :: Ptr CShort -> Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO () + +-- | alias of c_cadd_ with unused argument (for CTHState) to unify backpack signatures. +c_cadd :: Ptr C'THState -> Ptr CShort -> Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO () +c_cadd = const c_cadd_ + +-- | c_adds : y x c n -> void +foreign import ccall "THVector.h THShortVector_adds" + c_adds_ :: Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO () + +-- | alias of c_adds_ with unused argument (for CTHState) to unify backpack signatures. +c_adds :: Ptr C'THState -> Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO () +c_adds = const c_adds_ + +-- | c_cmul : z x y n -> void +foreign import ccall "THVector.h THShortVector_cmul" + c_cmul_ :: Ptr CShort -> Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () + +-- | alias of c_cmul_ with unused argument (for CTHState) to unify backpack signatures. +c_cmul :: Ptr C'THState -> Ptr CShort -> Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () +c_cmul = const c_cmul_ + +-- | c_muls : y x c n -> void +foreign import ccall "THVector.h THShortVector_muls" + c_muls_ :: Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO () + +-- | alias of c_muls_ with unused argument (for CTHState) to unify backpack signatures. +c_muls :: Ptr C'THState -> Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO () +c_muls = const c_muls_ + +-- | c_cdiv : z x y n -> void +foreign import ccall "THVector.h THShortVector_cdiv" + c_cdiv_ :: Ptr CShort -> Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () + +-- | alias of c_cdiv_ with unused argument (for CTHState) to unify backpack signatures. +c_cdiv :: Ptr C'THState -> Ptr CShort -> Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () +c_cdiv = const c_cdiv_ + +-- | c_divs : y x c n -> void +foreign import ccall "THVector.h THShortVector_divs" + c_divs_ :: Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO () + +-- | alias of c_divs_ with unused argument (for CTHState) to unify backpack signatures. +c_divs :: Ptr C'THState -> Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO () +c_divs = const c_divs_ + +-- | c_copy : y x n -> void +foreign import ccall "THVector.h THShortVector_copy" + c_copy_ :: Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () + +-- | alias of c_copy_ with unused argument (for CTHState) to unify backpack signatures. +c_copy :: Ptr C'THState -> Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () +c_copy = const c_copy_ + +-- | c_neg : y x n -> void +foreign import ccall "THVector.h THShortVector_neg" + c_neg_ :: Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () + +-- | alias of c_neg_ with unused argument (for CTHState) to unify backpack signatures. +c_neg :: Ptr C'THState -> Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () +c_neg = const c_neg_ + +-- | c_normal_fill : data size generator mean stddev -> void +foreign import ccall "THVector.h THShortVector_normal_fill" + c_normal_fill_ :: Ptr CShort -> CLLong -> Ptr C'THGenerator -> CShort -> CShort -> IO () + +-- | alias of c_normal_fill_ with unused argument (for CTHState) to unify backpack signatures. +c_normal_fill :: Ptr C'THState -> Ptr CShort -> CLLong -> Ptr C'THGenerator -> CShort -> CShort -> IO () +c_normal_fill = const c_normal_fill_ + +-- | c_abs : y x n -> void +foreign import ccall "THVector.h THShortVector_abs" + c_abs_ :: Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () + +-- | alias of c_abs_ with unused argument (for CTHState) to unify backpack signatures. +c_abs :: Ptr C'THState -> Ptr CShort -> Ptr CShort -> CPtrdiff -> IO () +c_abs = const c_abs_ + +-- | p_fill : Pointer to function : x c n -> void +foreign import ccall "THVector.h &THShortVector_fill" + p_fill :: FunPtr (Ptr CShort -> CShort -> CPtrdiff -> IO ()) + +-- | p_cadd : Pointer to function : z x y c n -> void +foreign import ccall "THVector.h &THShortVector_cadd" + p_cadd :: FunPtr (Ptr CShort -> Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO ()) + +-- | p_adds : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THShortVector_adds" + p_adds :: FunPtr (Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO ()) + +-- | p_cmul : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THShortVector_cmul" + p_cmul :: FunPtr (Ptr CShort -> Ptr CShort -> Ptr CShort -> CPtrdiff -> IO ()) + +-- | p_muls : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THShortVector_muls" + p_muls :: FunPtr (Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO ()) + +-- | p_cdiv : Pointer to function : z x y n -> void +foreign import ccall "THVector.h &THShortVector_cdiv" + p_cdiv :: FunPtr (Ptr CShort -> Ptr CShort -> Ptr CShort -> CPtrdiff -> IO ()) + +-- | p_divs : Pointer to function : y x c n -> void +foreign import ccall "THVector.h &THShortVector_divs" + p_divs :: FunPtr (Ptr CShort -> Ptr CShort -> CShort -> CPtrdiff -> IO ()) + +-- | p_copy : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THShortVector_copy" + p_copy :: FunPtr (Ptr CShort -> Ptr CShort -> CPtrdiff -> IO ()) + +-- | p_neg : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THShortVector_neg" + p_neg :: FunPtr (Ptr CShort -> Ptr CShort -> CPtrdiff -> IO ()) + +-- | p_normal_fill : Pointer to function : data size generator mean stddev -> void +foreign import ccall "THVector.h &THShortVector_normal_fill" + p_normal_fill :: FunPtr (Ptr CShort -> CLLong -> Ptr C'THGenerator -> CShort -> CShort -> IO ()) + +-- | p_abs : Pointer to function : y x n -> void +foreign import ccall "THVector.h &THShortVector_abs" + p_abs :: FunPtr (Ptr CShort -> Ptr CShort -> CPtrdiff -> IO ()) diff --git a/src/Torch/FFI/TH/Size.hs b/src/Torch/FFI/TH/Size.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Size.hs @@ -0,0 +1,24 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Size where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_THSize_isSameSizeAs : sizeA dimsA sizeB dimsB -> int +foreign import ccall "THSize.h THSize_isSameSizeAs" + c_THSize_isSameSizeAs :: Ptr CLLong -> CLLong -> Ptr CLLong -> CLLong -> IO CInt + +-- | c_THSize_nElement : dims size -> ptrdiff_t +foreign import ccall "THSize.h THSize_nElement" + c_THSize_nElement :: CLLong -> Ptr CLLong -> IO CPtrdiff + +-- | p_THSize_isSameSizeAs : Pointer to function : sizeA dimsA sizeB dimsB -> int +foreign import ccall "THSize.h &THSize_isSameSizeAs" + p_THSize_isSameSizeAs :: FunPtr (Ptr CLLong -> CLLong -> Ptr CLLong -> CLLong -> IO CInt) + +-- | p_THSize_nElement : Pointer to function : dims size -> ptrdiff_t +foreign import ccall "THSize.h &THSize_nElement" + p_THSize_nElement :: FunPtr (CLLong -> Ptr CLLong -> IO CPtrdiff) diff --git a/src/Torch/FFI/TH/Storage.hs b/src/Torch/FFI/TH/Storage.hs new file mode 100644 --- /dev/null +++ b/src/Torch/FFI/TH/Storage.hs @@ -0,0 +1,48 @@ +{-# LANGUAGE ForeignFunctionInterface #-} +module Torch.FFI.TH.Storage where + +import Foreign +import Foreign.C.Types +import Data.Word +import Data.Int +import Torch.Types.TH + +-- | c_THLongStorage_sizeDesc : size -> THDescBuff +foreign import ccall "THStorage.h THLongStorage_sizeDesc" + c_THLongStorage_sizeDesc :: Ptr C'THLongStorage -> IO (Ptr C'THDescBuff) + +-- | c_THLongStorage_newInferSize : size nElement -> THLongStorage * +foreign import ccall "THStorage.h THLongStorage_newInferSize" + c_THLongStorage_newInferSize :: Ptr C'THLongStorage -> CPtrdiff -> IO (Ptr C'THLongStorage) + +-- | c_THLongStorage_inferSize2 : output sizesA dimsA sizesB dimsB error_buffer buffer_len -> int +foreign import ccall "THStorage.h THLongStorage_inferSize2" + c_THLongStorage_inferSize2 :: Ptr C'THLongStorage -> Ptr CLLong -> CLLong -> Ptr CLLong -> CLLong -> Ptr CChar -> CInt -> IO CInt + +-- | c_THLongStorage_inferSizeN : output n sizes dims error_buffer buffer_len -> int +foreign import ccall "THStorage.h THLongStorage_inferSizeN" + c_THLongStorage_inferSizeN :: Ptr C'THLongStorage -> CInt -> Ptr (Ptr CLLong) -> Ptr CLLong -> Ptr CChar -> CInt -> IO CInt + +-- | c_THLongStorage_inferExpandGeometry : tensorSizes tensorStrides tensorDim sizes expandedSizes expandedStrides error_buffer buffer_len -> int +foreign import ccall "THStorage.h THLongStorage_inferExpandGeometry" + c_THLongStorage_inferExpandGeometry :: Ptr CLLong -> Ptr CLLong -> CLLong -> Ptr C'THLongStorage -> Ptr (Ptr CLLong) -> Ptr (Ptr CLLong) -> Ptr CChar -> CInt -> IO CInt + +-- | p_THLongStorage_sizeDesc : Pointer to function : size -> THDescBuff +foreign import ccall "THStorage.h &THLongStorage_sizeDesc" + p_THLongStorage_sizeDesc :: FunPtr (Ptr C'THLongStorage -> IO (Ptr C'THDescBuff)) + +-- | p_THLongStorage_newInferSize : Pointer to function : size nElement -> THLongStorage * +foreign import ccall "THStorage.h &THLongStorage_newInferSize" + p_THLongStorage_newInferSize :: FunPtr (Ptr C'THLongStorage -> CPtrdiff -> IO (Ptr C'THLongStorage)) + +-- | p_THLongStorage_inferSize2 : Pointer to function : output sizesA dimsA sizesB dimsB error_buffer buffer_len -> int +foreign import ccall "THStorage.h &THLongStorage_inferSize2" + p_THLongStorage_inferSize2 :: FunPtr (Ptr C'THLongStorage -> Ptr CLLong -> CLLong -> Ptr CLLong -> CLLong -> Ptr CChar -> CInt -> IO CInt) + +-- | p_THLongStorage_inferSizeN : Pointer to function : output n sizes dims error_buffer buffer_len -> int +foreign import ccall "THStorage.h &THLongStorage_inferSizeN" + p_THLongStorage_inferSizeN :: FunPtr (Ptr C'THLongStorage -> CInt -> Ptr (Ptr CLLong) -> Ptr CLLong -> Ptr CChar -> CInt -> IO CInt) + +-- | p_THLongStorage_inferExpandGeometry : Pointer to function : tensorSizes tensorStrides tensorDim sizes expandedSizes expandedStrides error_buffer buffer_len -> int +foreign import ccall "THStorage.h &THLongStorage_inferExpandGeometry" + p_THLongStorage_inferExpandGeometry :: FunPtr (Ptr CLLong -> Ptr CLLong -> CLLong -> Ptr C'THLongStorage -> Ptr (Ptr CLLong) -> Ptr (Ptr CLLong) -> Ptr CChar -> CInt -> IO CInt) diff --git a/tests/MathSpec.hs b/tests/MathSpec.hs new file mode 100644 --- /dev/null +++ b/tests/MathSpec.hs @@ -0,0 +1,59 @@ +module MathSpec (spec) where + +import Foreign +import Foreign.C.Types +import Test.Hspec +import Torch.FFI.TH.Random + +import qualified Torch.FFI.TH.Double.Tensor as D +import qualified Torch.FFI.TH.Double.TensorMath as D +import qualified Torch.FFI.TH.Double.TensorRandom as D + +import qualified Torch.FFI.TH.Float.Tensor as F +import qualified Torch.FFI.TH.Float.TensorMath as F +import qualified Torch.FFI.TH.Float.TensorRandom as F + +import qualified Torch.FFI.TH.Int.Tensor as I +import qualified Torch.FFI.TH.Int.TensorMath as I +import qualified Torch.FFI.TH.Int.TensorRandom as I + + +main :: IO () +main = hspec spec + +spec :: Spec +spec = + describe "Math" $ do + it "Can initialize values with the fill method" $ do + t1 <- D.c_newWithSize2d nullPtr 2 2 + D.c_fill nullPtr t1 3.1 + r <- D.c_get2d nullPtr t1 0 0 + r `shouldBe` (3.1 :: CDouble) + D.c_free nullPtr t1 + it "Can invert double values with cinv" $ do + t1 <- D.c_newWithSize2d nullPtr 3 2 + D.c_fill nullPtr t1 2.0 + result <- D.c_newWithSize2d nullPtr 3 2 + D.c_cinv nullPtr result t1 + r <- D.c_get2d nullPtr result 0 0 + r `shouldBe` (0.5 :: CDouble) + r <- D.c_get2d nullPtr t1 0 0 + r `shouldBe` (2.0 :: CDouble) + D.c_free nullPtr t1 + D.c_free nullPtr result + + -- cinv doesn't seem to be excluded by the preprocessor, yet is not implemented + -- for Int + -- it "Can invert int values with cinv (?)" $ do + -- t1 <- c_THIntTensor_newWithSize2d 3 2 + -- c_THIntTensor_fill t1 2 + -- result <- c_THIntTensor_newWithSize2d 3 2 + -- c_THIntTensor_cinv result t1 + -- c_THIntTensor_get2d result 0 0 `shouldBe` (0 :: CInt) + -- c_THIntTensor_get2d t1 0 0 `shouldBe` (2 :: CInt) + -- c_THIntTensor_free t1 + -- c_THIntTensor_free result + + + + diff --git a/tests/NNSpec.hs b/tests/NNSpec.hs new file mode 100644 --- /dev/null +++ b/tests/NNSpec.hs @@ -0,0 +1,63 @@ +{-# LANGUAGE ConstraintKinds #-} +module NNSpec (spec) where + +import Foreign +import Foreign.C.Types + +import Test.Hspec + +import Torch.Types.TH + +import Torch.FFI.TH.NN.Double as D +import Torch.FFI.TH.Double.Tensor as D +import Torch.FFI.TH.Double.TensorMath as D +import Torch.FFI.TH.Double.TensorRandom as D + +import Torch.FFI.TH.NN.Float as F +import Torch.FFI.TH.Float.Tensor as F +import Torch.FFI.TH.Float.TensorMath as F +import Torch.FFI.TH.Float.TensorRandom as F + +import Torch.FFI.TH.Random as R + +import Torch.FFI.TestsNN + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "Float NNs" $ testSuite nullPtr floatBook + describe "Double NNs" $ testSuite nullPtr doubleBook + +doubleBook :: NNTestSuite (Ptr C'THNNState) (Ptr C'THDoubleTensor) CDouble CDouble (Ptr C'THGenerator) +doubleBook = NNTestSuite + { _newWithSize1d = D.c_newWithSize1d + , _newWithSize2d = D.c_newWithSize2d + , _newGen = R.c_THGenerator_new + , _normal = Left D.c_normal + , _fill = D.c_fill + , _sumall = D.c_sumall + , _free = D.c_free + , _nnAbsUpdateOutput = D.c_Abs_updateOutput + , _nnHSUpdateOutput = Just D.c_HardShrink_updateOutput + , _nnL1UpdateOutput = D.c_L1Cost_updateOutput + , _nnRReLUUpdateOutput = D.c_RReLU_updateOutput + } + + +floatBook :: NNTestSuite (Ptr C'THNNState) (Ptr C'THFloatTensor) CFloat CDouble (Ptr C'THGenerator) +floatBook = NNTestSuite + { _newWithSize1d = F.c_newWithSize1d + , _newWithSize2d = F.c_newWithSize2d + , _newGen = R.c_THGenerator_new + , _normal = Left F.c_normal + , _fill = F.c_fill + , _sumall = F.c_sumall + , _free = F.c_free + , _nnAbsUpdateOutput = F.c_Abs_updateOutput + , _nnHSUpdateOutput = Just F.c_HardShrink_updateOutput + , _nnL1UpdateOutput = F.c_L1Cost_updateOutput + , _nnRReLUUpdateOutput = F.c_RReLU_updateOutput + } + diff --git a/tests/Spec.hs b/tests/Spec.hs new file mode 100644 --- /dev/null +++ b/tests/Spec.hs @@ -0,0 +1,1 @@ +{-# OPTIONS_GHC -F -pgmF hspec-discover #-} diff --git a/tests/TensorSpec.hs b/tests/TensorSpec.hs new file mode 100644 --- /dev/null +++ b/tests/TensorSpec.hs @@ -0,0 +1,204 @@ +module TensorSpec (spec) where + +import Foreign +import Foreign.C.Types + +import Test.Hspec + +import Torch.FFI.Tests + +import Torch.Types.TH (C'THState) +import qualified Torch.Types.TH.Byte as B +import qualified Torch.FFI.TH.Byte.Tensor as B +import qualified Torch.FFI.TH.Byte.TensorMath as B + +import qualified Torch.Types.TH.Float as F +import qualified Torch.FFI.TH.Float.Tensor as F +import qualified Torch.FFI.TH.Float.TensorMath as F + +import qualified Torch.Types.TH.Double as D +import qualified Torch.FFI.TH.Double.Tensor as D +import qualified Torch.FFI.TH.Double.TensorMath as D + +import qualified Torch.Types.TH.Int as I +import qualified Torch.FFI.TH.Int.Tensor as I +import qualified Torch.FFI.TH.Int.TensorMath as I + +import qualified Torch.Types.TH.Short as S +import qualified Torch.FFI.TH.Short.Tensor as S +import qualified Torch.FFI.TH.Short.TensorMath as S + +import qualified Torch.Types.TH.Long as L +import qualified Torch.FFI.TH.Long.Tensor as L +import qualified Torch.FFI.TH.Long.TensorMath as L + +main :: IO () +main = hspec spec + +spec :: Spec +spec = do + describe "Float Tensor creation and access methods" $ signedSuite nullPtr floatBook + describe "Double Tensor creation and access methods" $ signedSuite nullPtr doubleBook + describe "Byte Tensor creation and access methods" $ signedSuite nullPtr byteBook + describe "Int Tensor creation and access methods" $ signedSuite nullPtr intBook + describe "Long Tensor creation and access methods" $ signedSuite nullPtr longBook + describe "Short Tensor creation and access methods" $ signedSuite nullPtr shortBook + +type CState = Ptr C'THState + +longBook :: TestFunctions CState (Ptr L.CTensor) L.CReal L.CAccReal +longBook = TestFunctions + { _new = L.c_new + , _newWithSize1d = L.c_newWithSize1d + , _newWithSize2d = L.c_newWithSize2d + , _newWithSize3d = L.c_newWithSize3d + , _newWithSize4d = L.c_newWithSize4d + , _nDimension = L.c_nDimension + , _set1d = L.c_set1d + , _get1d = L.c_get1d + , _set2d = L.c_set2d + , _get2d = L.c_get2d + , _set3d = L.c_set3d + , _get3d = L.c_get3d + , _set4d = L.c_set4d + , _get4d = L.c_get4d + , _size = L.c_size + , _fill = L.c_fill + , _free = L.c_free + , _sumall = L.c_sumall + , _prodall = L.c_prodall + , _zero = L.c_zero + , _dot = Just L.c_dot + , _abs = Just L.c_abs + } + +shortBook :: TestFunctions CState (Ptr S.CTensor) S.CReal S.CAccReal +shortBook = TestFunctions + { _new = S.c_new + , _newWithSize1d = S.c_newWithSize1d + , _newWithSize2d = S.c_newWithSize2d + , _newWithSize3d = S.c_newWithSize3d + , _newWithSize4d = S.c_newWithSize4d + , _nDimension = S.c_nDimension + , _set1d = S.c_set1d + , _get1d = S.c_get1d + , _set2d = S.c_set2d + , _get2d = S.c_get2d + , _set3d = S.c_set3d + , _get3d = S.c_get3d + , _set4d = S.c_set4d + , _get4d = S.c_get4d + , _size = S.c_size + , _fill = S.c_fill + , _free = S.c_free + , _sumall = S.c_sumall + , _prodall = S.c_prodall + , _zero = S.c_zero + , _dot = Just S.c_dot + , _abs = Just S.c_abs + } + +floatBook :: TestFunctions CState (Ptr F.CTensor) F.CReal F.CAccReal +floatBook = TestFunctions + { _new = F.c_new + , _newWithSize1d = F.c_newWithSize1d + , _newWithSize2d = F.c_newWithSize2d + , _newWithSize3d = F.c_newWithSize3d + , _newWithSize4d = F.c_newWithSize4d + , _nDimension = F.c_nDimension + , _set1d = F.c_set1d + , _get1d = F.c_get1d + , _set2d = F.c_set2d + , _get2d = F.c_get2d + , _set3d = F.c_set3d + , _get3d = F.c_get3d + , _set4d = F.c_set4d + , _get4d = F.c_get4d + , _size = F.c_size + , _fill = F.c_fill + , _free = F.c_free + , _sumall = F.c_sumall + , _prodall = F.c_prodall + , _zero = F.c_zero + , _dot = Just F.c_dot + , _abs = Just F.c_abs + } + +doubleBook :: TestFunctions CState (Ptr D.CTensor) D.CReal D.CAccReal +doubleBook = TestFunctions + { _new = D.c_new + , _newWithSize1d = D.c_newWithSize1d + , _newWithSize2d = D.c_newWithSize2d + , _newWithSize3d = D.c_newWithSize3d + , _newWithSize4d = D.c_newWithSize4d + , _nDimension = D.c_nDimension + , _set1d = D.c_set1d + , _get1d = D.c_get1d + , _set2d = D.c_set2d + , _get2d = D.c_get2d + , _set3d = D.c_set3d + , _get3d = D.c_get3d + , _set4d = D.c_set4d + , _get4d = D.c_get4d + , _size = D.c_size + , _fill = D.c_fill + , _free = D.c_free + , _sumall = D.c_sumall + , _prodall = D.c_prodall + , _zero = D.c_zero + , _dot = Just D.c_dot + , _abs = Just D.c_abs + } + +byteBook :: TestFunctions CState (Ptr B.CTensor) B.CReal B.CAccReal +byteBook = TestFunctions + { _new = B.c_new + , _newWithSize1d = B.c_newWithSize1d + , _newWithSize2d = B.c_newWithSize2d + , _newWithSize3d = B.c_newWithSize3d + , _newWithSize4d = B.c_newWithSize4d + , _nDimension = B.c_nDimension + , _set1d = B.c_set1d + , _get1d = B.c_get1d + , _set2d = B.c_set2d + , _get2d = B.c_get2d + , _set3d = B.c_set3d + , _get3d = B.c_get3d + , _set4d = B.c_set4d + , _get4d = B.c_get4d + , _size = B.c_size + , _fill = B.c_fill + , _free = B.c_free + , _sumall = B.c_sumall + , _prodall = B.c_prodall + , _zero = B.c_zero + , _dot = Just B.c_dot + , _abs = Nothing + } + +intBook :: TestFunctions CState (Ptr I.CTensor) I.CReal I.CAccReal +intBook = TestFunctions + { _new = I.c_new + , _newWithSize1d = I.c_newWithSize1d + , _newWithSize2d = I.c_newWithSize2d + , _newWithSize3d = I.c_newWithSize3d + , _newWithSize4d = I.c_newWithSize4d + , _nDimension = I.c_nDimension + , _set1d = I.c_set1d + , _get1d = I.c_get1d + , _set2d = I.c_set2d + , _get2d = I.c_get2d + , _set3d = I.c_set3d + , _get3d = I.c_get3d + , _set4d = I.c_set4d + , _get4d = I.c_get4d + , _size = I.c_size + , _fill = I.c_fill + , _free = I.c_free + , _sumall = I.c_sumall + , _prodall = I.c_prodall + , _zero = I.c_zero + , _dot = Just I.c_dot + , _abs = Just I.c_abs + } +