hasktorch-types-thc (empty) → 0.0.1.0
raw patch · 14 files changed
+3084/−0 lines, 14 filesdep +basedep +hasktorch-types-thdep +inline-c
Dependencies added: base, hasktorch-types-th, inline-c
Files
- hasktorch-types-thc.cabal +55/−0
- src/Torch/Types/CuRand/Structs.hs +214/−0
- src/Torch/Types/Cuda/Structs.hs +867/−0
- src/Torch/Types/THC.hs +212/−0
- src/Torch/Types/THC/Byte.hs +58/−0
- src/Torch/Types/THC/Char.hs +57/−0
- src/Torch/Types/THC/Double.hs +53/−0
- src/Torch/Types/THC/Float.hs +44/−0
- src/Torch/Types/THC/Int.hs +53/−0
- src/Torch/Types/THC/Internal.hs +41/−0
- src/Torch/Types/THC/Long.hs +52/−0
- src/Torch/Types/THC/Short.hs +53/−0
- src/Torch/Types/THC/Structs.hs +1321/−0
- src/Torch/Types/THCUNN.hs +4/−0
+ hasktorch-types-thc.cabal view
@@ -0,0 +1,55 @@+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/types/thc/hasktorch-types-thc.dhall', and re-generate this file by running+-- 'dhall-to-cabal -- ffi/types/thc/hasktorch-types-thc.dhall > hasktorch-types-thc.cabal'.+-- * * * * * * * * * * * * WARNING * * * * * * * * * * * *+name: hasktorch-types-thc+version: 0.0.1.0+license: BSD-3-Clause+maintainer: Sam Stites <fnz@fgvgrf.vb>, Austin Huang <nhfgvau@nyhz.zvg.rqh> - cipher:ROT13+author: Hasktorch dev team+homepage: https://github.com/hasktorch/hasktorch#readme+bug-reports: https://github.com/hasktorch/hasktorch/issues+synopsis: C-types for Cutorch+description:+ Includes core C-types generated from c2hsc.+category: Tensors, Machine Learning, AI, FFI+build-type: Simple++source-repository head+ type: git+ location: https://github.com/hasktorch/hasktorch++library+ exposed-modules:+ Torch.Types.THC+ Torch.Types.THCUNN+ Torch.Types.THC.Structs+ Torch.Types.Cuda.Structs+ Torch.Types.CuRand.Structs+ Torch.Types.THC.Char+ Torch.Types.THC.Byte+ Torch.Types.THC.Short+ Torch.Types.THC.Int+ Torch.Types.THC.Long+ Torch.Types.THC.Float+ Torch.Types.THC.Double+ build-tools: c2hs -any+ hs-source-dirs: src+ other-modules:+ Paths_hasktorch_types_thc+ Torch.Types.THC.Internal+ autogen-modules:+ Paths_hasktorch_types_thc+ default-language: Haskell2010+ default-extensions: KindSignatures DataKinds+ build-depends:+ base (==4.7 || >4.7) && <5,+ inline-c ==0.5 || >0.5,+ hasktorch-types-th -any+
+ src/Torch/Types/CuRand/Structs.hs view
@@ -0,0 +1,214 @@+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+++module Torch.Types.CuRand.Structs where+import Foreign.Ptr+import Foreign.Ptr (Ptr,FunPtr,plusPtr)+import Foreign.Ptr (wordPtrToPtr,castPtrToFunPtr)+import Foreign.Storable+import Foreign.C.Types+import Foreign.C.String (CString,CStringLen,CWString,CWStringLen)+import Foreign.Marshal.Alloc (alloca)+import Foreign.Marshal.Array (peekArray,pokeArray)+import Data.Int+import Data.Word+++{- struct mtgp32_params_fast {+ int mexp;+ int pos;+ int sh1;+ int sh2;+ unsigned int tbl[16];+ unsigned int tmp_tbl[16];+ unsigned int flt_tmp_tbl[16];+ unsigned int mask;+ unsigned char poly_sha1[21];+}; -}+++++++++++data C'mtgp32_params_fast = C'mtgp32_params_fast{+ c'mtgp32_params_fast'mexp :: CInt,+ c'mtgp32_params_fast'pos :: CInt,+ c'mtgp32_params_fast'sh1 :: CInt,+ c'mtgp32_params_fast'sh2 :: CInt,+ c'mtgp32_params_fast'tbl :: [CUInt],+ c'mtgp32_params_fast'tmp_tbl :: [CUInt],+ c'mtgp32_params_fast'flt_tmp_tbl :: [CUInt],+ c'mtgp32_params_fast'mask :: CUInt,+ c'mtgp32_params_fast'poly_sha1 :: [CUChar]+} deriving (Eq,Show)+p'mtgp32_params_fast'mexp p = plusPtr p 0+p'mtgp32_params_fast'mexp :: Ptr (C'mtgp32_params_fast) -> Ptr (CInt)+p'mtgp32_params_fast'pos p = plusPtr p 4+p'mtgp32_params_fast'pos :: Ptr (C'mtgp32_params_fast) -> Ptr (CInt)+p'mtgp32_params_fast'sh1 p = plusPtr p 8+p'mtgp32_params_fast'sh1 :: Ptr (C'mtgp32_params_fast) -> Ptr (CInt)+p'mtgp32_params_fast'sh2 p = plusPtr p 12+p'mtgp32_params_fast'sh2 :: Ptr (C'mtgp32_params_fast) -> Ptr (CInt)+p'mtgp32_params_fast'tbl p = plusPtr p 16+p'mtgp32_params_fast'tbl :: Ptr (C'mtgp32_params_fast) -> Ptr (CUInt)+p'mtgp32_params_fast'tmp_tbl p = plusPtr p 80+p'mtgp32_params_fast'tmp_tbl :: Ptr (C'mtgp32_params_fast) -> Ptr (CUInt)+p'mtgp32_params_fast'flt_tmp_tbl p = plusPtr p 144+p'mtgp32_params_fast'flt_tmp_tbl :: Ptr (C'mtgp32_params_fast) -> Ptr (CUInt)+p'mtgp32_params_fast'mask p = plusPtr p 208+p'mtgp32_params_fast'mask :: Ptr (C'mtgp32_params_fast) -> Ptr (CUInt)+p'mtgp32_params_fast'poly_sha1 p = plusPtr p 212+p'mtgp32_params_fast'poly_sha1 :: Ptr (C'mtgp32_params_fast) -> Ptr (CUChar)+instance Storable C'mtgp32_params_fast where+ sizeOf _ = 236+ alignment _ = 4+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 4+ v2 <- peekByteOff _p 8+ v3 <- peekByteOff _p 12+ v4 <- let s4 = div 64 $ sizeOf $ (undefined :: CUInt) in peekArray s4 (plusPtr _p 16)+ v5 <- let s5 = div 64 $ sizeOf $ (undefined :: CUInt) in peekArray s5 (plusPtr _p 80)+ v6 <- let s6 = div 64 $ sizeOf $ (undefined :: CUInt) in peekArray s6 (plusPtr _p 144)+ v7 <- peekByteOff _p 208+ v8 <- let s8 = div 21 $ sizeOf $ (undefined :: CUChar) in peekArray s8 (plusPtr _p 212)+ return $ C'mtgp32_params_fast v0 v1 v2 v3 v4 v5 v6 v7 v8+ poke _p (C'mtgp32_params_fast v0 v1 v2 v3 v4 v5 v6 v7 v8) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 4 v1+ pokeByteOff _p 8 v2+ pokeByteOff _p 12 v3+ let s4 = div 64 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 16) (take s4 v4)+ let s5 = div 64 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 80) (take s5 v5)+ let s6 = div 64 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 144) (take s6 v6)+ pokeByteOff _p 208 v7+ let s8 = div 21 $ sizeOf $ (undefined :: CUChar)+ pokeArray (plusPtr _p 212) (take s8 v8)+ return ()++{- struct mtgp32_kernel_params {+ unsigned int pos_tbl[200];+ unsigned int param_tbl[200][16];+ unsigned int temper_tbl[200][16];+ unsigned int single_temper_tbl[200][16];+ unsigned int sh1_tbl[200];+ unsigned int sh2_tbl[200];+ unsigned int mask[1];+}; -}+++++++++data C'mtgp32_kernel_params = C'mtgp32_kernel_params{+ c'mtgp32_kernel_params'pos_tbl :: [CUInt],+ c'mtgp32_kernel_params'param_tbl :: [CUInt],+ c'mtgp32_kernel_params'temper_tbl :: [CUInt],+ c'mtgp32_kernel_params'single_temper_tbl :: [CUInt],+ c'mtgp32_kernel_params'sh1_tbl :: [CUInt],+ c'mtgp32_kernel_params'sh2_tbl :: [CUInt],+ c'mtgp32_kernel_params'mask :: [CUInt]+} deriving (Eq,Show)+p'mtgp32_kernel_params'pos_tbl p = plusPtr p 0+p'mtgp32_kernel_params'pos_tbl :: Ptr (C'mtgp32_kernel_params) -> Ptr (CUInt)+p'mtgp32_kernel_params'param_tbl p = plusPtr p 800+p'mtgp32_kernel_params'param_tbl :: Ptr (C'mtgp32_kernel_params) -> Ptr (CUInt)+p'mtgp32_kernel_params'temper_tbl p = plusPtr p 13600+p'mtgp32_kernel_params'temper_tbl :: Ptr (C'mtgp32_kernel_params) -> Ptr (CUInt)+p'mtgp32_kernel_params'single_temper_tbl p = plusPtr p 26400+p'mtgp32_kernel_params'single_temper_tbl :: Ptr (C'mtgp32_kernel_params) -> Ptr (CUInt)+p'mtgp32_kernel_params'sh1_tbl p = plusPtr p 39200+p'mtgp32_kernel_params'sh1_tbl :: Ptr (C'mtgp32_kernel_params) -> Ptr (CUInt)+p'mtgp32_kernel_params'sh2_tbl p = plusPtr p 40000+p'mtgp32_kernel_params'sh2_tbl :: Ptr (C'mtgp32_kernel_params) -> Ptr (CUInt)+p'mtgp32_kernel_params'mask p = plusPtr p 40800+p'mtgp32_kernel_params'mask :: Ptr (C'mtgp32_kernel_params) -> Ptr (CUInt)+instance Storable C'mtgp32_kernel_params where+ sizeOf _ = 40804+ alignment _ = 4+ peek _p = do+ v0 <- let s0 = div 800 $ sizeOf $ (undefined :: CUInt) in peekArray s0 (plusPtr _p 0)+ v1 <- let s1 = div 12800 $ sizeOf $ (undefined :: CUInt) in peekArray s1 (plusPtr _p 800)+ v2 <- let s2 = div 12800 $ sizeOf $ (undefined :: CUInt) in peekArray s2 (plusPtr _p 13600)+ v3 <- let s3 = div 12800 $ sizeOf $ (undefined :: CUInt) in peekArray s3 (plusPtr _p 26400)+ v4 <- let s4 = div 800 $ sizeOf $ (undefined :: CUInt) in peekArray s4 (plusPtr _p 39200)+ v5 <- let s5 = div 800 $ sizeOf $ (undefined :: CUInt) in peekArray s5 (plusPtr _p 40000)+ v6 <- let s6 = div 4 $ sizeOf $ (undefined :: CUInt) in peekArray s6 (plusPtr _p 40800)+ return $ C'mtgp32_kernel_params v0 v1 v2 v3 v4 v5 v6+ poke _p (C'mtgp32_kernel_params v0 v1 v2 v3 v4 v5 v6) = do+ let s0 = div 800 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 0) (take s0 v0)+ let s1 = div 12800 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 800) (take s1 v1)+ let s2 = div 12800 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 13600) (take s2 v2)+ let s3 = div 12800 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 26400) (take s3 v3)+ let s4 = div 800 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 39200) (take s4 v4)+ let s5 = div 800 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 40000) (take s5 v5)+ let s6 = div 4 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 40800) (take s6 v6)+ return ()++{- struct curandStateMtgp32 {+ unsigned int s[1024];+ int offset;+ int pIdx;+ struct mtgp32_kernel_params * k;+ int precise_double_flag;+}; -}+++++++data C'curandStateMtgp32 = C'curandStateMtgp32{+ c'curandStateMtgp32's :: [CUInt],+ c'curandStateMtgp32'offset :: CInt,+ c'curandStateMtgp32'pIdx :: CInt,+ c'curandStateMtgp32'k :: Ptr C'mtgp32_kernel_params,+ c'curandStateMtgp32'precise_double_flag :: CInt+} deriving (Eq,Show)+p'curandStateMtgp32's p = plusPtr p 0+p'curandStateMtgp32's :: Ptr (C'curandStateMtgp32) -> Ptr (CUInt)+p'curandStateMtgp32'offset p = plusPtr p 4096+p'curandStateMtgp32'offset :: Ptr (C'curandStateMtgp32) -> Ptr (CInt)+p'curandStateMtgp32'pIdx p = plusPtr p 4100+p'curandStateMtgp32'pIdx :: Ptr (C'curandStateMtgp32) -> Ptr (CInt)+p'curandStateMtgp32'k p = plusPtr p 4104+p'curandStateMtgp32'k :: Ptr (C'curandStateMtgp32) -> Ptr (Ptr C'mtgp32_kernel_params)+p'curandStateMtgp32'precise_double_flag p = plusPtr p 4112+p'curandStateMtgp32'precise_double_flag :: Ptr (C'curandStateMtgp32) -> Ptr (CInt)+instance Storable C'curandStateMtgp32 where+ sizeOf _ = 4120+ alignment _ = 8+ peek _p = do+ v0 <- let s0 = div 4096 $ sizeOf $ (undefined :: CUInt) in peekArray s0 (plusPtr _p 0)+ v1 <- peekByteOff _p 4096+ v2 <- peekByteOff _p 4100+ v3 <- peekByteOff _p 4104+ v4 <- peekByteOff _p 4112+ return $ C'curandStateMtgp32 v0 v1 v2 v3 v4+ poke _p (C'curandStateMtgp32 v0 v1 v2 v3 v4) = do+ let s0 = div 4096 $ sizeOf $ (undefined :: CUInt)+ pokeArray (plusPtr _p 0) (take s0 v0)+ pokeByteOff _p 4096 v1+ pokeByteOff _p 4100 v2+ pokeByteOff _p 4104 v3+ pokeByteOff _p 4112 v4+ return ()+
+ src/Torch/Types/Cuda/Structs.hs view
@@ -0,0 +1,867 @@+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+++module Torch.Types.Cuda.Structs where+import Foreign.Ptr+import Foreign.Ptr (Ptr,FunPtr,plusPtr)+import Foreign.Ptr (wordPtrToPtr,castPtrToFunPtr)+import Foreign.Storable+import Foreign.C.Types+import Foreign.C.String (CString,CStringLen,CWString,CWStringLen)+import Foreign.Marshal.Alloc (alloca)+import Foreign.Marshal.Array (peekArray,pokeArray)+import Data.Int+import Data.Word+++{- typedef struct cudaDeviceProp {+ char name[256];+ size_t totalGlobalMem;+ size_t sharedMemPerBlock;+ int regsPerBlock;+ int warpSize;+ size_t memPitch;+ int maxThreadsPerBlock;+ int maxThreadsDim[3];+ int maxGridSize[3];+ int clockRate;+ size_t totalConstMem;+ int major;+ int minor;+ size_t textureAlignment;+ size_t texturePitchAlignment;+ int deviceOverlap;+ int multiProcessorCount;+ int kernelExecTimeoutEnabled;+ int integrated;+ int canMapHostMemory;+ int computeMode;+ int maxTexture1D;+ int maxTexture1DMipmap;+ int maxTexture1DLinear;+ int maxTexture2D[2];+ int maxTexture2DMipmap[2];+ int maxTexture2DLinear[3];+ int maxTexture2DGather[2];+ int maxTexture3D[3];+ int maxTexture3DAlt[3];+ int maxTextureCubemap;+ int maxTexture1DLayered[2];+ int maxTexture2DLayered[3];+ int maxTextureCubemapLayered[2];+ int maxSurface1D;+ int maxSurface2D[2];+ int maxSurface3D[3];+ int maxSurface1DLayered[2];+ int maxSurface2DLayered[3];+ int maxSurfaceCubemap;+ int maxSurfaceCubemapLayered[2];+ size_t surfaceAlignment;+ int concurrentKernels;+ int ECCEnabled;+ int pciBusID;+ int pciDeviceID;+ int pciDomainID;+ int tccDriver;+ int asyncEngineCount;+ int unifiedAddressing;+ int memoryClockRate;+ int memoryBusWidth;+ int l2CacheSize;+ int maxThreadsPerMultiProcessor;+ int streamPrioritiesSupported;+ int globalL1CacheSupported;+ int localL1CacheSupported;+ size_t sharedMemPerMultiprocessor;+ int regsPerMultiprocessor;+ int managedMemSupported;+ int isMultiGpuBoard;+ int multiGpuBoardGroupID;+ int singleToDoublePrecisionPerfRatio;+ int pageableMemoryAccess;+ int concurrentManagedAccess;+ int computePreemptionSupported;+ int canUseHostPointerForRegisteredMem;+ int cooperativeLaunch;+ int cooperativeMultiDeviceLaunch;+ } cudaDeviceProp; -}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++data C'cudaDeviceProp = C'cudaDeviceProp{+ c'cudaDeviceProp'name :: [CChar],+ c'cudaDeviceProp'totalGlobalMem :: CSize,+ c'cudaDeviceProp'sharedMemPerBlock :: CSize,+ c'cudaDeviceProp'regsPerBlock :: CInt,+ c'cudaDeviceProp'warpSize :: CInt,+ c'cudaDeviceProp'memPitch :: CSize,+ c'cudaDeviceProp'maxThreadsPerBlock :: CInt,+ c'cudaDeviceProp'maxThreadsDim :: [CInt],+ c'cudaDeviceProp'maxGridSize :: [CInt],+ c'cudaDeviceProp'clockRate :: CInt,+ c'cudaDeviceProp'totalConstMem :: CSize,+ c'cudaDeviceProp'major :: CInt,+ c'cudaDeviceProp'minor :: CInt,+ c'cudaDeviceProp'textureAlignment :: CSize,+ c'cudaDeviceProp'texturePitchAlignment :: CSize,+ c'cudaDeviceProp'deviceOverlap :: CInt,+ c'cudaDeviceProp'multiProcessorCount :: CInt,+ c'cudaDeviceProp'kernelExecTimeoutEnabled :: CInt,+ c'cudaDeviceProp'integrated :: CInt,+ c'cudaDeviceProp'canMapHostMemory :: CInt,+ c'cudaDeviceProp'computeMode :: CInt,+ c'cudaDeviceProp'maxTexture1D :: CInt,+ c'cudaDeviceProp'maxTexture1DMipmap :: CInt,+ c'cudaDeviceProp'maxTexture1DLinear :: CInt,+ c'cudaDeviceProp'maxTexture2D :: [CInt],+ c'cudaDeviceProp'maxTexture2DMipmap :: [CInt],+ c'cudaDeviceProp'maxTexture2DLinear :: [CInt],+ c'cudaDeviceProp'maxTexture2DGather :: [CInt],+ c'cudaDeviceProp'maxTexture3D :: [CInt],+ c'cudaDeviceProp'maxTexture3DAlt :: [CInt],+ c'cudaDeviceProp'maxTextureCubemap :: CInt,+ c'cudaDeviceProp'maxTexture1DLayered :: [CInt],+ c'cudaDeviceProp'maxTexture2DLayered :: [CInt],+ c'cudaDeviceProp'maxTextureCubemapLayered :: [CInt],+ c'cudaDeviceProp'maxSurface1D :: CInt,+ c'cudaDeviceProp'maxSurface2D :: [CInt],+ c'cudaDeviceProp'maxSurface3D :: [CInt],+ c'cudaDeviceProp'maxSurface1DLayered :: [CInt],+ c'cudaDeviceProp'maxSurface2DLayered :: [CInt],+ c'cudaDeviceProp'maxSurfaceCubemap :: CInt,+ c'cudaDeviceProp'maxSurfaceCubemapLayered :: [CInt],+ c'cudaDeviceProp'surfaceAlignment :: CSize,+ c'cudaDeviceProp'concurrentKernels :: CInt,+ c'cudaDeviceProp'ECCEnabled :: CInt,+ c'cudaDeviceProp'pciBusID :: CInt,+ c'cudaDeviceProp'pciDeviceID :: CInt,+ c'cudaDeviceProp'pciDomainID :: CInt,+ c'cudaDeviceProp'tccDriver :: CInt,+ c'cudaDeviceProp'asyncEngineCount :: CInt,+ c'cudaDeviceProp'unifiedAddressing :: CInt,+ c'cudaDeviceProp'memoryClockRate :: CInt,+ c'cudaDeviceProp'memoryBusWidth :: CInt,+ c'cudaDeviceProp'l2CacheSize :: CInt,+ c'cudaDeviceProp'maxThreadsPerMultiProcessor :: CInt,+ c'cudaDeviceProp'streamPrioritiesSupported :: CInt,+ c'cudaDeviceProp'globalL1CacheSupported :: CInt,+ c'cudaDeviceProp'localL1CacheSupported :: CInt,+ c'cudaDeviceProp'sharedMemPerMultiprocessor :: CSize,+ c'cudaDeviceProp'regsPerMultiprocessor :: CInt,+ c'cudaDeviceProp'managedMemSupported :: CInt,+ c'cudaDeviceProp'isMultiGpuBoard :: CInt,+ c'cudaDeviceProp'multiGpuBoardGroupID :: CInt,+ c'cudaDeviceProp'singleToDoublePrecisionPerfRatio :: CInt,+ c'cudaDeviceProp'pageableMemoryAccess :: CInt,+ c'cudaDeviceProp'concurrentManagedAccess :: CInt,+ c'cudaDeviceProp'computePreemptionSupported :: CInt,+ c'cudaDeviceProp'canUseHostPointerForRegisteredMem :: CInt,+ c'cudaDeviceProp'cooperativeLaunch :: CInt,+ c'cudaDeviceProp'cooperativeMultiDeviceLaunch :: CInt+} deriving (Eq,Show)+p'cudaDeviceProp'name p = plusPtr p 0+p'cudaDeviceProp'name :: Ptr (C'cudaDeviceProp) -> Ptr (CChar)+p'cudaDeviceProp'totalGlobalMem p = plusPtr p 256+p'cudaDeviceProp'totalGlobalMem :: Ptr (C'cudaDeviceProp) -> Ptr (CSize)+p'cudaDeviceProp'sharedMemPerBlock p = plusPtr p 264+p'cudaDeviceProp'sharedMemPerBlock :: Ptr (C'cudaDeviceProp) -> Ptr (CSize)+p'cudaDeviceProp'regsPerBlock p = plusPtr p 272+p'cudaDeviceProp'regsPerBlock :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'warpSize p = plusPtr p 276+p'cudaDeviceProp'warpSize :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'memPitch p = plusPtr p 280+p'cudaDeviceProp'memPitch :: Ptr (C'cudaDeviceProp) -> Ptr (CSize)+p'cudaDeviceProp'maxThreadsPerBlock p = plusPtr p 288+p'cudaDeviceProp'maxThreadsPerBlock :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxThreadsDim p = plusPtr p 292+p'cudaDeviceProp'maxThreadsDim :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxGridSize p = plusPtr p 304+p'cudaDeviceProp'maxGridSize :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'clockRate p = plusPtr p 316+p'cudaDeviceProp'clockRate :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'totalConstMem p = plusPtr p 320+p'cudaDeviceProp'totalConstMem :: Ptr (C'cudaDeviceProp) -> Ptr (CSize)+p'cudaDeviceProp'major p = plusPtr p 328+p'cudaDeviceProp'major :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'minor p = plusPtr p 332+p'cudaDeviceProp'minor :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'textureAlignment p = plusPtr p 336+p'cudaDeviceProp'textureAlignment :: Ptr (C'cudaDeviceProp) -> Ptr (CSize)+p'cudaDeviceProp'texturePitchAlignment p = plusPtr p 344+p'cudaDeviceProp'texturePitchAlignment :: Ptr (C'cudaDeviceProp) -> Ptr (CSize)+p'cudaDeviceProp'deviceOverlap p = plusPtr p 352+p'cudaDeviceProp'deviceOverlap :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'multiProcessorCount p = plusPtr p 356+p'cudaDeviceProp'multiProcessorCount :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'kernelExecTimeoutEnabled p = plusPtr p 360+p'cudaDeviceProp'kernelExecTimeoutEnabled :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'integrated p = plusPtr p 364+p'cudaDeviceProp'integrated :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'canMapHostMemory p = plusPtr p 368+p'cudaDeviceProp'canMapHostMemory :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'computeMode p = plusPtr p 372+p'cudaDeviceProp'computeMode :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture1D p = plusPtr p 376+p'cudaDeviceProp'maxTexture1D :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture1DMipmap p = plusPtr p 380+p'cudaDeviceProp'maxTexture1DMipmap :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture1DLinear p = plusPtr p 384+p'cudaDeviceProp'maxTexture1DLinear :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture2D p = plusPtr p 388+p'cudaDeviceProp'maxTexture2D :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture2DMipmap p = plusPtr p 396+p'cudaDeviceProp'maxTexture2DMipmap :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture2DLinear p = plusPtr p 404+p'cudaDeviceProp'maxTexture2DLinear :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture2DGather p = plusPtr p 416+p'cudaDeviceProp'maxTexture2DGather :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture3D p = plusPtr p 424+p'cudaDeviceProp'maxTexture3D :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture3DAlt p = plusPtr p 436+p'cudaDeviceProp'maxTexture3DAlt :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTextureCubemap p = plusPtr p 448+p'cudaDeviceProp'maxTextureCubemap :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture1DLayered p = plusPtr p 452+p'cudaDeviceProp'maxTexture1DLayered :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTexture2DLayered p = plusPtr p 460+p'cudaDeviceProp'maxTexture2DLayered :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxTextureCubemapLayered p = plusPtr p 472+p'cudaDeviceProp'maxTextureCubemapLayered :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxSurface1D p = plusPtr p 480+p'cudaDeviceProp'maxSurface1D :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxSurface2D p = plusPtr p 484+p'cudaDeviceProp'maxSurface2D :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxSurface3D p = plusPtr p 492+p'cudaDeviceProp'maxSurface3D :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxSurface1DLayered p = plusPtr p 504+p'cudaDeviceProp'maxSurface1DLayered :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxSurface2DLayered p = plusPtr p 512+p'cudaDeviceProp'maxSurface2DLayered :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxSurfaceCubemap p = plusPtr p 524+p'cudaDeviceProp'maxSurfaceCubemap :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxSurfaceCubemapLayered p = plusPtr p 528+p'cudaDeviceProp'maxSurfaceCubemapLayered :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'surfaceAlignment p = plusPtr p 536+p'cudaDeviceProp'surfaceAlignment :: Ptr (C'cudaDeviceProp) -> Ptr (CSize)+p'cudaDeviceProp'concurrentKernels p = plusPtr p 544+p'cudaDeviceProp'concurrentKernels :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'ECCEnabled p = plusPtr p 548+p'cudaDeviceProp'ECCEnabled :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'pciBusID p = plusPtr p 552+p'cudaDeviceProp'pciBusID :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'pciDeviceID p = plusPtr p 556+p'cudaDeviceProp'pciDeviceID :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'pciDomainID p = plusPtr p 560+p'cudaDeviceProp'pciDomainID :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'tccDriver p = plusPtr p 564+p'cudaDeviceProp'tccDriver :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'asyncEngineCount p = plusPtr p 568+p'cudaDeviceProp'asyncEngineCount :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'unifiedAddressing p = plusPtr p 572+p'cudaDeviceProp'unifiedAddressing :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'memoryClockRate p = plusPtr p 576+p'cudaDeviceProp'memoryClockRate :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'memoryBusWidth p = plusPtr p 580+p'cudaDeviceProp'memoryBusWidth :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'l2CacheSize p = plusPtr p 584+p'cudaDeviceProp'l2CacheSize :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'maxThreadsPerMultiProcessor p = plusPtr p 588+p'cudaDeviceProp'maxThreadsPerMultiProcessor :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'streamPrioritiesSupported p = plusPtr p 592+p'cudaDeviceProp'streamPrioritiesSupported :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'globalL1CacheSupported p = plusPtr p 596+p'cudaDeviceProp'globalL1CacheSupported :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'localL1CacheSupported p = plusPtr p 600+p'cudaDeviceProp'localL1CacheSupported :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'sharedMemPerMultiprocessor p = plusPtr p 608+p'cudaDeviceProp'sharedMemPerMultiprocessor :: Ptr (C'cudaDeviceProp) -> Ptr (CSize)+p'cudaDeviceProp'regsPerMultiprocessor p = plusPtr p 616+p'cudaDeviceProp'regsPerMultiprocessor :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'managedMemSupported p = plusPtr p 620+p'cudaDeviceProp'managedMemSupported :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'isMultiGpuBoard p = plusPtr p 624+p'cudaDeviceProp'isMultiGpuBoard :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'multiGpuBoardGroupID p = plusPtr p 628+p'cudaDeviceProp'multiGpuBoardGroupID :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'singleToDoublePrecisionPerfRatio p = plusPtr p 632+p'cudaDeviceProp'singleToDoublePrecisionPerfRatio :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'pageableMemoryAccess p = plusPtr p 636+p'cudaDeviceProp'pageableMemoryAccess :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'concurrentManagedAccess p = plusPtr p 640+p'cudaDeviceProp'concurrentManagedAccess :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'computePreemptionSupported p = plusPtr p 644+p'cudaDeviceProp'computePreemptionSupported :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'canUseHostPointerForRegisteredMem p = plusPtr p 648+p'cudaDeviceProp'canUseHostPointerForRegisteredMem :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'cooperativeLaunch p = plusPtr p 652+p'cudaDeviceProp'cooperativeLaunch :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+p'cudaDeviceProp'cooperativeMultiDeviceLaunch p = plusPtr p 656+p'cudaDeviceProp'cooperativeMultiDeviceLaunch :: Ptr (C'cudaDeviceProp) -> Ptr (CInt)+instance Storable C'cudaDeviceProp where+ sizeOf _ = 664+ alignment _ = 8+ peek _p = do+ v0 <- let s0 = div 256 $ sizeOf $ (undefined :: CChar) in peekArray s0 (plusPtr _p 0)+ v1 <- peekByteOff _p 256+ v2 <- peekByteOff _p 264+ v3 <- peekByteOff _p 272+ v4 <- peekByteOff _p 276+ v5 <- peekByteOff _p 280+ v6 <- peekByteOff _p 288+ v7 <- let s7 = div 12 $ sizeOf $ (undefined :: CInt) in peekArray s7 (plusPtr _p 292)+ v8 <- let s8 = div 12 $ sizeOf $ (undefined :: CInt) in peekArray s8 (plusPtr _p 304)+ v9 <- peekByteOff _p 316+ v10 <- peekByteOff _p 320+ v11 <- peekByteOff _p 328+ v12 <- peekByteOff _p 332+ v13 <- peekByteOff _p 336+ v14 <- peekByteOff _p 344+ v15 <- peekByteOff _p 352+ v16 <- peekByteOff _p 356+ v17 <- peekByteOff _p 360+ v18 <- peekByteOff _p 364+ v19 <- peekByteOff _p 368+ v20 <- peekByteOff _p 372+ v21 <- peekByteOff _p 376+ v22 <- peekByteOff _p 380+ v23 <- peekByteOff _p 384+ v24 <- let s24 = div 8 $ sizeOf $ (undefined :: CInt) in peekArray s24 (plusPtr _p 388)+ v25 <- let s25 = div 8 $ sizeOf $ (undefined :: CInt) in peekArray s25 (plusPtr _p 396)+ v26 <- let s26 = div 12 $ sizeOf $ (undefined :: CInt) in peekArray s26 (plusPtr _p 404)+ v27 <- let s27 = div 8 $ sizeOf $ (undefined :: CInt) in peekArray s27 (plusPtr _p 416)+ v28 <- let s28 = div 12 $ sizeOf $ (undefined :: CInt) in peekArray s28 (plusPtr _p 424)+ v29 <- let s29 = div 12 $ sizeOf $ (undefined :: CInt) in peekArray s29 (plusPtr _p 436)+ v30 <- peekByteOff _p 448+ v31 <- let s31 = div 8 $ sizeOf $ (undefined :: CInt) in peekArray s31 (plusPtr _p 452)+ v32 <- let s32 = div 12 $ sizeOf $ (undefined :: CInt) in peekArray s32 (plusPtr _p 460)+ v33 <- let s33 = div 8 $ sizeOf $ (undefined :: CInt) in peekArray s33 (plusPtr _p 472)+ v34 <- peekByteOff _p 480+ v35 <- let s35 = div 8 $ sizeOf $ (undefined :: CInt) in peekArray s35 (plusPtr _p 484)+ v36 <- let s36 = div 12 $ sizeOf $ (undefined :: CInt) in peekArray s36 (plusPtr _p 492)+ v37 <- let s37 = div 8 $ sizeOf $ (undefined :: CInt) in peekArray s37 (plusPtr _p 504)+ v38 <- let s38 = div 12 $ sizeOf $ (undefined :: CInt) in peekArray s38 (plusPtr _p 512)+ v39 <- peekByteOff _p 524+ v40 <- let s40 = div 8 $ sizeOf $ (undefined :: CInt) in peekArray s40 (plusPtr _p 528)+ v41 <- peekByteOff _p 536+ v42 <- peekByteOff _p 544+ v43 <- peekByteOff _p 548+ v44 <- peekByteOff _p 552+ v45 <- peekByteOff _p 556+ v46 <- peekByteOff _p 560+ v47 <- peekByteOff _p 564+ v48 <- peekByteOff _p 568+ v49 <- peekByteOff _p 572+ v50 <- peekByteOff _p 576+ v51 <- peekByteOff _p 580+ v52 <- peekByteOff _p 584+ v53 <- peekByteOff _p 588+ v54 <- peekByteOff _p 592+ v55 <- peekByteOff _p 596+ v56 <- peekByteOff _p 600+ v57 <- peekByteOff _p 608+ v58 <- peekByteOff _p 616+ v59 <- peekByteOff _p 620+ v60 <- peekByteOff _p 624+ v61 <- peekByteOff _p 628+ v62 <- peekByteOff _p 632+ v63 <- peekByteOff _p 636+ v64 <- peekByteOff _p 640+ v65 <- peekByteOff _p 644+ v66 <- peekByteOff _p 648+ v67 <- peekByteOff _p 652+ v68 <- peekByteOff _p 656+ return $ C'cudaDeviceProp v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16 v17 v18 v19 v20 v21 v22 v23 v24 v25 v26 v27 v28 v29 v30 v31 v32 v33 v34 v35 v36 v37 v38 v39 v40 v41 v42 v43 v44 v45 v46 v47 v48 v49 v50 v51 v52 v53 v54 v55 v56 v57 v58 v59 v60 v61 v62 v63 v64 v65 v66 v67 v68+ poke _p (C'cudaDeviceProp v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16 v17 v18 v19 v20 v21 v22 v23 v24 v25 v26 v27 v28 v29 v30 v31 v32 v33 v34 v35 v36 v37 v38 v39 v40 v41 v42 v43 v44 v45 v46 v47 v48 v49 v50 v51 v52 v53 v54 v55 v56 v57 v58 v59 v60 v61 v62 v63 v64 v65 v66 v67 v68) = do+ let s0 = div 256 $ sizeOf $ (undefined :: CChar)+ pokeArray (plusPtr _p 0) (take s0 v0)+ pokeByteOff _p 256 v1+ pokeByteOff _p 264 v2+ pokeByteOff _p 272 v3+ pokeByteOff _p 276 v4+ pokeByteOff _p 280 v5+ pokeByteOff _p 288 v6+ let s7 = div 12 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 292) (take s7 v7)+ let s8 = div 12 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 304) (take s8 v8)+ pokeByteOff _p 316 v9+ pokeByteOff _p 320 v10+ pokeByteOff _p 328 v11+ pokeByteOff _p 332 v12+ pokeByteOff _p 336 v13+ pokeByteOff _p 344 v14+ pokeByteOff _p 352 v15+ pokeByteOff _p 356 v16+ pokeByteOff _p 360 v17+ pokeByteOff _p 364 v18+ pokeByteOff _p 368 v19+ pokeByteOff _p 372 v20+ pokeByteOff _p 376 v21+ pokeByteOff _p 380 v22+ pokeByteOff _p 384 v23+ let s24 = div 8 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 388) (take s24 v24)+ let s25 = div 8 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 396) (take s25 v25)+ let s26 = div 12 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 404) (take s26 v26)+ let s27 = div 8 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 416) (take s27 v27)+ let s28 = div 12 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 424) (take s28 v28)+ let s29 = div 12 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 436) (take s29 v29)+ pokeByteOff _p 448 v30+ let s31 = div 8 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 452) (take s31 v31)+ let s32 = div 12 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 460) (take s32 v32)+ let s33 = div 8 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 472) (take s33 v33)+ pokeByteOff _p 480 v34+ let s35 = div 8 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 484) (take s35 v35)+ let s36 = div 12 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 492) (take s36 v36)+ let s37 = div 8 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 504) (take s37 v37)+ let s38 = div 12 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 512) (take s38 v38)+ pokeByteOff _p 524 v39+ let s40 = div 8 $ sizeOf $ (undefined :: CInt)+ pokeArray (plusPtr _p 528) (take s40 v40)+ pokeByteOff _p 536 v41+ pokeByteOff _p 544 v42+ pokeByteOff _p 548 v43+ pokeByteOff _p 552 v44+ pokeByteOff _p 556 v45+ pokeByteOff _p 560 v46+ pokeByteOff _p 564 v47+ pokeByteOff _p 568 v48+ pokeByteOff _p 572 v49+ pokeByteOff _p 576 v50+ pokeByteOff _p 580 v51+ pokeByteOff _p 584 v52+ pokeByteOff _p 588 v53+ pokeByteOff _p 592 v54+ pokeByteOff _p 596 v55+ pokeByteOff _p 600 v56+ pokeByteOff _p 608 v57+ pokeByteOff _p 616 v58+ pokeByteOff _p 620 v59+ pokeByteOff _p 624 v60+ pokeByteOff _p 628 v61+ pokeByteOff _p 632 v62+ pokeByteOff _p 636 v63+ pokeByteOff _p 640 v64+ pokeByteOff _p 644 v65+ pokeByteOff _p 648 v66+ pokeByteOff _p 652 v67+ pokeByteOff _p 656 v68+ return ()+++{- typedef enum cudaError_t {+ cudaSuccess = 0,+ cudaErrorMissingConfiguration = 1,+ cudaErrorMemoryAllocation = 2,+ cudaErrorInitializationError = 3,+ cudaErrorLaunchFailure = 4,+ cudaErrorPriorLaunchFailure = 5,+ cudaErrorLaunchTimeout = 6,+ cudaErrorLaunchOutOfResources = 7,+ cudaErrorInvalidDeviceFunction = 8,+ cudaErrorInvalidConfiguration = 9,+ cudaErrorInvalidDevice = 10,+ cudaErrorInvalidValue = 11,+ cudaErrorInvalidPitchValue = 12,+ cudaErrorInvalidSymbol = 13,+ cudaErrorMapBufferObjectFailed = 14,+ cudaErrorUnmapBufferObjectFailed = 15,+ cudaErrorInvalidHostPointer = 16,+ cudaErrorInvalidDevicePointer = 17,+ cudaErrorInvalidTexture = 18,+ cudaErrorInvalidTextureBinding = 19,+ cudaErrorInvalidChannelDescriptor = 20,+ cudaErrorInvalidMemcpyDirection = 21,+ cudaErrorAddressOfConstant = 22,+ cudaErrorTextureFetchFailed = 23,+ cudaErrorTextureNotBound = 24,+ cudaErrorSynchronizationError = 25,+ cudaErrorInvalidFilterSetting = 26,+ cudaErrorInvalidNormSetting = 27,+ cudaErrorMixedDeviceExecution = 28,+ cudaErrorCudartUnloading = 29,+ cudaErrorUnknown = 30,+ cudaErrorNotYetImplemented = 31,+ cudaErrorMemoryValueTooLarge = 32,+ cudaErrorInvalidResourceHandle = 33,+ cudaErrorNotReady = 34,+ cudaErrorInsufficientDriver = 35,+ cudaErrorSetOnActiveProcess = 36,+ cudaErrorInvalidSurface = 37,+ cudaErrorNoDevice = 38,+ cudaErrorECCUncorrectable = 39,+ cudaErrorSharedObjectSymbolNotFound = 40,+ cudaErrorSharedObjectInitFailed = 41,+ cudaErrorUnsupportedLimit = 42,+ cudaErrorDuplicateVariableName = 43,+ cudaErrorDuplicateTextureName = 44,+ cudaErrorDuplicateSurfaceName = 45,+ cudaErrorDevicesUnavailable = 46,+ cudaErrorInvalidKernelImage = 47,+ cudaErrorNoKernelImageForDevice = 48,+ cudaErrorIncompatibleDriverContext = 49,+ cudaErrorPeerAccessAlreadyEnabled = 50,+ cudaErrorPeerAccessNotEnabled = 51,+ cudaErrorDeviceAlreadyInUse = 54,+ cudaErrorProfilerDisabled = 55,+ cudaErrorProfilerNotInitialized = 56,+ cudaErrorProfilerAlreadyStarted = 57,+ cudaErrorProfilerAlreadyStopped = 58,+ cudaErrorAssert = 59,+ cudaErrorTooManyPeers = 60,+ cudaErrorHostMemoryAlreadyRegistered = 61,+ cudaErrorHostMemoryNotRegistered = 62,+ cudaErrorOperatingSystem = 63,+ cudaErrorPeerAccessUnsupported = 64,+ cudaErrorLaunchMaxDepthExceeded = 65,+ cudaErrorLaunchFileScopedTex = 66,+ cudaErrorLaunchFileScopedSurf = 67,+ cudaErrorSyncDepthExceeded = 68,+ cudaErrorLaunchPendingCountExceeded = 69,+ cudaErrorNotPermitted = 70,+ cudaErrorNotSupported = 71,+ cudaErrorHardwareStackError = 72,+ cudaErrorIllegalInstruction = 73,+ cudaErrorMisalignedAddress = 74,+ cudaErrorInvalidAddressSpace = 75,+ cudaErrorInvalidPc = 76,+ cudaErrorIllegalAddress = 77,+ cudaErrorInvalidPtx = 78,+ cudaErrorInvalidGraphicsContext = 79,+ cudaErrorNvlinkUncorrectable = 80,+ cudaErrorJitCompilerNotFound = 81,+ cudaErrorCooperativeLaunchTooLarge = 82,+ cudaErrorStartupFailure = 0x7f,+ cudaErrorApiFailureBase = 10000+ } cudaError_t; -}+type C'cudaError_t = CUInt++c'cudaSuccess = 0+c'cudaSuccess :: (Num a) => a++c'cudaErrorMissingConfiguration = 1+c'cudaErrorMissingConfiguration :: (Num a) => a++c'cudaErrorMemoryAllocation = 2+c'cudaErrorMemoryAllocation :: (Num a) => a++c'cudaErrorInitializationError = 3+c'cudaErrorInitializationError :: (Num a) => a++c'cudaErrorLaunchFailure = 4+c'cudaErrorLaunchFailure :: (Num a) => a++c'cudaErrorPriorLaunchFailure = 5+c'cudaErrorPriorLaunchFailure :: (Num a) => a++c'cudaErrorLaunchTimeout = 6+c'cudaErrorLaunchTimeout :: (Num a) => a++c'cudaErrorLaunchOutOfResources = 7+c'cudaErrorLaunchOutOfResources :: (Num a) => a++c'cudaErrorInvalidDeviceFunction = 8+c'cudaErrorInvalidDeviceFunction :: (Num a) => a++c'cudaErrorInvalidConfiguration = 9+c'cudaErrorInvalidConfiguration :: (Num a) => a++c'cudaErrorInvalidDevice = 10+c'cudaErrorInvalidDevice :: (Num a) => a++c'cudaErrorInvalidValue = 11+c'cudaErrorInvalidValue :: (Num a) => a++c'cudaErrorInvalidPitchValue = 12+c'cudaErrorInvalidPitchValue :: (Num a) => a++c'cudaErrorInvalidSymbol = 13+c'cudaErrorInvalidSymbol :: (Num a) => a++c'cudaErrorMapBufferObjectFailed = 14+c'cudaErrorMapBufferObjectFailed :: (Num a) => a++c'cudaErrorUnmapBufferObjectFailed = 15+c'cudaErrorUnmapBufferObjectFailed :: (Num a) => a++c'cudaErrorInvalidHostPointer = 16+c'cudaErrorInvalidHostPointer :: (Num a) => a++c'cudaErrorInvalidDevicePointer = 17+c'cudaErrorInvalidDevicePointer :: (Num a) => a++c'cudaErrorInvalidTexture = 18+c'cudaErrorInvalidTexture :: (Num a) => a++c'cudaErrorInvalidTextureBinding = 19+c'cudaErrorInvalidTextureBinding :: (Num a) => a++c'cudaErrorInvalidChannelDescriptor = 20+c'cudaErrorInvalidChannelDescriptor :: (Num a) => a++c'cudaErrorInvalidMemcpyDirection = 21+c'cudaErrorInvalidMemcpyDirection :: (Num a) => a++c'cudaErrorAddressOfConstant = 22+c'cudaErrorAddressOfConstant :: (Num a) => a++c'cudaErrorTextureFetchFailed = 23+c'cudaErrorTextureFetchFailed :: (Num a) => a++c'cudaErrorTextureNotBound = 24+c'cudaErrorTextureNotBound :: (Num a) => a++c'cudaErrorSynchronizationError = 25+c'cudaErrorSynchronizationError :: (Num a) => a++c'cudaErrorInvalidFilterSetting = 26+c'cudaErrorInvalidFilterSetting :: (Num a) => a++c'cudaErrorInvalidNormSetting = 27+c'cudaErrorInvalidNormSetting :: (Num a) => a++c'cudaErrorMixedDeviceExecution = 28+c'cudaErrorMixedDeviceExecution :: (Num a) => a++c'cudaErrorCudartUnloading = 29+c'cudaErrorCudartUnloading :: (Num a) => a++c'cudaErrorUnknown = 30+c'cudaErrorUnknown :: (Num a) => a++c'cudaErrorNotYetImplemented = 31+c'cudaErrorNotYetImplemented :: (Num a) => a++c'cudaErrorMemoryValueTooLarge = 32+c'cudaErrorMemoryValueTooLarge :: (Num a) => a++c'cudaErrorInvalidResourceHandle = 33+c'cudaErrorInvalidResourceHandle :: (Num a) => a++c'cudaErrorNotReady = 34+c'cudaErrorNotReady :: (Num a) => a++c'cudaErrorInsufficientDriver = 35+c'cudaErrorInsufficientDriver :: (Num a) => a++c'cudaErrorSetOnActiveProcess = 36+c'cudaErrorSetOnActiveProcess :: (Num a) => a++c'cudaErrorInvalidSurface = 37+c'cudaErrorInvalidSurface :: (Num a) => a++c'cudaErrorNoDevice = 38+c'cudaErrorNoDevice :: (Num a) => a++c'cudaErrorECCUncorrectable = 39+c'cudaErrorECCUncorrectable :: (Num a) => a++c'cudaErrorSharedObjectSymbolNotFound = 40+c'cudaErrorSharedObjectSymbolNotFound :: (Num a) => a++c'cudaErrorSharedObjectInitFailed = 41+c'cudaErrorSharedObjectInitFailed :: (Num a) => a++c'cudaErrorUnsupportedLimit = 42+c'cudaErrorUnsupportedLimit :: (Num a) => a++c'cudaErrorDuplicateVariableName = 43+c'cudaErrorDuplicateVariableName :: (Num a) => a++c'cudaErrorDuplicateTextureName = 44+c'cudaErrorDuplicateTextureName :: (Num a) => a++c'cudaErrorDuplicateSurfaceName = 45+c'cudaErrorDuplicateSurfaceName :: (Num a) => a++c'cudaErrorDevicesUnavailable = 46+c'cudaErrorDevicesUnavailable :: (Num a) => a++c'cudaErrorInvalidKernelImage = 47+c'cudaErrorInvalidKernelImage :: (Num a) => a++c'cudaErrorNoKernelImageForDevice = 48+c'cudaErrorNoKernelImageForDevice :: (Num a) => a++c'cudaErrorIncompatibleDriverContext = 49+c'cudaErrorIncompatibleDriverContext :: (Num a) => a++c'cudaErrorPeerAccessAlreadyEnabled = 50+c'cudaErrorPeerAccessAlreadyEnabled :: (Num a) => a++c'cudaErrorPeerAccessNotEnabled = 51+c'cudaErrorPeerAccessNotEnabled :: (Num a) => a++c'cudaErrorDeviceAlreadyInUse = 54+c'cudaErrorDeviceAlreadyInUse :: (Num a) => a++c'cudaErrorProfilerDisabled = 55+c'cudaErrorProfilerDisabled :: (Num a) => a++c'cudaErrorProfilerNotInitialized = 56+c'cudaErrorProfilerNotInitialized :: (Num a) => a++c'cudaErrorProfilerAlreadyStarted = 57+c'cudaErrorProfilerAlreadyStarted :: (Num a) => a++c'cudaErrorProfilerAlreadyStopped = 58+c'cudaErrorProfilerAlreadyStopped :: (Num a) => a++c'cudaErrorAssert = 59+c'cudaErrorAssert :: (Num a) => a++c'cudaErrorTooManyPeers = 60+c'cudaErrorTooManyPeers :: (Num a) => a++c'cudaErrorHostMemoryAlreadyRegistered = 61+c'cudaErrorHostMemoryAlreadyRegistered :: (Num a) => a++c'cudaErrorHostMemoryNotRegistered = 62+c'cudaErrorHostMemoryNotRegistered :: (Num a) => a++c'cudaErrorOperatingSystem = 63+c'cudaErrorOperatingSystem :: (Num a) => a++c'cudaErrorPeerAccessUnsupported = 64+c'cudaErrorPeerAccessUnsupported :: (Num a) => a++c'cudaErrorLaunchMaxDepthExceeded = 65+c'cudaErrorLaunchMaxDepthExceeded :: (Num a) => a++c'cudaErrorLaunchFileScopedTex = 66+c'cudaErrorLaunchFileScopedTex :: (Num a) => a++c'cudaErrorLaunchFileScopedSurf = 67+c'cudaErrorLaunchFileScopedSurf :: (Num a) => a++c'cudaErrorSyncDepthExceeded = 68+c'cudaErrorSyncDepthExceeded :: (Num a) => a++c'cudaErrorLaunchPendingCountExceeded = 69+c'cudaErrorLaunchPendingCountExceeded :: (Num a) => a++c'cudaErrorNotPermitted = 70+c'cudaErrorNotPermitted :: (Num a) => a++c'cudaErrorNotSupported = 71+c'cudaErrorNotSupported :: (Num a) => a++c'cudaErrorHardwareStackError = 72+c'cudaErrorHardwareStackError :: (Num a) => a++c'cudaErrorIllegalInstruction = 73+c'cudaErrorIllegalInstruction :: (Num a) => a++c'cudaErrorMisalignedAddress = 74+c'cudaErrorMisalignedAddress :: (Num a) => a++c'cudaErrorInvalidAddressSpace = 75+c'cudaErrorInvalidAddressSpace :: (Num a) => a++c'cudaErrorInvalidPc = 76+c'cudaErrorInvalidPc :: (Num a) => a++c'cudaErrorIllegalAddress = 77+c'cudaErrorIllegalAddress :: (Num a) => a++c'cudaErrorInvalidPtx = 78+c'cudaErrorInvalidPtx :: (Num a) => a++c'cudaErrorInvalidGraphicsContext = 79+c'cudaErrorInvalidGraphicsContext :: (Num a) => a++c'cudaErrorNvlinkUncorrectable = 80+c'cudaErrorNvlinkUncorrectable :: (Num a) => a++c'cudaErrorJitCompilerNotFound = 81+c'cudaErrorJitCompilerNotFound :: (Num a) => a++c'cudaErrorCooperativeLaunchTooLarge = 82+c'cudaErrorCooperativeLaunchTooLarge :: (Num a) => a++c'cudaErrorStartupFailure = 127+c'cudaErrorStartupFailure :: (Num a) => a++c'cudaErrorApiFailureBase = 10000+c'cudaErrorApiFailureBase :: (Num a) => a++
+ src/Torch/Types/THC.hs view
@@ -0,0 +1,212 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-}+module Torch.Types.THC+ ( module Torch.Types.THC.Structs++ , CState, State(..), asState+ , CAllocator, Allocator(..)+ , CDescBuff, DescBuff, descBuff+ , CGenerator, Generator(..), generatorToRng++ -- for nn-packages+ , CNNState+ , CDim+ , CNNGenerator++ , CInt'+ , CMaskTensor, CIndexTensor, CIndexStorage, C'THCIndexTensor+ , MaskDynamic, IndexDynamic, MaskTensor, IndexTensor, IndexStorage++ , CByteTensor, ByteDynamic(..), byteDynamic, ByteTensor(..), byteAsStatic+ , CByteStorage, ByteStorage(..), byteStorage++ , CCharTensor, CharDynamic(..), charDynamic, CharTensor(..), charAsStatic+ , CCharStorage, CharStorage(..), charStorage++ , CLongTensor, LongDynamic(..), longDynamic, LongTensor(..), longAsStatic+ , CLongStorage, LongStorage(..), longStorage++ , CShortTensor, ShortDynamic(..), shortDynamic, ShortTensor(..), shortAsStatic+ , CShortStorage, ShortStorage(..), shortStorage++ , CIntTensor, IntDynamic(..), intDynamic, IntTensor(..), intAsStatic+ , CIntStorage, IntStorage(..), intStorage++ , CFloatTensor, FloatDynamic(..), floatDynamic, FloatTensor(..), floatAsStatic+ , CFloatStorage, FloatStorage(..), floatStorage++ , CDoubleTensor, DoubleDynamic(..), doubleDynamic, DoubleTensor(..), doubleAsStatic+ , CDoubleStorage, DoubleStorage(..), doubleStorage++ , C'THCHalfStorage, C'THCudaHalfTensor, C'THCFile, C'THCHalf+ ) where++import Foreign+import Foreign.C.Types+import GHC.TypeLits+import Data.Char (chr)++import Torch.Types.THC.Structs++-- nn-package+type CNNState = C'THCState+type CDim = CInt+type CNNGenerator = ()++type CAllocator = ()+type Allocator = ()++type CDescBuff = C'THCDescBuff+type DescBuff = String+descBuff :: Ptr CDescBuff -> IO DescBuff+descBuff p = (map (chr . fromIntegral) . c'THCDescBuff'str) <$> peek p++type CState = C'THCState+newtype State = State { asForeign :: ForeignPtr CState }+ deriving (Eq)+asState = State++type CGenerator = C'_Generator+newtype Generator = Generator { rng :: ForeignPtr CGenerator }+ deriving (Eq, Show)++generatorToRng :: ForeignPtr CGenerator -> Generator+generatorToRng = Generator++type CInt' = CLLong+type Int' = Integer++-- Some type alias'+type C'THCIndexTensor = CLongTensor+type CMaskTensor = CByteTensor+type CIndexTensor = CLongTensor+type CIndexStorage = CLongStorage++type MaskDynamic = ByteDynamic+type MaskTensor = ByteTensor+type IndexDynamic = LongDynamic+type IndexTensor = LongTensor+type IndexStorage = LongStorage++-- unsigned types++type CByteTensor = C'THCudaByteTensor+newtype ByteDynamic = ByteDynamic { byteDynamicState :: (ForeignPtr CState, ForeignPtr CByteTensor) }+ deriving (Eq)+byteDynamic = curry ByteDynamic++newtype ByteTensor (ds :: [Nat]) = ByteTensor { byteAsDynamic :: ByteDynamic }+ deriving (Eq)+byteAsStatic = ByteTensor++type CByteStorage = C'THCByteStorage+newtype ByteStorage = ByteStorage { byteStorageState :: (ForeignPtr CState, ForeignPtr CByteStorage) }+ deriving (Eq)+byteStorage = curry ByteStorage++type CCharTensor = C'THCudaCharTensor+newtype CharDynamic = CharDynamic { charDynamicState :: (ForeignPtr CState, ForeignPtr CCharTensor) }+ deriving (Eq)+charDynamic = curry CharDynamic++newtype CharTensor (ds :: [Nat]) = CharTensor { charAsDynamic :: CharDynamic }+ deriving (Eq)+charAsStatic = CharTensor++type CCharStorage = C'THCCharStorage+newtype CharStorage = CharStorage { charStorageState :: (ForeignPtr CState, ForeignPtr CCharStorage) }+ deriving (Eq)+charStorage = curry CharStorage++-- Signed types++type CLongTensor = C'THCudaLongTensor+newtype LongDynamic = LongDynamic { longDynamicState :: (ForeignPtr CState, ForeignPtr CLongTensor) }+ deriving (Eq)+longDynamic = curry LongDynamic++newtype LongTensor (ds :: [Nat]) = LongTensor { longAsDynamic :: LongDynamic }+ deriving (Eq)+longAsStatic = LongTensor++type CLongStorage = C'THCLongStorage+newtype LongStorage = LongStorage { longStorageState :: (ForeignPtr CState, ForeignPtr CLongStorage) }+ deriving (Eq)+longStorage = curry LongStorage++type CShortTensor = C'THCudaShortTensor+newtype ShortDynamic = ShortDynamic { shortDynamicState :: (ForeignPtr CState, ForeignPtr CShortTensor) }+ deriving (Eq)+shortDynamic = curry ShortDynamic++newtype ShortTensor (ds :: [Nat]) = ShortTensor { shortAsDynamic :: ShortDynamic }+ deriving (Eq)+shortAsStatic = ShortTensor++type CShortStorage = C'THCShortStorage+newtype ShortStorage = ShortStorage { shortStorageState :: (ForeignPtr CState, ForeignPtr CShortStorage) }+ deriving (Eq)+shortStorage = curry ShortStorage++type CIntTensor = C'THCudaIntTensor+newtype IntDynamic = IntDynamic { intDynamicState :: (ForeignPtr CState, ForeignPtr CIntTensor) }+ deriving (Eq)+intDynamic = curry IntDynamic++newtype IntTensor (ds :: [Nat]) = IntTensor { intAsDynamic :: IntDynamic }+ deriving (Eq)+intAsStatic = IntTensor++type CIntStorage = C'THCIntStorage+newtype IntStorage = IntStorage { intStorageState :: (ForeignPtr CState, ForeignPtr CIntStorage) }+ deriving (Eq)+intStorage = curry IntStorage++-- Floating types++type CFloatTensor = C'THCudaFloatTensor+newtype FloatDynamic = FloatDynamic { floatDynamicState :: (ForeignPtr CState, ForeignPtr CFloatTensor) }+ deriving (Eq)+floatDynamic = curry FloatDynamic++newtype FloatTensor (ds :: [Nat]) = FloatTensor { floatAsDynamic :: FloatDynamic }+ deriving (Eq)+floatAsStatic = FloatTensor++type CFloatStorage = C'THCFloatStorage+newtype FloatStorage = FloatStorage { floatStorageState :: (ForeignPtr CState, ForeignPtr CFloatStorage) }+ deriving (Eq)+floatStorage = curry FloatStorage++type CDoubleTensor = C'THCudaDoubleTensor+newtype DoubleDynamic = DoubleDynamic { doubleDynamicState :: (ForeignPtr CState, ForeignPtr CDoubleTensor) }+ deriving (Eq)+doubleDynamic = curry DoubleDynamic++newtype DoubleTensor (ds :: [Nat]) = DoubleTensor { doubleAsDynamic :: DoubleDynamic }+ deriving (Eq)+doubleAsStatic = DoubleTensor++type CDoubleStorage = C'THCDoubleStorage+newtype DoubleStorage = DoubleStorage { doubleStorageState :: (ForeignPtr CState, ForeignPtr CDoubleStorage) }+ deriving (Eq)+doubleStorage = curry DoubleStorage++{-+data CHalfTensor+data HalfDynTensor+halfCTensor :: HalfDynTensor -> ForeignPtr CHalfTensor+halfDynTensor :: ForeignPtr CHalfTensor -> HalfDynTensor++data CHalfStorage+data HalfStorage+halfCStorage :: HalfStorage -> ForeignPtr CHalfStorage+halfStorage :: ForeignPtr CHalfStorage -> HalfStorage+-}++type C'THCudaHalfTensor = ()+type C'THCHalfStorage = ()+type C'THCFile = ()+type C'THCHalf = Ptr ()++
+ src/Torch/Types/THC/Byte.hs view
@@ -0,0 +1,58 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-}+module Torch.Types.THC.Byte where++import Foreign+import Foreign.C.Types+import GHC.TypeLits (Nat)+import GHC.Word+import Torch.Types.TH (C'THLongStorage, C'THLongTensor)+import Torch.Types.THC+import qualified Torch.Types.THC.Long as Long++type CStorage = CByteStorage+type CTensor = CByteTensor++type CReal = CUChar+type CAccReal = CLong+type HsReal = Word8+type HsAccReal = Word64++real2acc :: HsReal -> HsAccReal+real2acc = fromIntegral++acc2real :: HsAccReal -> HsReal+acc2real = fromIntegral++hs2cReal :: HsReal -> CReal+hs2cReal = fromIntegral++hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = fromIntegral++c2hsReal :: CReal -> HsReal+c2hsReal = fromIntegral++c2hsAccReal :: CAccReal -> HsAccReal+c2hsAccReal = fromIntegral++i2hsReal :: Integral i => i -> HsReal+i2hsReal = fromIntegral++type Storage = ByteStorage+cstorage = snd . byteStorageState+storage = byteStorage+storageState = byteStorageState+storageStateRef = fst . byteStorageState++type Dynamic = ByteDynamic+ctensor = snd . byteDynamicState+dynamic = byteDynamic+dynamicState = byteDynamicState+dynamicStateRef = fst . byteDynamicState++type Tensor = ByteTensor+asDynamic = byteAsDynamic+asStatic = byteAsStatic++-- instance Fractional Word8
+ src/Torch/Types/THC/Char.hs view
@@ -0,0 +1,57 @@+module Torch.Types.THC.Char where++import Foreign.C.Types+import Foreign+import GHC.TypeLits (Nat)+import GHC.Word+import GHC.Int+import Torch.Types.TH (C'THLongStorage, C'THLongTensor)+import Torch.Types.THC++type CTensor = CCharTensor+type CStorage = CCharStorage++type CReal = CChar+type CUReal = CUChar+type CAccReal = CLong+type HsReal = Int8+type HsUReal = Word8+type HsAccReal = Int64++real2acc :: HsReal -> HsAccReal+real2acc = fromIntegral++acc2real :: HsAccReal -> HsReal+acc2real = fromIntegral++hs2cReal :: HsReal -> CReal+hs2cReal = fromIntegral++hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = fromIntegral++c2hsReal :: CReal -> HsReal+c2hsReal = fromIntegral++c2hsAccReal :: CAccReal -> HsAccReal+c2hsAccReal = fromIntegral++type Storage = CharStorage+cstorage = snd . charStorageState+storage = curry CharStorage+storageState = charStorageState+storageStateRef = fst . charStorageState++type Dynamic = CharDynamic+ctensor = snd . charDynamicState+dynamic = curry CharDynamic+dynamicState = charDynamicState+dynamicStateRef = fst . charDynamicState++type Tensor = CharTensor+asDynamic = charAsDynamic+asStatic = charAsStatic++-- instance Fractional Int8++
+ src/Torch/Types/THC/Double.hs view
@@ -0,0 +1,53 @@+module Torch.Types.THC.Double where++import Foreign.C.Types+import Foreign (ForeignPtr)+import GHC.TypeLits (Nat)+import Torch.Types.THC++type CTensor = C'THCudaDoubleTensor+type CStorage = C'THCDoubleStorage++-- TENSOR-LAPACK ONLY+-- type CIntTensor = C'THCudaIntTensor++type CReal = CDouble+type CAccReal = CDouble+type HsReal = Double+type HsAccReal = Double++real2acc :: HsReal -> HsAccReal+real2acc = id++acc2real :: HsAccReal -> HsReal+acc2real = id++hs2cReal :: HsReal -> CReal+hs2cReal = realToFrac++hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = realToFrac++c2hsReal :: CReal -> HsReal+c2hsReal = realToFrac++c2hsAccReal :: CAccReal -> HsAccReal+c2hsAccReal = realToFrac++type Storage = DoubleStorage+cstorage = snd . doubleStorageState+storage = doubleStorage+storageState = doubleStorageState+storageStateRef = fst . doubleStorageState++type Dynamic = DoubleDynamic+ctensor = snd . doubleDynamicState+dynamic = doubleDynamic+dynamicState = doubleDynamicState+dynamicStateRef = fst . doubleDynamicState++type Tensor = DoubleTensor+asDynamic = doubleAsDynamic+asStatic = doubleAsStatic++
+ src/Torch/Types/THC/Float.hs view
@@ -0,0 +1,44 @@+module Torch.Types.THC.Float where++import Foreign.C.Types+import Foreign+import GHC.TypeLits (Nat)+import Torch.Types.THC++type CTensor = CFloatTensor+type CStorage = CFloatStorage++type CReal = CFloat+type CAccReal = CDouble+type HsReal = Float+type HsAccReal = Double++hs2cReal :: HsReal -> CReal+hs2cReal = realToFrac++hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = realToFrac++c2hsReal :: CReal -> HsReal+c2hsReal = realToFrac++c2hsAccReal :: CAccReal -> HsAccReal+c2hsAccReal = realToFrac++type Storage = FloatStorage+cstorage = snd . floatStorageState+storage = floatStorage+storageState = floatStorageState+storageStateRef = fst . floatStorageState++type Dynamic = FloatDynamic+ctensor = snd . floatDynamicState+dynamic = floatDynamic+dynamicState = floatDynamicState+dynamicStateRef = fst . floatDynamicState++type Tensor = FloatTensor+asDynamic = floatAsDynamic+asStatic = floatAsStatic++
+ src/Torch/Types/THC/Int.hs view
@@ -0,0 +1,53 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-}+module Torch.Types.THC.Int where++import Foreign.C.Types+import Foreign+import GHC.TypeLits (Nat)+import GHC.Int+import Torch.Types.THC++type CTensor = CIntTensor+type CStorage = CIntStorage++type CReal = CInt+type CAccReal = CLong+type HsReal = Int32+type HsAccReal = Int64++real2acc :: HsReal -> HsAccReal+real2acc = fromIntegral++acc2real :: HsAccReal -> HsReal+acc2real = fromIntegral++hs2cReal :: HsReal -> CReal+hs2cReal = fromIntegral++hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = fromIntegral++c2hsReal :: CReal -> HsReal+c2hsReal = fromIntegral++c2hsAccReal :: CAccReal -> HsAccReal+c2hsAccReal = fromIntegral++type Storage = IntStorage+cstorage = snd . intStorageState+storage = intStorage+storageState = intStorageState+storageStateRef = fst . intStorageState++type Dynamic = IntDynamic+ctensor = snd . intDynamicState+dynamic = intDynamic+dynamicState = intDynamicState+dynamicStateRef = fst . intDynamicState++type Tensor = IntTensor+asDynamic = intAsDynamic+asStatic = intAsStatic++-- instance Fractional Int32
+ src/Torch/Types/THC/Internal.hs view
@@ -0,0 +1,41 @@+-------------------------------------------------------------------------------+-- |+-- Module : Torch.Types.THC.Internal+-- Copyright : (c) Hasktorch dev team 2017+-- License : BSD3+-- Maintainer: sam@stites.io+-- Stability : experimental+-- Portability: non-portable+--+-- Any manual work which has to be ammended to Torch.Types.THC.Structs after+-- running c2hsc.+-------------------------------------------------------------------------------+{-# LANGUAGE ConstraintKinds #-}+module Torch.Types.THC.Internal+ ( module X+ , C'THAllocator(..)+ , C'cudaStream_t, c'cudaStream_t+ , C'cusparseHandle_t, c'cusparseHandle_t+ , C'cublasHandle_t, c'cublasHandle_t+ , C'cusparseContext, c'cusparseContext+ ) where++import Foreign.Ptr++import Torch.Types.Cuda.Structs as X+import Torch.Types.CuRand.Structs as X+import Torch.Types.TH.Structs (C'THAllocator(..))++type C'cudaStream_t = Ptr ()+c'cudaStream_t = nullPtr++type C'cusparseHandle_t = Ptr ()+c'cusparseHandle_t = nullPtr++type C'cublasHandle_t = Ptr ()+c'cublasHandle_t = nullPtr++type C'cusparseContext = Ptr ()+c'cusparseContext = nullPtr++
+ src/Torch/Types/THC/Long.hs view
@@ -0,0 +1,52 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-}+module Torch.Types.THC.Long where++import Foreign.C.Types+import Foreign+import GHC.TypeLits (Nat)+import Torch.Types.THC++type CTensor = C'THCudaLongTensor+type CStorage = C'THCLongStorage++type CReal = CLong+type CAccReal = CLong+type HsReal = Integer+type HsAccReal = Integer++real2acc :: HsReal -> HsAccReal+real2acc = id++acc2real :: HsAccReal -> HsReal+acc2real = id++hs2cReal :: HsReal -> CReal+hs2cReal = fromIntegral++hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = fromIntegral++c2hsReal :: CReal -> HsReal+c2hsReal = fromIntegral++c2hsAccReal :: CAccReal -> HsAccReal+c2hsAccReal = fromIntegral++type Storage = LongStorage+cstorage = snd . longStorageState+storage = longStorage+storageState = longStorageState+storageStateRef = fst . longStorageState++type Dynamic = LongDynamic+ctensor = snd . longDynamicState+dynamic = longDynamic+dynamicState = longDynamicState+dynamicStateRef = fst . longDynamicState++type Tensor = LongTensor+asDynamic = longAsDynamic+asStatic = longAsStatic++-- instance Fractional Integer
+ src/Torch/Types/THC/Short.hs view
@@ -0,0 +1,53 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-}+module Torch.Types.THC.Short where++import Foreign.C.Types+import Foreign+import GHC.TypeLits (Nat)+import GHC.Int+import Torch.Types.THC++type CTensor = C'THCudaShortTensor+type CStorage = C'THCShortStorage++type CReal = CShort+type CAccReal = CLong+type HsReal = Int16+type HsAccReal = Int64++real2acc :: HsReal -> HsAccReal+real2acc = fromIntegral++acc2real :: HsAccReal -> HsReal+acc2real = fromIntegral++hs2cReal :: HsReal -> CReal+hs2cReal = fromIntegral++hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = fromIntegral++c2hsReal :: CReal -> HsReal+c2hsReal = fromIntegral++c2hsAccReal :: CAccReal -> HsAccReal+c2hsAccReal = fromIntegral++type Storage = ShortStorage+cstorage = snd . shortStorageState+storage = shortStorage+storageState = shortStorageState+storageStateRef = fst . shortStorageState++type Dynamic = ShortDynamic+ctensor = snd . shortDynamicState+dynamic = shortDynamic+dynamicState = shortDynamicState+dynamicStateRef = fst . shortDynamicState++type Tensor = ShortTensor+asDynamic = shortAsDynamic+asStatic = shortAsStatic++-- instance Fractional Int16
+ src/Torch/Types/THC/Structs.hs view
@@ -0,0 +1,1321 @@+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+++module Torch.Types.THC.Structs where+import Torch.Types.THC.Internal+import Foreign.Ptr+import Foreign.Ptr (Ptr,FunPtr,plusPtr)+import Foreign.Ptr (wordPtrToPtr,castPtrToFunPtr)+import Foreign.Storable+import Foreign.C.Types+import Foreign.C.String (CString,CStringLen,CWString,CWStringLen)+import Foreign.Marshal.Alloc (alloca)+import Foreign.Marshal.Array (peekArray,pokeArray)+import Data.Int+import Data.Word+++{- typedef struct THCStream {+ cudaStream_t stream; int device; int refcount;+ } THCStream; -}+++++data C'THCStream = C'THCStream{+ c'THCStream'stream :: C'cudaStream_t,+ c'THCStream'device :: CInt,+ c'THCStream'refcount :: CInt+} deriving (Eq,Show)+p'THCStream'stream p = plusPtr p 0+p'THCStream'stream :: Ptr (C'THCStream) -> Ptr (C'cudaStream_t)+p'THCStream'device p = plusPtr p 0+p'THCStream'device :: Ptr (C'THCStream) -> Ptr (CInt)+p'THCStream'refcount p = plusPtr p 4+p'THCStream'refcount :: Ptr (C'THCStream) -> Ptr (CInt)+instance Storable C'THCStream where+ sizeOf _ = 8+ alignment _ = 4+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 0+ v2 <- peekByteOff _p 4+ return $ C'THCStream v0 v1 v2+ poke _p (C'THCStream v0 v1 v2) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 0 v1+ pokeByteOff _p 4 v2+ return ()+++{- typedef struct _Generator {+ struct curandStateMtgp32 * gen_states;+ struct mtgp32_kernel_params * kernel_params;+ int initf;+ unsigned long long initial_seed;+ } Generator; -}++++++data C'_Generator = C'_Generator{+ c'_Generator'gen_states :: Ptr C'curandStateMtgp32,+ c'_Generator'kernel_params :: Ptr C'mtgp32_kernel_params,+ c'_Generator'initf :: CInt,+ c'_Generator'initial_seed :: CULong+} deriving (Eq,Show)+p'_Generator'gen_states p = plusPtr p 0+p'_Generator'gen_states :: Ptr (C'_Generator) -> Ptr (Ptr C'curandStateMtgp32)+p'_Generator'kernel_params p = plusPtr p 8+p'_Generator'kernel_params :: Ptr (C'_Generator) -> Ptr (Ptr C'mtgp32_kernel_params)+p'_Generator'initf p = plusPtr p 16+p'_Generator'initf :: Ptr (C'_Generator) -> Ptr (CInt)+p'_Generator'initial_seed p = plusPtr p 24+p'_Generator'initial_seed :: Ptr (C'_Generator) -> Ptr (CULong)+instance Storable C'_Generator where+ sizeOf _ = 32+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ return $ C'_Generator v0 v1 v2 v3+ poke _p (C'_Generator v0 v1 v2 v3) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ return ()+++{- typedef struct THCRNGState {+ Generator * gen; int num_devices;+ } THCRNGState; -}++++data C'THCRNGState = C'THCRNGState{+ c'THCRNGState'gen :: Ptr C'_Generator,+ c'THCRNGState'num_devices :: CInt+} deriving (Eq,Show)+p'THCRNGState'gen p = plusPtr p 0+p'THCRNGState'gen :: Ptr (C'THCRNGState) -> Ptr (Ptr C'_Generator)+p'THCRNGState'num_devices p = plusPtr p 8+p'THCRNGState'num_devices :: Ptr (C'THCRNGState) -> Ptr (CInt)+instance Storable C'THCRNGState where+ sizeOf _ = 16+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ return $ C'THCRNGState v0 v1+ poke _p (C'THCRNGState v0 v1) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ return ()+++{- typedef struct THCDescBuff {+ char str[64];+ } THCDescBuff; -}+++data C'THCDescBuff = C'THCDescBuff{+ c'THCDescBuff'str :: [CChar]+} deriving (Eq,Show)+p'THCDescBuff'str p = plusPtr p 0+p'THCDescBuff'str :: Ptr (C'THCDescBuff) -> Ptr (CChar)+instance Storable C'THCDescBuff where+ sizeOf _ = 64+ alignment _ = 1+ peek _p = do+ v0 <- let s0 = div 64 $ sizeOf $ (undefined :: CChar) in peekArray s0 (plusPtr _p 0)+ return $ C'THCDescBuff v0+ poke _p (C'THCDescBuff v0) = do+ let s0 = div 64 $ sizeOf $ (undefined :: CChar)+ pokeArray (plusPtr _p 0) (take s0 v0)+ return ()+++{- typedef struct _THCDeviceAllocator {+ cudaError_t (* malloc)(void *, void * *, size_t, cudaStream_t);+ cudaError_t (* realloc)(void *,+ void * *,+ size_t,+ size_t,+ cudaStream_t);+ cudaError_t (* free)(void *, void *);+ cudaError_t (* emptyCache)(void *);+ cudaError_t (* cacheInfo)(void *, int, size_t *, size_t *);+ void * state;+ } THCDeviceAllocator; -}++++++++data C'_THCDeviceAllocator = C'_THCDeviceAllocator{+ c'_THCDeviceAllocator'malloc :: FunPtr (Ptr () -> Ptr (Ptr ()) -> CSize -> C'cudaStream_t -> C'cudaError_t),+ c'_THCDeviceAllocator'realloc :: FunPtr (Ptr () -> Ptr (Ptr ()) -> CSize -> CSize -> C'cudaStream_t -> C'cudaError_t),+ c'_THCDeviceAllocator'free :: FunPtr (Ptr () -> Ptr () -> C'cudaError_t),+ c'_THCDeviceAllocator'emptyCache :: FunPtr (Ptr () -> C'cudaError_t),+ c'_THCDeviceAllocator'cacheInfo :: FunPtr (Ptr () -> CInt -> Ptr CSize -> Ptr CSize -> C'cudaError_t),+ c'_THCDeviceAllocator'state :: Ptr ()+} deriving (Eq,Show)+p'_THCDeviceAllocator'malloc p = plusPtr p 0+p'_THCDeviceAllocator'malloc :: Ptr (C'_THCDeviceAllocator) -> Ptr (FunPtr (Ptr () -> Ptr (Ptr ()) -> CSize -> C'cudaStream_t -> C'cudaError_t))+p'_THCDeviceAllocator'realloc p = plusPtr p 8+p'_THCDeviceAllocator'realloc :: Ptr (C'_THCDeviceAllocator) -> Ptr (FunPtr (Ptr () -> Ptr (Ptr ()) -> CSize -> CSize -> C'cudaStream_t -> C'cudaError_t))+p'_THCDeviceAllocator'free p = plusPtr p 16+p'_THCDeviceAllocator'free :: Ptr (C'_THCDeviceAllocator) -> Ptr (FunPtr (Ptr () -> Ptr () -> C'cudaError_t))+p'_THCDeviceAllocator'emptyCache p = plusPtr p 24+p'_THCDeviceAllocator'emptyCache :: Ptr (C'_THCDeviceAllocator) -> Ptr (FunPtr (Ptr () -> C'cudaError_t))+p'_THCDeviceAllocator'cacheInfo p = plusPtr p 32+p'_THCDeviceAllocator'cacheInfo :: Ptr (C'_THCDeviceAllocator) -> Ptr (FunPtr (Ptr () -> CInt -> Ptr CSize -> Ptr CSize -> C'cudaError_t))+p'_THCDeviceAllocator'state p = plusPtr p 40+p'_THCDeviceAllocator'state :: Ptr (C'_THCDeviceAllocator) -> Ptr (Ptr ())+instance Storable C'_THCDeviceAllocator where+ sizeOf _ = 48+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ v4 <- peekByteOff _p 32+ v5 <- peekByteOff _p 40+ return $ C'_THCDeviceAllocator v0 v1 v2 v3 v4 v5+ poke _p (C'_THCDeviceAllocator v0 v1 v2 v3 v4 v5) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ pokeByteOff _p 32 v4+ pokeByteOff _p 40 v5+ return ()+++{- typedef struct _THCCudaResourcesPerDevice {+ THCStream * * streams;+ int numBlasHandles;+ int numSparseHandles;+ cublasHandle_t * blasHandles;+ cusparseHandle_t * sparseHandles;+ size_t scratchSpacePerStream;+ void * * devScratchSpacePerStream;+ } THCCudaResourcesPerDevice; -}+++++++++data C'_THCCudaResourcesPerDevice = C'_THCCudaResourcesPerDevice{+ c'_THCCudaResourcesPerDevice'streams :: Ptr (Ptr C'THCStream),+ c'_THCCudaResourcesPerDevice'numBlasHandles :: CInt,+ c'_THCCudaResourcesPerDevice'numSparseHandles :: CInt,+ c'_THCCudaResourcesPerDevice'blasHandles :: Ptr C'cublasHandle_t,+ c'_THCCudaResourcesPerDevice'sparseHandles :: Ptr C'cusparseHandle_t,+ c'_THCCudaResourcesPerDevice'scratchSpacePerStream :: CSize,+ c'_THCCudaResourcesPerDevice'devScratchSpacePerStream :: Ptr (Ptr ())+} deriving (Eq,Show)+p'_THCCudaResourcesPerDevice'streams p = plusPtr p 0+p'_THCCudaResourcesPerDevice'streams :: Ptr (C'_THCCudaResourcesPerDevice) -> Ptr (Ptr (Ptr C'THCStream))+p'_THCCudaResourcesPerDevice'numBlasHandles p = plusPtr p 8+p'_THCCudaResourcesPerDevice'numBlasHandles :: Ptr (C'_THCCudaResourcesPerDevice) -> Ptr (CInt)+p'_THCCudaResourcesPerDevice'numSparseHandles p = plusPtr p 12+p'_THCCudaResourcesPerDevice'numSparseHandles :: Ptr (C'_THCCudaResourcesPerDevice) -> Ptr (CInt)+p'_THCCudaResourcesPerDevice'blasHandles p = plusPtr p 16+p'_THCCudaResourcesPerDevice'blasHandles :: Ptr (C'_THCCudaResourcesPerDevice) -> Ptr (Ptr C'cublasHandle_t)+p'_THCCudaResourcesPerDevice'sparseHandles p = plusPtr p 24+p'_THCCudaResourcesPerDevice'sparseHandles :: Ptr (C'_THCCudaResourcesPerDevice) -> Ptr (Ptr C'cusparseHandle_t)+p'_THCCudaResourcesPerDevice'scratchSpacePerStream p = plusPtr p 32+p'_THCCudaResourcesPerDevice'scratchSpacePerStream :: Ptr (C'_THCCudaResourcesPerDevice) -> Ptr (CSize)+p'_THCCudaResourcesPerDevice'devScratchSpacePerStream p = plusPtr p 40+p'_THCCudaResourcesPerDevice'devScratchSpacePerStream :: Ptr (C'_THCCudaResourcesPerDevice) -> Ptr (Ptr (Ptr ()))+instance Storable C'_THCCudaResourcesPerDevice where+ sizeOf _ = 48+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 12+ v3 <- peekByteOff _p 16+ v4 <- peekByteOff _p 24+ v5 <- peekByteOff _p 32+ v6 <- peekByteOff _p 40+ return $ C'_THCCudaResourcesPerDevice v0 v1 v2 v3 v4 v5 v6+ poke _p (C'_THCCudaResourcesPerDevice v0 v1 v2 v3 v4 v5 v6) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 12 v2+ pokeByteOff _p 16 v3+ pokeByteOff _p 24 v4+ pokeByteOff _p 32 v5+ pokeByteOff _p 40 v6+ return ()+++{- typedef struct THCState {+ struct THCRNGState * rngState;+ struct cudaDeviceProp * deviceProperties;+ THCCudaResourcesPerDevice * resourcesPerDevice;+ int numDevices;+ int numUserStreams;+ int numUserBlasHandles;+ int numUserSparseHandles;+ THAllocator * cudaHostAllocator;+ THAllocator * cudaUVAAllocator;+ THCDeviceAllocator * cudaDeviceAllocator;+ int * * p2pAccessEnabled;+ int p2pKernelAccessEnabled;+ void (* cutorchGCFunction)(void * data);+ void * cutorchGCData;+ ptrdiff_t heapSoftmax;+ ptrdiff_t heapDelta;+ } THCState; -}++++++++++++++++++data C'THCState = C'THCState{+ c'THCState'rngState :: Ptr C'THCRNGState,+ c'THCState'deviceProperties :: Ptr C'cudaDeviceProp,+ c'THCState'resourcesPerDevice :: Ptr C'_THCCudaResourcesPerDevice,+ c'THCState'numDevices :: CInt,+ c'THCState'numUserStreams :: CInt,+ c'THCState'numUserBlasHandles :: CInt,+ c'THCState'numUserSparseHandles :: CInt,+ c'THCState'cudaHostAllocator :: Ptr C'THAllocator,+ c'THCState'cudaUVAAllocator :: Ptr C'THAllocator,+ c'THCState'cudaDeviceAllocator :: Ptr C'_THCDeviceAllocator,+ c'THCState'p2pAccessEnabled :: Ptr (Ptr CInt),+ c'THCState'p2pKernelAccessEnabled :: CInt,+ c'THCState'cutorchGCFunction :: FunPtr (Ptr () -> IO ()),+ c'THCState'cutorchGCData :: Ptr (),+ c'THCState'heapSoftmax :: CLong,+ c'THCState'heapDelta :: CLong+} deriving (Eq,Show)+p'THCState'rngState p = plusPtr p 0+p'THCState'rngState :: Ptr (C'THCState) -> Ptr (Ptr C'THCRNGState)+p'THCState'deviceProperties p = plusPtr p 8+p'THCState'deviceProperties :: Ptr (C'THCState) -> Ptr (Ptr C'cudaDeviceProp)+p'THCState'resourcesPerDevice p = plusPtr p 16+p'THCState'resourcesPerDevice :: Ptr (C'THCState) -> Ptr (Ptr C'_THCCudaResourcesPerDevice)+p'THCState'numDevices p = plusPtr p 24+p'THCState'numDevices :: Ptr (C'THCState) -> Ptr (CInt)+p'THCState'numUserStreams p = plusPtr p 28+p'THCState'numUserStreams :: Ptr (C'THCState) -> Ptr (CInt)+p'THCState'numUserBlasHandles p = plusPtr p 32+p'THCState'numUserBlasHandles :: Ptr (C'THCState) -> Ptr (CInt)+p'THCState'numUserSparseHandles p = plusPtr p 36+p'THCState'numUserSparseHandles :: Ptr (C'THCState) -> Ptr (CInt)+p'THCState'cudaHostAllocator p = plusPtr p 40+p'THCState'cudaHostAllocator :: Ptr (C'THCState) -> Ptr (Ptr C'THAllocator)+p'THCState'cudaUVAAllocator p = plusPtr p 48+p'THCState'cudaUVAAllocator :: Ptr (C'THCState) -> Ptr (Ptr C'THAllocator)+p'THCState'cudaDeviceAllocator p = plusPtr p 56+p'THCState'cudaDeviceAllocator :: Ptr (C'THCState) -> Ptr (Ptr C'_THCDeviceAllocator)+p'THCState'p2pAccessEnabled p = plusPtr p 64+p'THCState'p2pAccessEnabled :: Ptr (C'THCState) -> Ptr (Ptr (Ptr CInt))+p'THCState'p2pKernelAccessEnabled p = plusPtr p 72+p'THCState'p2pKernelAccessEnabled :: Ptr (C'THCState) -> Ptr (CInt)+p'THCState'cutorchGCFunction p = plusPtr p 80+p'THCState'cutorchGCFunction :: Ptr (C'THCState) -> Ptr (FunPtr (Ptr () -> IO ()))+p'THCState'cutorchGCData p = plusPtr p 88+p'THCState'cutorchGCData :: Ptr (C'THCState) -> Ptr (Ptr ())+p'THCState'heapSoftmax p = plusPtr p 96+p'THCState'heapSoftmax :: Ptr (C'THCState) -> Ptr (CLong)+p'THCState'heapDelta p = plusPtr p 104+p'THCState'heapDelta :: Ptr (C'THCState) -> Ptr (CLong)+instance Storable C'THCState where+ sizeOf _ = 112+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ v4 <- peekByteOff _p 28+ v5 <- peekByteOff _p 32+ v6 <- peekByteOff _p 36+ v7 <- peekByteOff _p 40+ v8 <- peekByteOff _p 48+ v9 <- peekByteOff _p 56+ v10 <- peekByteOff _p 64+ v11 <- peekByteOff _p 72+ v12 <- peekByteOff _p 80+ v13 <- peekByteOff _p 88+ v14 <- peekByteOff _p 96+ v15 <- peekByteOff _p 104+ return $ C'THCState v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15+ poke _p (C'THCState v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ pokeByteOff _p 28 v4+ pokeByteOff _p 32 v5+ pokeByteOff _p 36 v6+ pokeByteOff _p 40 v7+ pokeByteOff _p 48 v8+ pokeByteOff _p 56 v9+ pokeByteOff _p 64 v10+ pokeByteOff _p 72 v11+ pokeByteOff _p 80 v12+ pokeByteOff _p 88 v13+ pokeByteOff _p 96 v14+ pokeByteOff _p 104 v15+ return ()+++{- typedef struct THCByteStorage {+ unsigned char * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THCDeviceAllocator * allocator;+ void * allocatorContext;+ struct THCByteStorage * view;+ int device;+ } THCByteStorage; -}++++++++++data C'THCByteStorage = C'THCByteStorage{+ c'THCByteStorage'data :: Ptr CUChar,+ c'THCByteStorage'size :: CLong,+ c'THCByteStorage'refcount :: CInt,+ c'THCByteStorage'flag :: CChar,+ c'THCByteStorage'allocator :: Ptr C'_THCDeviceAllocator,+ c'THCByteStorage'allocatorContext :: Ptr (),+ c'THCByteStorage'view :: Ptr C'THCByteStorage,+ c'THCByteStorage'device :: CInt+} deriving (Eq,Show)+p'THCByteStorage'data p = plusPtr p 0+p'THCByteStorage'data :: Ptr (C'THCByteStorage) -> Ptr (Ptr CUChar)+p'THCByteStorage'size p = plusPtr p 8+p'THCByteStorage'size :: Ptr (C'THCByteStorage) -> Ptr (CLong)+p'THCByteStorage'refcount p = plusPtr p 16+p'THCByteStorage'refcount :: Ptr (C'THCByteStorage) -> Ptr (CInt)+p'THCByteStorage'flag p = plusPtr p 20+p'THCByteStorage'flag :: Ptr (C'THCByteStorage) -> Ptr (CChar)+p'THCByteStorage'allocator p = plusPtr p 24+p'THCByteStorage'allocator :: Ptr (C'THCByteStorage) -> Ptr (Ptr C'_THCDeviceAllocator)+p'THCByteStorage'allocatorContext p = plusPtr p 32+p'THCByteStorage'allocatorContext :: Ptr (C'THCByteStorage) -> Ptr (Ptr ())+p'THCByteStorage'view p = plusPtr p 40+p'THCByteStorage'view :: Ptr (C'THCByteStorage) -> Ptr (Ptr C'THCByteStorage)+p'THCByteStorage'device p = plusPtr p 48+p'THCByteStorage'device :: Ptr (C'THCByteStorage) -> Ptr (CInt)+instance Storable C'THCByteStorage where+ sizeOf _ = 56+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 20+ v4 <- peekByteOff _p 24+ v5 <- peekByteOff _p 32+ v6 <- peekByteOff _p 40+ v7 <- peekByteOff _p 48+ return $ C'THCByteStorage v0 v1 v2 v3 v4 v5 v6 v7+ poke _p (C'THCByteStorage v0 v1 v2 v3 v4 v5 v6 v7) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 20 v3+ pokeByteOff _p 24 v4+ pokeByteOff _p 32 v5+ pokeByteOff _p 40 v6+ pokeByteOff _p 48 v7+ return ()+++{- typedef struct THCCharStorage {+ char * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THCDeviceAllocator * allocator;+ void * allocatorContext;+ struct THCCharStorage * view;+ int device;+ } THCCharStorage; -}++++++++++data C'THCCharStorage = C'THCCharStorage{+ c'THCCharStorage'data :: CString,+ c'THCCharStorage'size :: CLong,+ c'THCCharStorage'refcount :: CInt,+ c'THCCharStorage'flag :: CChar,+ c'THCCharStorage'allocator :: Ptr C'_THCDeviceAllocator,+ c'THCCharStorage'allocatorContext :: Ptr (),+ c'THCCharStorage'view :: Ptr C'THCCharStorage,+ c'THCCharStorage'device :: CInt+} deriving (Eq,Show)+p'THCCharStorage'data p = plusPtr p 0+p'THCCharStorage'data :: Ptr (C'THCCharStorage) -> Ptr (CString)+p'THCCharStorage'size p = plusPtr p 8+p'THCCharStorage'size :: Ptr (C'THCCharStorage) -> Ptr (CLong)+p'THCCharStorage'refcount p = plusPtr p 16+p'THCCharStorage'refcount :: Ptr (C'THCCharStorage) -> Ptr (CInt)+p'THCCharStorage'flag p = plusPtr p 20+p'THCCharStorage'flag :: Ptr (C'THCCharStorage) -> Ptr (CChar)+p'THCCharStorage'allocator p = plusPtr p 24+p'THCCharStorage'allocator :: Ptr (C'THCCharStorage) -> Ptr (Ptr C'_THCDeviceAllocator)+p'THCCharStorage'allocatorContext p = plusPtr p 32+p'THCCharStorage'allocatorContext :: Ptr (C'THCCharStorage) -> Ptr (Ptr ())+p'THCCharStorage'view p = plusPtr p 40+p'THCCharStorage'view :: Ptr (C'THCCharStorage) -> Ptr (Ptr C'THCCharStorage)+p'THCCharStorage'device p = plusPtr p 48+p'THCCharStorage'device :: Ptr (C'THCCharStorage) -> Ptr (CInt)+instance Storable C'THCCharStorage where+ sizeOf _ = 56+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 20+ v4 <- peekByteOff _p 24+ v5 <- peekByteOff _p 32+ v6 <- peekByteOff _p 40+ v7 <- peekByteOff _p 48+ return $ C'THCCharStorage v0 v1 v2 v3 v4 v5 v6 v7+ poke _p (C'THCCharStorage v0 v1 v2 v3 v4 v5 v6 v7) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 20 v3+ pokeByteOff _p 24 v4+ pokeByteOff _p 32 v5+ pokeByteOff _p 40 v6+ pokeByteOff _p 48 v7+ return ()+++{- typedef struct THCDoubleStorage {+ double * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THCDeviceAllocator * allocator;+ void * allocatorContext;+ struct THCDoubleStorage * view;+ int device;+ } THCDoubleStorage; -}++++++++++data C'THCDoubleStorage = C'THCDoubleStorage{+ c'THCDoubleStorage'data :: Ptr CDouble,+ c'THCDoubleStorage'size :: CLong,+ c'THCDoubleStorage'refcount :: CInt,+ c'THCDoubleStorage'flag :: CChar,+ c'THCDoubleStorage'allocator :: Ptr C'_THCDeviceAllocator,+ c'THCDoubleStorage'allocatorContext :: Ptr (),+ c'THCDoubleStorage'view :: Ptr C'THCDoubleStorage,+ c'THCDoubleStorage'device :: CInt+} deriving (Eq,Show)+p'THCDoubleStorage'data p = plusPtr p 0+p'THCDoubleStorage'data :: Ptr (C'THCDoubleStorage) -> Ptr (Ptr CDouble)+p'THCDoubleStorage'size p = plusPtr p 8+p'THCDoubleStorage'size :: Ptr (C'THCDoubleStorage) -> Ptr (CLong)+p'THCDoubleStorage'refcount p = plusPtr p 16+p'THCDoubleStorage'refcount :: Ptr (C'THCDoubleStorage) -> Ptr (CInt)+p'THCDoubleStorage'flag p = plusPtr p 20+p'THCDoubleStorage'flag :: Ptr (C'THCDoubleStorage) -> Ptr (CChar)+p'THCDoubleStorage'allocator p = plusPtr p 24+p'THCDoubleStorage'allocator :: Ptr (C'THCDoubleStorage) -> Ptr (Ptr C'_THCDeviceAllocator)+p'THCDoubleStorage'allocatorContext p = plusPtr p 32+p'THCDoubleStorage'allocatorContext :: Ptr (C'THCDoubleStorage) -> Ptr (Ptr ())+p'THCDoubleStorage'view p = plusPtr p 40+p'THCDoubleStorage'view :: Ptr (C'THCDoubleStorage) -> Ptr (Ptr C'THCDoubleStorage)+p'THCDoubleStorage'device p = plusPtr p 48+p'THCDoubleStorage'device :: Ptr (C'THCDoubleStorage) -> Ptr (CInt)+instance Storable C'THCDoubleStorage where+ sizeOf _ = 56+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 20+ v4 <- peekByteOff _p 24+ v5 <- peekByteOff _p 32+ v6 <- peekByteOff _p 40+ v7 <- peekByteOff _p 48+ return $ C'THCDoubleStorage v0 v1 v2 v3 v4 v5 v6 v7+ poke _p (C'THCDoubleStorage v0 v1 v2 v3 v4 v5 v6 v7) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 20 v3+ pokeByteOff _p 24 v4+ pokeByteOff _p 32 v5+ pokeByteOff _p 40 v6+ pokeByteOff _p 48 v7+ return ()+++{- typedef struct THCFloatStorage {+ float * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THCDeviceAllocator * allocator;+ void * allocatorContext;+ struct THCFloatStorage * view;+ int device;+ } THCFloatStorage; -}++++++++++data C'THCFloatStorage = C'THCFloatStorage{+ c'THCFloatStorage'data :: Ptr CFloat,+ c'THCFloatStorage'size :: CLong,+ c'THCFloatStorage'refcount :: CInt,+ c'THCFloatStorage'flag :: CChar,+ c'THCFloatStorage'allocator :: Ptr C'_THCDeviceAllocator,+ c'THCFloatStorage'allocatorContext :: Ptr (),+ c'THCFloatStorage'view :: Ptr C'THCFloatStorage,+ c'THCFloatStorage'device :: CInt+} deriving (Eq,Show)+p'THCFloatStorage'data p = plusPtr p 0+p'THCFloatStorage'data :: Ptr (C'THCFloatStorage) -> Ptr (Ptr CFloat)+p'THCFloatStorage'size p = plusPtr p 8+p'THCFloatStorage'size :: Ptr (C'THCFloatStorage) -> Ptr (CLong)+p'THCFloatStorage'refcount p = plusPtr p 16+p'THCFloatStorage'refcount :: Ptr (C'THCFloatStorage) -> Ptr (CInt)+p'THCFloatStorage'flag p = plusPtr p 20+p'THCFloatStorage'flag :: Ptr (C'THCFloatStorage) -> Ptr (CChar)+p'THCFloatStorage'allocator p = plusPtr p 24+p'THCFloatStorage'allocator :: Ptr (C'THCFloatStorage) -> Ptr (Ptr C'_THCDeviceAllocator)+p'THCFloatStorage'allocatorContext p = plusPtr p 32+p'THCFloatStorage'allocatorContext :: Ptr (C'THCFloatStorage) -> Ptr (Ptr ())+p'THCFloatStorage'view p = plusPtr p 40+p'THCFloatStorage'view :: Ptr (C'THCFloatStorage) -> Ptr (Ptr C'THCFloatStorage)+p'THCFloatStorage'device p = plusPtr p 48+p'THCFloatStorage'device :: Ptr (C'THCFloatStorage) -> Ptr (CInt)+instance Storable C'THCFloatStorage where+ sizeOf _ = 56+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 20+ v4 <- peekByteOff _p 24+ v5 <- peekByteOff _p 32+ v6 <- peekByteOff _p 40+ v7 <- peekByteOff _p 48+ return $ C'THCFloatStorage v0 v1 v2 v3 v4 v5 v6 v7+ poke _p (C'THCFloatStorage v0 v1 v2 v3 v4 v5 v6 v7) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 20 v3+ pokeByteOff _p 24 v4+ pokeByteOff _p 32 v5+ pokeByteOff _p 40 v6+ pokeByteOff _p 48 v7+ return ()+++{- typedef struct THCIntStorage {+ int * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THCDeviceAllocator * allocator;+ void * allocatorContext;+ struct THCIntStorage * view;+ int device;+ } THCIntStorage; -}++++++++++data C'THCIntStorage = C'THCIntStorage{+ c'THCIntStorage'data :: Ptr CInt,+ c'THCIntStorage'size :: CLong,+ c'THCIntStorage'refcount :: CInt,+ c'THCIntStorage'flag :: CChar,+ c'THCIntStorage'allocator :: Ptr C'_THCDeviceAllocator,+ c'THCIntStorage'allocatorContext :: Ptr (),+ c'THCIntStorage'view :: Ptr C'THCIntStorage,+ c'THCIntStorage'device :: CInt+} deriving (Eq,Show)+p'THCIntStorage'data p = plusPtr p 0+p'THCIntStorage'data :: Ptr (C'THCIntStorage) -> Ptr (Ptr CInt)+p'THCIntStorage'size p = plusPtr p 8+p'THCIntStorage'size :: Ptr (C'THCIntStorage) -> Ptr (CLong)+p'THCIntStorage'refcount p = plusPtr p 16+p'THCIntStorage'refcount :: Ptr (C'THCIntStorage) -> Ptr (CInt)+p'THCIntStorage'flag p = plusPtr p 20+p'THCIntStorage'flag :: Ptr (C'THCIntStorage) -> Ptr (CChar)+p'THCIntStorage'allocator p = plusPtr p 24+p'THCIntStorage'allocator :: Ptr (C'THCIntStorage) -> Ptr (Ptr C'_THCDeviceAllocator)+p'THCIntStorage'allocatorContext p = plusPtr p 32+p'THCIntStorage'allocatorContext :: Ptr (C'THCIntStorage) -> Ptr (Ptr ())+p'THCIntStorage'view p = plusPtr p 40+p'THCIntStorage'view :: Ptr (C'THCIntStorage) -> Ptr (Ptr C'THCIntStorage)+p'THCIntStorage'device p = plusPtr p 48+p'THCIntStorage'device :: Ptr (C'THCIntStorage) -> Ptr (CInt)+instance Storable C'THCIntStorage where+ sizeOf _ = 56+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 20+ v4 <- peekByteOff _p 24+ v5 <- peekByteOff _p 32+ v6 <- peekByteOff _p 40+ v7 <- peekByteOff _p 48+ return $ C'THCIntStorage v0 v1 v2 v3 v4 v5 v6 v7+ poke _p (C'THCIntStorage v0 v1 v2 v3 v4 v5 v6 v7) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 20 v3+ pokeByteOff _p 24 v4+ pokeByteOff _p 32 v5+ pokeByteOff _p 40 v6+ pokeByteOff _p 48 v7+ return ()+++{- typedef struct THCShortStorage {+ short * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THCDeviceAllocator * allocator;+ void * allocatorContext;+ struct THCShortStorage * view;+ int device;+ } THCShortStorage; -}++++++++++data C'THCShortStorage = C'THCShortStorage{+ c'THCShortStorage'data :: Ptr CShort,+ c'THCShortStorage'size :: CLong,+ c'THCShortStorage'refcount :: CInt,+ c'THCShortStorage'flag :: CChar,+ c'THCShortStorage'allocator :: Ptr C'_THCDeviceAllocator,+ c'THCShortStorage'allocatorContext :: Ptr (),+ c'THCShortStorage'view :: Ptr C'THCShortStorage,+ c'THCShortStorage'device :: CInt+} deriving (Eq,Show)+p'THCShortStorage'data p = plusPtr p 0+p'THCShortStorage'data :: Ptr (C'THCShortStorage) -> Ptr (Ptr CShort)+p'THCShortStorage'size p = plusPtr p 8+p'THCShortStorage'size :: Ptr (C'THCShortStorage) -> Ptr (CLong)+p'THCShortStorage'refcount p = plusPtr p 16+p'THCShortStorage'refcount :: Ptr (C'THCShortStorage) -> Ptr (CInt)+p'THCShortStorage'flag p = plusPtr p 20+p'THCShortStorage'flag :: Ptr (C'THCShortStorage) -> Ptr (CChar)+p'THCShortStorage'allocator p = plusPtr p 24+p'THCShortStorage'allocator :: Ptr (C'THCShortStorage) -> Ptr (Ptr C'_THCDeviceAllocator)+p'THCShortStorage'allocatorContext p = plusPtr p 32+p'THCShortStorage'allocatorContext :: Ptr (C'THCShortStorage) -> Ptr (Ptr ())+p'THCShortStorage'view p = plusPtr p 40+p'THCShortStorage'view :: Ptr (C'THCShortStorage) -> Ptr (Ptr C'THCShortStorage)+p'THCShortStorage'device p = plusPtr p 48+p'THCShortStorage'device :: Ptr (C'THCShortStorage) -> Ptr (CInt)+instance Storable C'THCShortStorage where+ sizeOf _ = 56+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 20+ v4 <- peekByteOff _p 24+ v5 <- peekByteOff _p 32+ v6 <- peekByteOff _p 40+ v7 <- peekByteOff _p 48+ return $ C'THCShortStorage v0 v1 v2 v3 v4 v5 v6 v7+ poke _p (C'THCShortStorage v0 v1 v2 v3 v4 v5 v6 v7) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 20 v3+ pokeByteOff _p 24 v4+ pokeByteOff _p 32 v5+ pokeByteOff _p 40 v6+ pokeByteOff _p 48 v7+ return ()+++{- typedef struct THCLongStorage {+ long * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THCDeviceAllocator * allocator;+ void * allocatorContext;+ struct THCLongStorage * view;+ int device;+ } THCLongStorage; -}++++++++++data C'THCLongStorage = C'THCLongStorage{+ c'THCLongStorage'data :: Ptr CLong,+ c'THCLongStorage'size :: CLong,+ c'THCLongStorage'refcount :: CInt,+ c'THCLongStorage'flag :: CChar,+ c'THCLongStorage'allocator :: Ptr C'_THCDeviceAllocator,+ c'THCLongStorage'allocatorContext :: Ptr (),+ c'THCLongStorage'view :: Ptr C'THCLongStorage,+ c'THCLongStorage'device :: CInt+} deriving (Eq,Show)+p'THCLongStorage'data p = plusPtr p 0+p'THCLongStorage'data :: Ptr (C'THCLongStorage) -> Ptr (Ptr CLong)+p'THCLongStorage'size p = plusPtr p 8+p'THCLongStorage'size :: Ptr (C'THCLongStorage) -> Ptr (CLong)+p'THCLongStorage'refcount p = plusPtr p 16+p'THCLongStorage'refcount :: Ptr (C'THCLongStorage) -> Ptr (CInt)+p'THCLongStorage'flag p = plusPtr p 20+p'THCLongStorage'flag :: Ptr (C'THCLongStorage) -> Ptr (CChar)+p'THCLongStorage'allocator p = plusPtr p 24+p'THCLongStorage'allocator :: Ptr (C'THCLongStorage) -> Ptr (Ptr C'_THCDeviceAllocator)+p'THCLongStorage'allocatorContext p = plusPtr p 32+p'THCLongStorage'allocatorContext :: Ptr (C'THCLongStorage) -> Ptr (Ptr ())+p'THCLongStorage'view p = plusPtr p 40+p'THCLongStorage'view :: Ptr (C'THCLongStorage) -> Ptr (Ptr C'THCLongStorage)+p'THCLongStorage'device p = plusPtr p 48+p'THCLongStorage'device :: Ptr (C'THCLongStorage) -> Ptr (CInt)+instance Storable C'THCLongStorage where+ sizeOf _ = 56+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 20+ v4 <- peekByteOff _p 24+ v5 <- peekByteOff _p 32+ v6 <- peekByteOff _p 40+ v7 <- peekByteOff _p 48+ return $ C'THCLongStorage v0 v1 v2 v3 v4 v5 v6 v7+ poke _p (C'THCLongStorage v0 v1 v2 v3 v4 v5 v6 v7) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 20 v3+ pokeByteOff _p 24 v4+ pokeByteOff _p 32 v5+ pokeByteOff _p 40 v6+ pokeByteOff _p 48 v7+ return ()+++{- typedef struct THCudaByteTensor {+ long * size;+ long * stride;+ int nDimension;+ THCByteStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THCudaByteTensor; -}+++++++++data C'THCudaByteTensor = C'THCudaByteTensor{+ c'THCudaByteTensor'size :: Ptr CLong,+ c'THCudaByteTensor'stride :: Ptr CLong,+ c'THCudaByteTensor'nDimension :: CInt,+ c'THCudaByteTensor'storage :: Ptr C'THCByteStorage,+ c'THCudaByteTensor'storageOffset :: CLong,+ c'THCudaByteTensor'refcount :: CInt,+ c'THCudaByteTensor'flag :: CChar+} deriving (Eq,Show)+p'THCudaByteTensor'size p = plusPtr p 0+p'THCudaByteTensor'size :: Ptr (C'THCudaByteTensor) -> Ptr (Ptr CLong)+p'THCudaByteTensor'stride p = plusPtr p 8+p'THCudaByteTensor'stride :: Ptr (C'THCudaByteTensor) -> Ptr (Ptr CLong)+p'THCudaByteTensor'nDimension p = plusPtr p 16+p'THCudaByteTensor'nDimension :: Ptr (C'THCudaByteTensor) -> Ptr (CInt)+p'THCudaByteTensor'storage p = plusPtr p 24+p'THCudaByteTensor'storage :: Ptr (C'THCudaByteTensor) -> Ptr (Ptr C'THCByteStorage)+p'THCudaByteTensor'storageOffset p = plusPtr p 32+p'THCudaByteTensor'storageOffset :: Ptr (C'THCudaByteTensor) -> Ptr (CLong)+p'THCudaByteTensor'refcount p = plusPtr p 40+p'THCudaByteTensor'refcount :: Ptr (C'THCudaByteTensor) -> Ptr (CInt)+p'THCudaByteTensor'flag p = plusPtr p 44+p'THCudaByteTensor'flag :: Ptr (C'THCudaByteTensor) -> Ptr (CChar)+instance Storable C'THCudaByteTensor where+ sizeOf _ = 48+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ v4 <- peekByteOff _p 32+ v5 <- peekByteOff _p 40+ v6 <- peekByteOff _p 44+ return $ C'THCudaByteTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THCudaByteTensor v0 v1 v2 v3 v4 v5 v6) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ pokeByteOff _p 32 v4+ pokeByteOff _p 40 v5+ pokeByteOff _p 44 v6+ return ()+++{- typedef struct THCudaCharTensor {+ long * size;+ long * stride;+ int nDimension;+ THCCharStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THCudaCharTensor; -}+++++++++data C'THCudaCharTensor = C'THCudaCharTensor{+ c'THCudaCharTensor'size :: Ptr CLong,+ c'THCudaCharTensor'stride :: Ptr CLong,+ c'THCudaCharTensor'nDimension :: CInt,+ c'THCudaCharTensor'storage :: Ptr C'THCCharStorage,+ c'THCudaCharTensor'storageOffset :: CLong,+ c'THCudaCharTensor'refcount :: CInt,+ c'THCudaCharTensor'flag :: CChar+} deriving (Eq,Show)+p'THCudaCharTensor'size p = plusPtr p 0+p'THCudaCharTensor'size :: Ptr (C'THCudaCharTensor) -> Ptr (Ptr CLong)+p'THCudaCharTensor'stride p = plusPtr p 8+p'THCudaCharTensor'stride :: Ptr (C'THCudaCharTensor) -> Ptr (Ptr CLong)+p'THCudaCharTensor'nDimension p = plusPtr p 16+p'THCudaCharTensor'nDimension :: Ptr (C'THCudaCharTensor) -> Ptr (CInt)+p'THCudaCharTensor'storage p = plusPtr p 24+p'THCudaCharTensor'storage :: Ptr (C'THCudaCharTensor) -> Ptr (Ptr C'THCCharStorage)+p'THCudaCharTensor'storageOffset p = plusPtr p 32+p'THCudaCharTensor'storageOffset :: Ptr (C'THCudaCharTensor) -> Ptr (CLong)+p'THCudaCharTensor'refcount p = plusPtr p 40+p'THCudaCharTensor'refcount :: Ptr (C'THCudaCharTensor) -> Ptr (CInt)+p'THCudaCharTensor'flag p = plusPtr p 44+p'THCudaCharTensor'flag :: Ptr (C'THCudaCharTensor) -> Ptr (CChar)+instance Storable C'THCudaCharTensor where+ sizeOf _ = 48+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ v4 <- peekByteOff _p 32+ v5 <- peekByteOff _p 40+ v6 <- peekByteOff _p 44+ return $ C'THCudaCharTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THCudaCharTensor v0 v1 v2 v3 v4 v5 v6) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ pokeByteOff _p 32 v4+ pokeByteOff _p 40 v5+ pokeByteOff _p 44 v6+ return ()+++{- typedef struct THCudaDoubleTensor {+ long * size;+ long * stride;+ int nDimension;+ THCDoubleStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THCudaDoubleTensor; -}+++++++++data C'THCudaDoubleTensor = C'THCudaDoubleTensor{+ c'THCudaDoubleTensor'size :: Ptr CLong,+ c'THCudaDoubleTensor'stride :: Ptr CLong,+ c'THCudaDoubleTensor'nDimension :: CInt,+ c'THCudaDoubleTensor'storage :: Ptr C'THCDoubleStorage,+ c'THCudaDoubleTensor'storageOffset :: CLong,+ c'THCudaDoubleTensor'refcount :: CInt,+ c'THCudaDoubleTensor'flag :: CChar+} deriving (Eq,Show)+p'THCudaDoubleTensor'size p = plusPtr p 0+p'THCudaDoubleTensor'size :: Ptr (C'THCudaDoubleTensor) -> Ptr (Ptr CLong)+p'THCudaDoubleTensor'stride p = plusPtr p 8+p'THCudaDoubleTensor'stride :: Ptr (C'THCudaDoubleTensor) -> Ptr (Ptr CLong)+p'THCudaDoubleTensor'nDimension p = plusPtr p 16+p'THCudaDoubleTensor'nDimension :: Ptr (C'THCudaDoubleTensor) -> Ptr (CInt)+p'THCudaDoubleTensor'storage p = plusPtr p 24+p'THCudaDoubleTensor'storage :: Ptr (C'THCudaDoubleTensor) -> Ptr (Ptr C'THCDoubleStorage)+p'THCudaDoubleTensor'storageOffset p = plusPtr p 32+p'THCudaDoubleTensor'storageOffset :: Ptr (C'THCudaDoubleTensor) -> Ptr (CLong)+p'THCudaDoubleTensor'refcount p = plusPtr p 40+p'THCudaDoubleTensor'refcount :: Ptr (C'THCudaDoubleTensor) -> Ptr (CInt)+p'THCudaDoubleTensor'flag p = plusPtr p 44+p'THCudaDoubleTensor'flag :: Ptr (C'THCudaDoubleTensor) -> Ptr (CChar)+instance Storable C'THCudaDoubleTensor where+ sizeOf _ = 48+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ v4 <- peekByteOff _p 32+ v5 <- peekByteOff _p 40+ v6 <- peekByteOff _p 44+ return $ C'THCudaDoubleTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THCudaDoubleTensor v0 v1 v2 v3 v4 v5 v6) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ pokeByteOff _p 32 v4+ pokeByteOff _p 40 v5+ pokeByteOff _p 44 v6+ return ()+++{- typedef struct THCudaFloatTensor {+ long * size;+ long * stride;+ int nDimension;+ THCFloatStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THCudaFloatTensor; -}+++++++++data C'THCudaFloatTensor = C'THCudaFloatTensor{+ c'THCudaFloatTensor'size :: Ptr CLong,+ c'THCudaFloatTensor'stride :: Ptr CLong,+ c'THCudaFloatTensor'nDimension :: CInt,+ c'THCudaFloatTensor'storage :: Ptr C'THCFloatStorage,+ c'THCudaFloatTensor'storageOffset :: CLong,+ c'THCudaFloatTensor'refcount :: CInt,+ c'THCudaFloatTensor'flag :: CChar+} deriving (Eq,Show)+p'THCudaFloatTensor'size p = plusPtr p 0+p'THCudaFloatTensor'size :: Ptr (C'THCudaFloatTensor) -> Ptr (Ptr CLong)+p'THCudaFloatTensor'stride p = plusPtr p 8+p'THCudaFloatTensor'stride :: Ptr (C'THCudaFloatTensor) -> Ptr (Ptr CLong)+p'THCudaFloatTensor'nDimension p = plusPtr p 16+p'THCudaFloatTensor'nDimension :: Ptr (C'THCudaFloatTensor) -> Ptr (CInt)+p'THCudaFloatTensor'storage p = plusPtr p 24+p'THCudaFloatTensor'storage :: Ptr (C'THCudaFloatTensor) -> Ptr (Ptr C'THCFloatStorage)+p'THCudaFloatTensor'storageOffset p = plusPtr p 32+p'THCudaFloatTensor'storageOffset :: Ptr (C'THCudaFloatTensor) -> Ptr (CLong)+p'THCudaFloatTensor'refcount p = plusPtr p 40+p'THCudaFloatTensor'refcount :: Ptr (C'THCudaFloatTensor) -> Ptr (CInt)+p'THCudaFloatTensor'flag p = plusPtr p 44+p'THCudaFloatTensor'flag :: Ptr (C'THCudaFloatTensor) -> Ptr (CChar)+instance Storable C'THCudaFloatTensor where+ sizeOf _ = 48+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ v4 <- peekByteOff _p 32+ v5 <- peekByteOff _p 40+ v6 <- peekByteOff _p 44+ return $ C'THCudaFloatTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THCudaFloatTensor v0 v1 v2 v3 v4 v5 v6) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ pokeByteOff _p 32 v4+ pokeByteOff _p 40 v5+ pokeByteOff _p 44 v6+ return ()+++{- typedef struct THCudaIntTensor {+ long * size;+ long * stride;+ int nDimension;+ THCIntStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THCudaIntTensor; -}+++++++++data C'THCudaIntTensor = C'THCudaIntTensor{+ c'THCudaIntTensor'size :: Ptr CLong,+ c'THCudaIntTensor'stride :: Ptr CLong,+ c'THCudaIntTensor'nDimension :: CInt,+ c'THCudaIntTensor'storage :: Ptr C'THCIntStorage,+ c'THCudaIntTensor'storageOffset :: CLong,+ c'THCudaIntTensor'refcount :: CInt,+ c'THCudaIntTensor'flag :: CChar+} deriving (Eq,Show)+p'THCudaIntTensor'size p = plusPtr p 0+p'THCudaIntTensor'size :: Ptr (C'THCudaIntTensor) -> Ptr (Ptr CLong)+p'THCudaIntTensor'stride p = plusPtr p 8+p'THCudaIntTensor'stride :: Ptr (C'THCudaIntTensor) -> Ptr (Ptr CLong)+p'THCudaIntTensor'nDimension p = plusPtr p 16+p'THCudaIntTensor'nDimension :: Ptr (C'THCudaIntTensor) -> Ptr (CInt)+p'THCudaIntTensor'storage p = plusPtr p 24+p'THCudaIntTensor'storage :: Ptr (C'THCudaIntTensor) -> Ptr (Ptr C'THCIntStorage)+p'THCudaIntTensor'storageOffset p = plusPtr p 32+p'THCudaIntTensor'storageOffset :: Ptr (C'THCudaIntTensor) -> Ptr (CLong)+p'THCudaIntTensor'refcount p = plusPtr p 40+p'THCudaIntTensor'refcount :: Ptr (C'THCudaIntTensor) -> Ptr (CInt)+p'THCudaIntTensor'flag p = plusPtr p 44+p'THCudaIntTensor'flag :: Ptr (C'THCudaIntTensor) -> Ptr (CChar)+instance Storable C'THCudaIntTensor where+ sizeOf _ = 48+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ v4 <- peekByteOff _p 32+ v5 <- peekByteOff _p 40+ v6 <- peekByteOff _p 44+ return $ C'THCudaIntTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THCudaIntTensor v0 v1 v2 v3 v4 v5 v6) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ pokeByteOff _p 32 v4+ pokeByteOff _p 40 v5+ pokeByteOff _p 44 v6+ return ()+++{- typedef struct THCudaShortTensor {+ long * size;+ long * stride;+ int nDimension;+ THCShortStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THCudaShortTensor; -}+++++++++data C'THCudaShortTensor = C'THCudaShortTensor{+ c'THCudaShortTensor'size :: Ptr CLong,+ c'THCudaShortTensor'stride :: Ptr CLong,+ c'THCudaShortTensor'nDimension :: CInt,+ c'THCudaShortTensor'storage :: Ptr C'THCShortStorage,+ c'THCudaShortTensor'storageOffset :: CLong,+ c'THCudaShortTensor'refcount :: CInt,+ c'THCudaShortTensor'flag :: CChar+} deriving (Eq,Show)+p'THCudaShortTensor'size p = plusPtr p 0+p'THCudaShortTensor'size :: Ptr (C'THCudaShortTensor) -> Ptr (Ptr CLong)+p'THCudaShortTensor'stride p = plusPtr p 8+p'THCudaShortTensor'stride :: Ptr (C'THCudaShortTensor) -> Ptr (Ptr CLong)+p'THCudaShortTensor'nDimension p = plusPtr p 16+p'THCudaShortTensor'nDimension :: Ptr (C'THCudaShortTensor) -> Ptr (CInt)+p'THCudaShortTensor'storage p = plusPtr p 24+p'THCudaShortTensor'storage :: Ptr (C'THCudaShortTensor) -> Ptr (Ptr C'THCShortStorage)+p'THCudaShortTensor'storageOffset p = plusPtr p 32+p'THCudaShortTensor'storageOffset :: Ptr (C'THCudaShortTensor) -> Ptr (CLong)+p'THCudaShortTensor'refcount p = plusPtr p 40+p'THCudaShortTensor'refcount :: Ptr (C'THCudaShortTensor) -> Ptr (CInt)+p'THCudaShortTensor'flag p = plusPtr p 44+p'THCudaShortTensor'flag :: Ptr (C'THCudaShortTensor) -> Ptr (CChar)+instance Storable C'THCudaShortTensor where+ sizeOf _ = 48+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ v4 <- peekByteOff _p 32+ v5 <- peekByteOff _p 40+ v6 <- peekByteOff _p 44+ return $ C'THCudaShortTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THCudaShortTensor v0 v1 v2 v3 v4 v5 v6) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ pokeByteOff _p 32 v4+ pokeByteOff _p 40 v5+ pokeByteOff _p 44 v6+ return ()+++{- typedef struct THCudaLongTensor {+ long * size;+ long * stride;+ int nDimension;+ THCLongStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THCudaLongTensor; -}+++++++++data C'THCudaLongTensor = C'THCudaLongTensor{+ c'THCudaLongTensor'size :: Ptr CLong,+ c'THCudaLongTensor'stride :: Ptr CLong,+ c'THCudaLongTensor'nDimension :: CInt,+ c'THCudaLongTensor'storage :: Ptr C'THCLongStorage,+ c'THCudaLongTensor'storageOffset :: CLong,+ c'THCudaLongTensor'refcount :: CInt,+ c'THCudaLongTensor'flag :: CChar+} deriving (Eq,Show)+p'THCudaLongTensor'size p = plusPtr p 0+p'THCudaLongTensor'size :: Ptr (C'THCudaLongTensor) -> Ptr (Ptr CLong)+p'THCudaLongTensor'stride p = plusPtr p 8+p'THCudaLongTensor'stride :: Ptr (C'THCudaLongTensor) -> Ptr (Ptr CLong)+p'THCudaLongTensor'nDimension p = plusPtr p 16+p'THCudaLongTensor'nDimension :: Ptr (C'THCudaLongTensor) -> Ptr (CInt)+p'THCudaLongTensor'storage p = plusPtr p 24+p'THCudaLongTensor'storage :: Ptr (C'THCudaLongTensor) -> Ptr (Ptr C'THCLongStorage)+p'THCudaLongTensor'storageOffset p = plusPtr p 32+p'THCudaLongTensor'storageOffset :: Ptr (C'THCudaLongTensor) -> Ptr (CLong)+p'THCudaLongTensor'refcount p = plusPtr p 40+p'THCudaLongTensor'refcount :: Ptr (C'THCudaLongTensor) -> Ptr (CInt)+p'THCudaLongTensor'flag p = plusPtr p 44+p'THCudaLongTensor'flag :: Ptr (C'THCudaLongTensor) -> Ptr (CChar)+instance Storable C'THCudaLongTensor where+ sizeOf _ = 48+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ v3 <- peekByteOff _p 24+ v4 <- peekByteOff _p 32+ v5 <- peekByteOff _p 40+ v6 <- peekByteOff _p 44+ return $ C'THCudaLongTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THCudaLongTensor v0 v1 v2 v3 v4 v5 v6) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ pokeByteOff _p 24 v3+ pokeByteOff _p 32 v4+ pokeByteOff _p 40 v5+ pokeByteOff _p 44 v6+ return ()++
+ src/Torch/Types/THCUNN.hs view
@@ -0,0 +1,4 @@+module Torch.Types.THCUNN ( module X ) where++import Torch.Types.THC as X+