hasktorch-types-th (empty) → 0.0.1.0
raw patch · 12 files changed
+1886/−0 lines, 12 filesdep +basedep +inline-c
Dependencies added: base, inline-c
Files
- cbits/state_free.c +2/−0
- hasktorch-types-th.cabal +53/−0
- src/Torch/Types/Numeric.hs +104/−0
- src/Torch/Types/TH.hs +236/−0
- src/Torch/Types/TH/Byte.hs +90/−0
- src/Torch/Types/TH/Char.hs +60/−0
- src/Torch/Types/TH/Double.hs +51/−0
- src/Torch/Types/TH/Float.hs +57/−0
- src/Torch/Types/TH/Int.hs +97/−0
- src/Torch/Types/TH/Long.hs +50/−0
- src/Torch/Types/TH/Short.hs +54/−0
- src/Torch/Types/TH/Structs.hs +1032/−0
+ cbits/state_free.c view
@@ -0,0 +1,2 @@++void free_CTHState(void* s) { return; }
+ hasktorch-types-th.cabal view
@@ -0,0 +1,53 @@+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/th/hasktorch-types-th.dhall', and re-generate this file by running+-- 'dhall-to-cabal -- ffi/types/th/hasktorch-types-th.dhall > hasktorch-types-th.cabal'.+-- * * * * * * * * * * * * WARNING * * * * * * * * * * * *+name: hasktorch-types-th+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 Torch+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.TH.Byte+ Torch.Types.TH.Char+ Torch.Types.TH.Short+ Torch.Types.TH.Int+ Torch.Types.TH.Long+ Torch.Types.TH.Float+ Torch.Types.TH.Double+ Torch.Types.TH+ Torch.Types.TH.Structs+ Torch.Types.Numeric+ build-tools: c2hs -any+ c-sources:+ cbits/state_free.c+ hs-source-dirs: src+ other-modules:+ Paths_hasktorch_types_th+ autogen-modules:+ Paths_hasktorch_types_th+ default-language: Haskell2010+ default-extensions: KindSignatures DataKinds+ build-depends:+ base (==4.7 || >4.7) && <5,+ inline-c ==0.5 || >0.5+
+ src/Torch/Types/Numeric.hs view
@@ -0,0 +1,104 @@+-------------------------------------------------------------------------------+-- |+-- Module : Torch.Types.Numeric+-- Copyright : (c) Sam Stites 2017+-- License : BSD3+-- Maintainer: sam@stites.io+-- Stability : experimental+-- Portability: non-portable+--+-- ADTs to manage runtime boundaries+-------------------------------------------------------------------------------+module Torch.Types.Numeric+ ( OpenUnit , openUnit , openUnitValue+ , ClosedUnit , closedUnit , closedUnitValue+ , Ord2Tuple , ord2Tuple , ord2TupleValue+ , Positive , positive , positiveValue+ , NonZero , nonZero , nonZeroValue+ ) where+++-- | Datatype to represent the open unit interval: @0 < x < 1@. Any 'OpenUnit' inhabitant+-- must satisfy being in the interval.+--+-- FIXME: replace with numhask.+newtype OpenUnit x = OpenUnit x+ deriving (Eq, Ord, Show)++-- | Get a value from the open unit interval.+openUnitValue :: OpenUnit x -> x+openUnitValue (OpenUnit x) = x++-- | smart constructor to place a number in the open unit interval.+openUnit :: (Ord x, Num x) => x -> Maybe (OpenUnit x)+openUnit x+ | x >= 1 || x <= 0 = Nothing+ | otherwise = Just (OpenUnit x)++-- | Datatype to represent the closed unit interval: @0 =< x =< 1@. Any 'ClosedUnit'+-- inhabitant must satisfy being in the interval.+--+-- FIXME: replace with numhask.+newtype ClosedUnit x = ClosedUnit x+ deriving (Eq, Ord, Show)++-- | Get a value from the closed unit interval.+closedUnitValue :: ClosedUnit x -> x+closedUnitValue (ClosedUnit x) = x++-- | smart constructor to place a number in the closed unit interval.+closedUnit :: (Ord x, Num x) => x -> Maybe (ClosedUnit x)+closedUnit x+ | x >= 1 || x <= 0 = Nothing+ | otherwise = Just (ClosedUnit x)++-- | Datatype to represent an ordered pair of numbers, @(a, b)@, where @a <= b@.+--+-- FIXME: replace with numhask.+newtype Ord2Tuple x = Ord2Tuple (x, x)+ deriving (Eq, Show)++-- | Get the values of an ordered tuple.+ord2TupleValue :: Ord2Tuple x -> (x, x)+ord2TupleValue (Ord2Tuple x) = x++-- | smart constructor to place two values in an ordered tuple.+ord2Tuple :: (Ord x, Num x) => (x, x) -> Maybe (Ord2Tuple x)+ord2Tuple x@(a, b)+ | a <= b = Just (Ord2Tuple x)+ | otherwise = Nothing++-- | Datatype to represent a generic positive number: @0 =< x@.+--+-- FIXME: replace with numhask.+newtype Positive x = Positive x+ deriving (Eq, Ord, Show)++-- | Get a value from the positive bound.+positiveValue :: Positive x -> x+positiveValue (Positive x) = x++-- | smart constructor to place a number in a positive bound.+positive :: (Ord x, Num x) => x -> Maybe (Positive x)+positive x+ | x < 0 = Nothing+ | otherwise = Just (Positive x)+++-- | Datatype to represent a number that is not zero: @0 /= x@.+--+-- FIXME: replace with numhask.+newtype NonZero x = NonZero x+ deriving (Eq, Ord, Show)++-- | Get a value from the positive bound.+nonZeroValue :: NonZero x -> x+nonZeroValue (NonZero x) = x++-- | smart constructor to place a number in a positive bound.+nonZero :: (Ord x, Num x) => x -> Maybe (NonZero x)+nonZero x+ | x < 0 = Nothing+ | otherwise = Just (NonZero x)++
+ src/Torch/Types/TH.hs view
@@ -0,0 +1,236 @@+{-# LANGUAGE ForeignFunctionInterface #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# OPTIONS_GHC -fno-cse #-}+module Torch.Types.TH+ ( module Torch.Types.TH.Structs++ , C'THState, C'THNNState, CState, State(..), asState, torchstate+ , CAllocator, Allocator+ , CGenerator, Generator(..), generatorToRng, Seed(..)+ , CDescBuff, DescBuff, descBuff++ -- for nn-packages+ , CNNState+ , CDim+ , CNNGenerator++ , CInt'+ , CMaskTensor, CIndexTensor, CIndexStorage, C'THIndexTensor, C'THIntegerTensor+ , MaskDynamic, IndexDynamic, MaskTensor, IndexTensor, IndexStorage+++ -- * Unsigned types+ , CByteTensor, ByteDynamic(..), byteDynamic, ByteTensor(..), byteAsStatic+ , CByteStorage, ByteStorage(..), byteStorage++ , CCharTensor, CharDynamic(..), charDynamic, CharTensor(..), charAsStatic+ , CCharStorage, CharStorage(..), charStorage++ -- * Signed types+ , CLongTensor, LongDynamic(..), longDynamic, LongTensor(..), longAsStatic+ , CLongStorage, LongStorage(..), longStorage++ , CShortTensor, ShortDynamic(..), shortDynamic, ShortTensor(..), shortAsStatic+ , CShortStorage, ShortStorage(..), shortStorage++ , CIntTensor, IntDynamic(..), intDynamic, IntTensor(..), intAsStatic+ , CIntStorage, IntStorage(..), intStorage++ -- * Floating types+ , CFloatTensor, FloatDynamic(..), floatDynamic, FloatTensor(..), floatAsStatic+ , CFloatStorage, FloatStorage(..), floatStorage++ , CDoubleTensor, DoubleDynamic(..), doubleDynamic, DoubleTensor(..), doubleAsStatic+ , CDoubleStorage, DoubleStorage(..), doubleStorage++ , C'THHalfTensor, C'THHalfStorage, C'THFile, C'THHalf+ ) where++import Foreign+import Foreign.C.Types+import GHC.TypeLits+import Data.Char (chr)+import System.IO.Unsafe (unsafePerformIO)++import Torch.Types.TH.Structs++type CDescBuff = C'THDescBuff+type DescBuff = String++descBuff :: Ptr CDescBuff -> IO DescBuff+descBuff p = (map (chr . fromIntegral) . c'THDescBuff'str) <$> peek p++foreign import ccall "&free_CTHState" state_free :: FunPtr (Ptr C'THState -> IO ())++-- | 'torchstate' is just a foreign pointer wrapping around a null pointer with a noop+-- finalizer. This is to keep the API unified with THC.+torchstate :: ForeignPtr C'THState+torchstate = unsafePerformIO $ newForeignPtr state_free nullPtr+{-# NOINLINE torchstate #-}++type C'THState = ()+type C'THNNState = C'THState+type CState = C'THState+newtype State = State { asForeign :: ForeignPtr C'THState }+ deriving (Eq, Show)+asState = State++type CAllocator = C'THAllocator+newtype Allocator = Allocator { callocator :: ForeignPtr CAllocator }+ deriving (Eq, Show)+type CGenerator = C'THGenerator -- ^ Backpack type alias for TH's CPU generator+newtype Generator = Generator { rng :: ForeignPtr CGenerator }+ deriving (Eq, Show)+-- ^ Representation of a CPU-bound random number generator++generatorToRng :: ForeignPtr CGenerator -> Generator+generatorToRng = Generator++-- | Representation of a CPU-bound random seed+newtype Seed = Seed { unSeed :: Word64 }+ deriving (Bounded, Enum, Eq, Integral, Num, Ord, Read, Real, Show)++-- for nn-package+type CNNState = CState+type CDim = CLLong+type CNNGenerator = CGenerator++-- data CDoubleTensor+type CInt' = CInt+type Int' = Int++-- Some type alias'+type C'THIndexTensor = CLongTensor+type C'THIntegerTensor = CLongTensor -- TH-specific for THNN.++type CMaskTensor = CByteTensor+type CIndexTensor = CLongTensor+type CIndexStorage = CLongStorage+type MaskDynamic = ByteDynamic+type MaskTensor = ByteTensor+type IndexDynamic = LongDynamic+type IndexTensor = LongTensor+type IndexStorage = LongStorage++-- | A C-level representation of the Byte Tensor type. These need to be wrapped in 'Ptr'+type CByteTensor = C'THByteTensor++-- | A memory-managed representation of TH's Byte Tensor type. These carry a reference to the 'CState'+newtype ByteDynamic = ByteDynamic { byteDynamicState :: (ForeignPtr CState, ForeignPtr CByteTensor) }+ deriving (Eq)+-- | smart constructor for 'ByteDynamic'.+byteDynamic = curry ByteDynamic++-- | A newtype wrapper around 'ByteDynamic' which imbues a 'ByteDynamic' with static tensor dimensions.+newtype ByteTensor (ds :: [Nat]) = ByteTensor { byteAsDynamic :: ByteDynamic }+ deriving (Eq)+-- | smart constructor for 'ByteTensor'.+byteAsStatic = ByteTensor++type CByteStorage = C'THByteStorage+newtype ByteStorage = ByteStorage { byteStorageState :: (ForeignPtr CState, ForeignPtr CByteStorage) }+ deriving (Eq)+byteStorage = curry ByteStorage++type CCharTensor = C'THCharTensor+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'THCharStorage+newtype CharStorage = CharStorage { charStorageState :: (ForeignPtr CState, ForeignPtr CCharStorage) }+ deriving (Eq)+charStorage = curry CharStorage++-- Signed types++type CLongTensor = C'THLongTensor+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'THLongStorage+newtype LongStorage = LongStorage { longStorageState :: (ForeignPtr CState, ForeignPtr CLongStorage) }+ deriving (Eq)+longStorage = curry LongStorage++type CShortTensor = C'THShortTensor+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'THShortStorage+newtype ShortStorage = ShortStorage { shortStorageState :: (ForeignPtr CState, ForeignPtr CShortStorage) }+ deriving (Eq)+shortStorage = curry ShortStorage++type CIntTensor = C'THIntTensor+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'THIntStorage+newtype IntStorage = IntStorage { intStorageState :: (ForeignPtr CState, ForeignPtr CIntStorage) }+ deriving (Eq)+intStorage = curry IntStorage++-- Floating types++type CFloatTensor = C'THFloatTensor+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'THFloatStorage+newtype FloatStorage = FloatStorage { floatStorageState :: (ForeignPtr CState, ForeignPtr CFloatStorage) }+ deriving (Eq)+floatStorage = curry FloatStorage++type CDoubleTensor = C'THDoubleTensor+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'THDoubleStorage+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++-}++type C'THHalfTensor = ()+type C'THHalfStorage = ()+type C'THFile = ()+type C'THHalf = Ptr ()++
+ src/Torch/Types/TH/Byte.hs view
@@ -0,0 +1,90 @@+-------------------------------------------------------------------------------+-- |+-- Module : Torch.Types.TH.Byte+-- Copyright : (c) Sam Stites 2017+-- License : BSD3+-- Maintainer: sam@stites.io+-- Stability : experimental+-- Portability: non-portable+--+-- A package of type aliases to satisfy a backpack Torch.Sig.Types signature.+-------------------------------------------------------------------------------+{-# LANGUAGE DataKinds #-}+module Torch.Types.TH.Byte where++import Foreign+import Foreign.C.Types+import GHC.TypeLits (Nat)+import GHC.Word+import Torch.Types.TH++-- | type alias of 'CByteStorage'+type CStorage = CByteStorage+-- | type alias of 'CByteTensor'+type CTensor = CByteTensor++-- | C-level representation of a torch "real" -- the inhabitant of a 'CTensor'. Alias to 'CUChar'.+type CReal = CUChar+-- | C-level representation of a torch "accreal" -- the accumulating type of a 'CTensor'. Alias to 'CLong'.+type CAccReal = CLong+-- | Hask-level representation of a torch "real" -- the accumulating type of a 'Tensor'. Alias to 'Word32'.+type HsReal = Word8+-- | Hask-level representation of a torch "accreal" -- the accumulating type of a 'Tensor'. Alias to 'Word64'.+type HsAccReal = Word64++real2acc :: HsReal -> HsAccReal+real2acc = fromIntegral++acc2real :: HsAccReal -> HsReal+acc2real = fromIntegral++-- | convert an 'HsReal' to its C-level representation+hs2cReal :: HsReal -> CReal+hs2cReal = fromIntegral++-- | convert an 'HsAccReal' to its C-level representation+hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = fromIntegral++-- | convert a 'CReal' to its Hask-level representation+c2hsReal :: CReal -> HsReal+c2hsReal = fromIntegral++-- | convert a 'CAccReal' to its Hask-level representation+c2hsAccReal :: CAccReal -> HsAccReal+c2hsAccReal = fromIntegral++-- | convert an integral type to its hask-level representation+i2hsReal :: Integral i => i -> HsReal+i2hsReal = fromIntegral++-- | type alias to 'ByteStorage'+type Storage = ByteStorage+-- | get the C-level representation of a 'ByteStorage' out of 'byteStorageState'+cstorage = snd . byteStorageState+-- | alias to 'byteStorage'+storage = byteStorage+-- | alias to 'byteStorageState'+storageState = byteStorageState+-- | get the C-level representation of the 'CState' from a 'ByteStorage' out of 'byteStorageState'+storageStateRef = fst . byteStorageState++-- | type alias to 'ByteDynamic'+type Dynamic = ByteDynamic+-- | get the C-level representation of a 'ByteDynamic' out of 'byteDynamicState'+ctensor = snd . byteDynamicState+-- | alias to 'byteDynamic'+dynamic = byteDynamic+-- | alias to 'byteDynamicState'+dynamicState = byteDynamicState+-- | get the C-level representation of the 'CState' from a 'ByteDynamic' out of 'byteDynamicState'+dynamicStateRef = fst . byteDynamicState++-- | type alias to 'ByteTensor'+type Tensor = ByteTensor+-- | type alias to 'byteAsDynamic'+asDynamic = byteAsDynamic+-- | type alias to 'byteAsStatic'+asStatic = byteAsStatic++-- instance Fractional Word8
+ src/Torch/Types/TH/Char.hs view
@@ -0,0 +1,60 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-}+module Torch.Types.TH.Char where++import Foreign+import Foreign.C.Types+import Foreign (ForeignPtr)+import GHC.TypeLits (Nat)+import GHC.Word+import GHC.Int+import Torch.Types.TH++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++i2hsReal :: Integral i => i -> HsReal+i2hsReal = 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/TH/Double.hs view
@@ -0,0 +1,51 @@+module Torch.Types.TH.Double where++import Foreign.C.Types+import Foreign+import GHC.TypeLits (Nat)+import Torch.Types.TH+import Text.Printf ()++type CTensor = CDoubleTensor+type CStorage = CDoubleStorage++type CReal = CDouble+type CAccReal = CDouble+type HsReal = Double+type HsAccReal = Double++real2acc :: HsReal -> HsAccReal+real2acc = realToFrac++acc2real :: HsAccReal -> HsReal+acc2real = realToFrac++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/TH/Float.hs view
@@ -0,0 +1,57 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-}+module Torch.Types.TH.Float where++import Foreign.C.Types+import Foreign+import GHC.TypeLits (Nat)+import Torch.Types.TH++type CTensor = CFloatTensor+type CStorage = CFloatStorage++-- for nn-package+type CNNState = CState+type CDim = CLLong+type CNNGenerator = CGenerator++type CReal = CFloat+type CAccReal = CDouble+type HsReal = Float+type HsAccReal = Double++hs2cReal :: HsReal -> CReal+hs2cReal = realToFrac++hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = realToFrac++real2acc :: HsReal -> HsAccReal+real2acc = realToFrac++acc2real :: HsAccReal -> HsReal+acc2real = 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/TH/Int.hs view
@@ -0,0 +1,97 @@+-------------------------------------------------------------------------------+-- |+-- Module : Torch.Types.TH.Int+-- Copyright : (c) Sam Stites 2017+-- License : BSD3+-- Maintainer: sam@stites.io+-- Stability : experimental+-- Portability: non-portable+--+-- A package of type aliases to satisfy a backpack Torch.Sig.Types signature.+-------------------------------------------------------------------------------+{-# LANGUAGE DataKinds #-}+module Torch.Types.TH.Int where++import Foreign.C.Types+import Foreign+import GHC.TypeLits (Nat)+import GHC.Int+import Torch.Types.TH++-- | type alias of 'CIntStorage'+type CStorage = CIntStorage+-- | type alias of 'CIntTensor'+type CTensor = CIntTensor++-- type CInt' = CInt++-- | C-level representation of a torch "real" -- the inhabitant of a 'CTensor'. Alias to 'CInt'.+type CReal = CInt+-- | C-level representation of a torch "accreal" -- the accumulating type of a 'CTensor'. Alias to 'CLong'.+type CAccReal = CLong+-- | Hask-level representation of a torch "real" -- the accumulating type of a 'Tensor'. Alias to 'Int32'.+type HsReal = Int32+-- | Hask-level representation of a torch "accreal" -- the accumulating type of a 'Tensor'. Alias to 'Int64'.+type HsAccReal = Int64++-- | convert a real to its accumulating representation+real2acc :: HsReal -> HsAccReal+real2acc = fromIntegral++-- | convert an accumulating value to its base rperesentation+acc2real :: HsAccReal -> HsReal+acc2real = fromIntegral++-- | convert an 'HsReal' to its C-level representation+hs2cReal :: HsReal -> CReal+hs2cReal = fromIntegral++-- | convert an 'HsAccReal' to its C-level representation+hs2cAccReal :: HsAccReal -> CAccReal+hs2cAccReal = fromIntegral++-- | convert a 'CReal' to its Hask-level representation+c2hsReal :: CReal -> HsReal+c2hsReal = fromIntegral++-- | convert a 'CAccReal' to its Hask-level representation+c2hsAccReal :: CAccReal -> HsAccReal+c2hsAccReal = fromIntegral++-- | convert an integral type to its hask-level representation+i2hsReal :: Integral i => i -> HsReal+i2hsReal = fromIntegral++-- | type alias to 'IntStorage'+type Storage = IntStorage+-- | get the C-level representation of a 'IntStorage' out of 'intStorageState'+cstorage = snd . intStorageState+-- | alias to 'intStorage'+storage = intStorage+-- | alias to 'intStorageState'+storageState = intStorageState+-- | get the C-level representation of the 'CState' from a 'IntStorage' out of 'intStorageState'+storageStateRef = fst . intStorageState++-- | type alias to 'IntDynamic'+type Dynamic = IntDynamic+-- | get the C-level representation of a 'IntDynamic' out of 'intDynamicState'+ctensor = snd . intDynamicState+-- | alias to 'intDynamic'+dynamic = intDynamic+-- | alias to 'intDynamicState'+dynamicState = intDynamicState+-- | get the C-level representation of the 'CState' from a 'IntDynamic' out of 'intDynamicState'+dynamicStateRef = fst . intDynamicState++-- | type alias to 'IntTensor'+type Tensor = IntTensor+-- | type alias to 'intAsDynamic'+asDynamic = intAsDynamic+-- | type alias to 'intAsStatic'+asStatic = intAsStatic++-- this is to make indef work with NN code and shouldn't be exported.+-- FIXME: Remove this+-- instance Fractional Int32+
+ src/Torch/Types/TH/Long.hs view
@@ -0,0 +1,50 @@+module Torch.Types.TH.Long where++import Foreign+import Foreign.C.Types+import GHC.TypeLits (Nat)+import Torch.Types.TH++type CTensor = CLongTensor+type CStorage = CLongStorage+type CReal = CLong+type CAccReal = CLong+type HsReal = Integer+type HsAccReal = Integer++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 = 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 where+-- fromRational = truncate
+ src/Torch/Types/TH/Short.hs view
@@ -0,0 +1,54 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE KindSignatures #-}+module Torch.Types.TH.Short where++import Foreign+import Foreign.C.Types+import GHC.TypeLits (Nat)+import GHC.Int+import Torch.Types.TH++type CTensor = CShortTensor+type CStorage = CShortStorage++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/TH/Structs.hs view
@@ -0,0 +1,1032 @@+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+++module Torch.Types.TH.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 {+ char str[64];+ } THDescBuff; -}+++data C'THDescBuff = C'THDescBuff{+ c'THDescBuff'str :: [CChar]+} deriving (Eq,Show)+p'THDescBuff'str p = plusPtr p 0+p'THDescBuff'str :: Ptr (C'THDescBuff) -> Ptr (CChar)+instance Storable C'THDescBuff where+ sizeOf _ = 64+ alignment _ = 1+ peek _p = do+ v0 <- let s0 = div 64 $ sizeOf $ (undefined :: CChar) in peekArray s0 (plusPtr _p 0)+ return $ C'THDescBuff v0+ poke _p (C'THDescBuff v0) = do+ let s0 = div 64 $ sizeOf $ (undefined :: CChar)+ pokeArray (plusPtr _p 0) (take s0 v0)+ return ()++{- typedef struct THAllocator {+ void * (* malloc)(void *, ptrdiff_t);+ void * (* realloc)(void *, void *, ptrdiff_t);+ void (* free)(void *, void *);+ } THAllocator; -}+++++data C'THAllocator = C'THAllocator{+ c'THAllocator'malloc :: FunPtr (Ptr () -> CLong -> Ptr ()),+ c'THAllocator'realloc :: FunPtr (Ptr () -> Ptr () -> CLong -> Ptr ()),+ c'THAllocator'free :: FunPtr (Ptr () -> Ptr () -> IO ())+} deriving (Eq,Show)+p'THAllocator'malloc p = plusPtr p 0+p'THAllocator'malloc :: Ptr (C'THAllocator) -> Ptr (FunPtr (Ptr () -> CLong -> Ptr ()))+p'THAllocator'realloc p = plusPtr p 8+p'THAllocator'realloc :: Ptr (C'THAllocator) -> Ptr (FunPtr (Ptr () -> Ptr () -> CLong -> Ptr ()))+p'THAllocator'free p = plusPtr p 16+p'THAllocator'free :: Ptr (C'THAllocator) -> Ptr (FunPtr (Ptr () -> Ptr () -> IO ()))+instance Storable C'THAllocator where+ sizeOf _ = 24+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 16+ return $ C'THAllocator v0 v1 v2+ poke _p (C'THAllocator v0 v1 v2) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 16 v2+ return ()+++{- typedef struct THGenerator {+ unsigned long the_initial_seed;+ int left;+ int seeded;+ unsigned long next;+ unsigned long state[624];+ double normal_x;+ double normal_y;+ double normal_rho;+ int normal_is_valid;+ } THGenerator; -}+++++++++++data C'THGenerator = C'THGenerator{+ c'THGenerator'the_initial_seed :: CULong,+ c'THGenerator'left :: CInt,+ c'THGenerator'seeded :: CInt,+ c'THGenerator'next :: CULong,+ c'THGenerator'state :: [CULong],+ c'THGenerator'normal_x :: CDouble,+ c'THGenerator'normal_y :: CDouble,+ c'THGenerator'normal_rho :: CDouble,+ c'THGenerator'normal_is_valid :: CInt+} deriving (Eq,Show)+p'THGenerator'the_initial_seed p = plusPtr p 0+p'THGenerator'the_initial_seed :: Ptr (C'THGenerator) -> Ptr (CULong)+p'THGenerator'left p = plusPtr p 8+p'THGenerator'left :: Ptr (C'THGenerator) -> Ptr (CInt)+p'THGenerator'seeded p = plusPtr p 12+p'THGenerator'seeded :: Ptr (C'THGenerator) -> Ptr (CInt)+p'THGenerator'next p = plusPtr p 16+p'THGenerator'next :: Ptr (C'THGenerator) -> Ptr (CULong)+p'THGenerator'state p = plusPtr p 24+p'THGenerator'state :: Ptr (C'THGenerator) -> Ptr (CULong)+p'THGenerator'normal_x p = plusPtr p 5016+p'THGenerator'normal_x :: Ptr (C'THGenerator) -> Ptr (CDouble)+p'THGenerator'normal_y p = plusPtr p 5024+p'THGenerator'normal_y :: Ptr (C'THGenerator) -> Ptr (CDouble)+p'THGenerator'normal_rho p = plusPtr p 5032+p'THGenerator'normal_rho :: Ptr (C'THGenerator) -> Ptr (CDouble)+p'THGenerator'normal_is_valid p = plusPtr p 5040+p'THGenerator'normal_is_valid :: Ptr (C'THGenerator) -> Ptr (CInt)+instance Storable C'THGenerator where+ sizeOf _ = 5048+ alignment _ = 8+ peek _p = do+ v0 <- peekByteOff _p 0+ v1 <- peekByteOff _p 8+ v2 <- peekByteOff _p 12+ v3 <- peekByteOff _p 16+ v4 <- let s4 = div 4992 $ sizeOf $ (undefined :: CULong) in peekArray s4 (plusPtr _p 24)+ v5 <- peekByteOff _p 5016+ v6 <- peekByteOff _p 5024+ v7 <- peekByteOff _p 5032+ v8 <- peekByteOff _p 5040+ return $ C'THGenerator v0 v1 v2 v3 v4 v5 v6 v7 v8+ poke _p (C'THGenerator v0 v1 v2 v3 v4 v5 v6 v7 v8) = do+ pokeByteOff _p 0 v0+ pokeByteOff _p 8 v1+ pokeByteOff _p 12 v2+ pokeByteOff _p 16 v3+ let s4 = div 4992 $ sizeOf $ (undefined :: CULong)+ pokeArray (plusPtr _p 24) (take s4 v4)+ pokeByteOff _p 5016 v5+ pokeByteOff _p 5024 v6+ pokeByteOff _p 5032 v7+ pokeByteOff _p 5040 v8+ return ()+++{- typedef struct THFloatStorage {+ float * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THAllocator * allocator;+ void * allocatorContext;+ struct THFloatStorage * view;+ } THFloatStorage; -}+++++++++data C'THFloatStorage = C'THFloatStorage{+ c'THFloatStorage'data :: Ptr CFloat,+ c'THFloatStorage'size :: CLong,+ c'THFloatStorage'refcount :: CInt,+ c'THFloatStorage'flag :: CChar,+ c'THFloatStorage'allocator :: Ptr C'THAllocator,+ c'THFloatStorage'allocatorContext :: Ptr (),+ c'THFloatStorage'view :: Ptr C'THFloatStorage+} deriving (Eq,Show)+p'THFloatStorage'data p = plusPtr p 0+p'THFloatStorage'data :: Ptr (C'THFloatStorage) -> Ptr (Ptr CFloat)+p'THFloatStorage'size p = plusPtr p 8+p'THFloatStorage'size :: Ptr (C'THFloatStorage) -> Ptr (CLong)+p'THFloatStorage'refcount p = plusPtr p 16+p'THFloatStorage'refcount :: Ptr (C'THFloatStorage) -> Ptr (CInt)+p'THFloatStorage'flag p = plusPtr p 20+p'THFloatStorage'flag :: Ptr (C'THFloatStorage) -> Ptr (CChar)+p'THFloatStorage'allocator p = plusPtr p 24+p'THFloatStorage'allocator :: Ptr (C'THFloatStorage) -> Ptr (Ptr C'THAllocator)+p'THFloatStorage'allocatorContext p = plusPtr p 32+p'THFloatStorage'allocatorContext :: Ptr (C'THFloatStorage) -> Ptr (Ptr ())+p'THFloatStorage'view p = plusPtr p 40+p'THFloatStorage'view :: Ptr (C'THFloatStorage) -> Ptr (Ptr C'THFloatStorage)+instance Storable C'THFloatStorage where+ sizeOf _ = 48+ 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+ return $ C'THFloatStorage v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THFloatStorage v0 v1 v2 v3 v4 v5 v6) = 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+ return ()+++{- typedef struct THFloatTensor {+ long * size;+ long * stride;+ int nDimension;+ THFloatStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THFloatTensor; -}+++++++++data C'THFloatTensor = C'THFloatTensor{+ c'THFloatTensor'size :: Ptr CLong,+ c'THFloatTensor'stride :: Ptr CLong,+ c'THFloatTensor'nDimension :: CInt,+ c'THFloatTensor'storage :: Ptr C'THFloatStorage,+ c'THFloatTensor'storageOffset :: CLong,+ c'THFloatTensor'refcount :: CInt,+ c'THFloatTensor'flag :: CChar+} deriving (Eq,Show)+p'THFloatTensor'size p = plusPtr p 0+p'THFloatTensor'size :: Ptr (C'THFloatTensor) -> Ptr (Ptr CLong)+p'THFloatTensor'stride p = plusPtr p 8+p'THFloatTensor'stride :: Ptr (C'THFloatTensor) -> Ptr (Ptr CLong)+p'THFloatTensor'nDimension p = plusPtr p 16+p'THFloatTensor'nDimension :: Ptr (C'THFloatTensor) -> Ptr (CInt)+p'THFloatTensor'storage p = plusPtr p 24+p'THFloatTensor'storage :: Ptr (C'THFloatTensor) -> Ptr (Ptr C'THFloatStorage)+p'THFloatTensor'storageOffset p = plusPtr p 32+p'THFloatTensor'storageOffset :: Ptr (C'THFloatTensor) -> Ptr (CLong)+p'THFloatTensor'refcount p = plusPtr p 40+p'THFloatTensor'refcount :: Ptr (C'THFloatTensor) -> Ptr (CInt)+p'THFloatTensor'flag p = plusPtr p 44+p'THFloatTensor'flag :: Ptr (C'THFloatTensor) -> Ptr (CChar)+instance Storable C'THFloatTensor 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'THFloatTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THFloatTensor 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 THDoubleStorage {+ double * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THAllocator * allocator;+ void * allocatorContext;+ struct THDoubleStorage * view;+ } THDoubleStorage; -}+++++++++data C'THDoubleStorage = C'THDoubleStorage{+ c'THDoubleStorage'data :: Ptr CDouble,+ c'THDoubleStorage'size :: CLong,+ c'THDoubleStorage'refcount :: CInt,+ c'THDoubleStorage'flag :: CChar,+ c'THDoubleStorage'allocator :: Ptr C'THAllocator,+ c'THDoubleStorage'allocatorContext :: Ptr (),+ c'THDoubleStorage'view :: Ptr C'THDoubleStorage+} deriving (Eq,Show)+p'THDoubleStorage'data p = plusPtr p 0+p'THDoubleStorage'data :: Ptr (C'THDoubleStorage) -> Ptr (Ptr CDouble)+p'THDoubleStorage'size p = plusPtr p 8+p'THDoubleStorage'size :: Ptr (C'THDoubleStorage) -> Ptr (CLong)+p'THDoubleStorage'refcount p = plusPtr p 16+p'THDoubleStorage'refcount :: Ptr (C'THDoubleStorage) -> Ptr (CInt)+p'THDoubleStorage'flag p = plusPtr p 20+p'THDoubleStorage'flag :: Ptr (C'THDoubleStorage) -> Ptr (CChar)+p'THDoubleStorage'allocator p = plusPtr p 24+p'THDoubleStorage'allocator :: Ptr (C'THDoubleStorage) -> Ptr (Ptr C'THAllocator)+p'THDoubleStorage'allocatorContext p = plusPtr p 32+p'THDoubleStorage'allocatorContext :: Ptr (C'THDoubleStorage) -> Ptr (Ptr ())+p'THDoubleStorage'view p = plusPtr p 40+p'THDoubleStorage'view :: Ptr (C'THDoubleStorage) -> Ptr (Ptr C'THDoubleStorage)+instance Storable C'THDoubleStorage where+ sizeOf _ = 48+ 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+ return $ C'THDoubleStorage v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THDoubleStorage v0 v1 v2 v3 v4 v5 v6) = 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+ return ()+++{- typedef struct THDoubleTensor {+ long * size;+ long * stride;+ int nDimension;+ THDoubleStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THDoubleTensor; -}+++++++++data C'THDoubleTensor = C'THDoubleTensor{+ c'THDoubleTensor'size :: Ptr CLong,+ c'THDoubleTensor'stride :: Ptr CLong,+ c'THDoubleTensor'nDimension :: CInt,+ c'THDoubleTensor'storage :: Ptr C'THDoubleStorage,+ c'THDoubleTensor'storageOffset :: CLong,+ c'THDoubleTensor'refcount :: CInt,+ c'THDoubleTensor'flag :: CChar+} deriving (Eq,Show)+p'THDoubleTensor'size p = plusPtr p 0+p'THDoubleTensor'size :: Ptr (C'THDoubleTensor) -> Ptr (Ptr CLong)+p'THDoubleTensor'stride p = plusPtr p 8+p'THDoubleTensor'stride :: Ptr (C'THDoubleTensor) -> Ptr (Ptr CLong)+p'THDoubleTensor'nDimension p = plusPtr p 16+p'THDoubleTensor'nDimension :: Ptr (C'THDoubleTensor) -> Ptr (CInt)+p'THDoubleTensor'storage p = plusPtr p 24+p'THDoubleTensor'storage :: Ptr (C'THDoubleTensor) -> Ptr (Ptr C'THDoubleStorage)+p'THDoubleTensor'storageOffset p = plusPtr p 32+p'THDoubleTensor'storageOffset :: Ptr (C'THDoubleTensor) -> Ptr (CLong)+p'THDoubleTensor'refcount p = plusPtr p 40+p'THDoubleTensor'refcount :: Ptr (C'THDoubleTensor) -> Ptr (CInt)+p'THDoubleTensor'flag p = plusPtr p 44+p'THDoubleTensor'flag :: Ptr (C'THDoubleTensor) -> Ptr (CChar)+instance Storable C'THDoubleTensor 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'THDoubleTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THDoubleTensor 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 THIntStorage {+ int * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THAllocator * allocator;+ void * allocatorContext;+ struct THIntStorage * view;+ } THIntStorage; -}+++++++++data C'THIntStorage = C'THIntStorage{+ c'THIntStorage'data :: Ptr CInt,+ c'THIntStorage'size :: CLong,+ c'THIntStorage'refcount :: CInt,+ c'THIntStorage'flag :: CChar,+ c'THIntStorage'allocator :: Ptr C'THAllocator,+ c'THIntStorage'allocatorContext :: Ptr (),+ c'THIntStorage'view :: Ptr C'THIntStorage+} deriving (Eq,Show)+p'THIntStorage'data p = plusPtr p 0+p'THIntStorage'data :: Ptr (C'THIntStorage) -> Ptr (Ptr CInt)+p'THIntStorage'size p = plusPtr p 8+p'THIntStorage'size :: Ptr (C'THIntStorage) -> Ptr (CLong)+p'THIntStorage'refcount p = plusPtr p 16+p'THIntStorage'refcount :: Ptr (C'THIntStorage) -> Ptr (CInt)+p'THIntStorage'flag p = plusPtr p 20+p'THIntStorage'flag :: Ptr (C'THIntStorage) -> Ptr (CChar)+p'THIntStorage'allocator p = plusPtr p 24+p'THIntStorage'allocator :: Ptr (C'THIntStorage) -> Ptr (Ptr C'THAllocator)+p'THIntStorage'allocatorContext p = plusPtr p 32+p'THIntStorage'allocatorContext :: Ptr (C'THIntStorage) -> Ptr (Ptr ())+p'THIntStorage'view p = plusPtr p 40+p'THIntStorage'view :: Ptr (C'THIntStorage) -> Ptr (Ptr C'THIntStorage)+instance Storable C'THIntStorage where+ sizeOf _ = 48+ 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+ return $ C'THIntStorage v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THIntStorage v0 v1 v2 v3 v4 v5 v6) = 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+ return ()+++{- typedef struct THIntTensor {+ long * size;+ long * stride;+ int nDimension;+ THIntStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THIntTensor; -}+++++++++data C'THIntTensor = C'THIntTensor{+ c'THIntTensor'size :: Ptr CLong,+ c'THIntTensor'stride :: Ptr CLong,+ c'THIntTensor'nDimension :: CInt,+ c'THIntTensor'storage :: Ptr C'THIntStorage,+ c'THIntTensor'storageOffset :: CLong,+ c'THIntTensor'refcount :: CInt,+ c'THIntTensor'flag :: CChar+} deriving (Eq,Show)+p'THIntTensor'size p = plusPtr p 0+p'THIntTensor'size :: Ptr (C'THIntTensor) -> Ptr (Ptr CLong)+p'THIntTensor'stride p = plusPtr p 8+p'THIntTensor'stride :: Ptr (C'THIntTensor) -> Ptr (Ptr CLong)+p'THIntTensor'nDimension p = plusPtr p 16+p'THIntTensor'nDimension :: Ptr (C'THIntTensor) -> Ptr (CInt)+p'THIntTensor'storage p = plusPtr p 24+p'THIntTensor'storage :: Ptr (C'THIntTensor) -> Ptr (Ptr C'THIntStorage)+p'THIntTensor'storageOffset p = plusPtr p 32+p'THIntTensor'storageOffset :: Ptr (C'THIntTensor) -> Ptr (CLong)+p'THIntTensor'refcount p = plusPtr p 40+p'THIntTensor'refcount :: Ptr (C'THIntTensor) -> Ptr (CInt)+p'THIntTensor'flag p = plusPtr p 44+p'THIntTensor'flag :: Ptr (C'THIntTensor) -> Ptr (CChar)+instance Storable C'THIntTensor 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'THIntTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THIntTensor 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 THCharStorage {+ char * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THAllocator * allocator;+ void * allocatorContext;+ struct THCharStorage * view;+ } THCharStorage; -}+++++++++data C'THCharStorage = C'THCharStorage{+ c'THCharStorage'data :: CString,+ c'THCharStorage'size :: CLong,+ c'THCharStorage'refcount :: CInt,+ c'THCharStorage'flag :: CChar,+ c'THCharStorage'allocator :: Ptr C'THAllocator,+ c'THCharStorage'allocatorContext :: Ptr (),+ c'THCharStorage'view :: Ptr C'THCharStorage+} deriving (Eq,Show)+p'THCharStorage'data p = plusPtr p 0+p'THCharStorage'data :: Ptr (C'THCharStorage) -> Ptr (CString)+p'THCharStorage'size p = plusPtr p 8+p'THCharStorage'size :: Ptr (C'THCharStorage) -> Ptr (CLong)+p'THCharStorage'refcount p = plusPtr p 16+p'THCharStorage'refcount :: Ptr (C'THCharStorage) -> Ptr (CInt)+p'THCharStorage'flag p = plusPtr p 20+p'THCharStorage'flag :: Ptr (C'THCharStorage) -> Ptr (CChar)+p'THCharStorage'allocator p = plusPtr p 24+p'THCharStorage'allocator :: Ptr (C'THCharStorage) -> Ptr (Ptr C'THAllocator)+p'THCharStorage'allocatorContext p = plusPtr p 32+p'THCharStorage'allocatorContext :: Ptr (C'THCharStorage) -> Ptr (Ptr ())+p'THCharStorage'view p = plusPtr p 40+p'THCharStorage'view :: Ptr (C'THCharStorage) -> Ptr (Ptr C'THCharStorage)+instance Storable C'THCharStorage where+ sizeOf _ = 48+ 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+ return $ C'THCharStorage v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THCharStorage v0 v1 v2 v3 v4 v5 v6) = 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+ return ()+++{- typedef struct THCharTensor {+ long * size;+ long * stride;+ int nDimension;+ THCharStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THCharTensor; -}+++++++++data C'THCharTensor = C'THCharTensor{+ c'THCharTensor'size :: Ptr CLong,+ c'THCharTensor'stride :: Ptr CLong,+ c'THCharTensor'nDimension :: CInt,+ c'THCharTensor'storage :: Ptr C'THCharStorage,+ c'THCharTensor'storageOffset :: CLong,+ c'THCharTensor'refcount :: CInt,+ c'THCharTensor'flag :: CChar+} deriving (Eq,Show)+p'THCharTensor'size p = plusPtr p 0+p'THCharTensor'size :: Ptr (C'THCharTensor) -> Ptr (Ptr CLong)+p'THCharTensor'stride p = plusPtr p 8+p'THCharTensor'stride :: Ptr (C'THCharTensor) -> Ptr (Ptr CLong)+p'THCharTensor'nDimension p = plusPtr p 16+p'THCharTensor'nDimension :: Ptr (C'THCharTensor) -> Ptr (CInt)+p'THCharTensor'storage p = plusPtr p 24+p'THCharTensor'storage :: Ptr (C'THCharTensor) -> Ptr (Ptr C'THCharStorage)+p'THCharTensor'storageOffset p = plusPtr p 32+p'THCharTensor'storageOffset :: Ptr (C'THCharTensor) -> Ptr (CLong)+p'THCharTensor'refcount p = plusPtr p 40+p'THCharTensor'refcount :: Ptr (C'THCharTensor) -> Ptr (CInt)+p'THCharTensor'flag p = plusPtr p 44+p'THCharTensor'flag :: Ptr (C'THCharTensor) -> Ptr (CChar)+instance Storable C'THCharTensor 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'THCharTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THCharTensor 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 THByteStorage {+ unsigned char * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THAllocator * allocator;+ void * allocatorContext;+ struct THByteStorage * view;+ } THByteStorage; -}+++++++++data C'THByteStorage = C'THByteStorage{+ c'THByteStorage'data :: Ptr CUChar,+ c'THByteStorage'size :: CLong,+ c'THByteStorage'refcount :: CInt,+ c'THByteStorage'flag :: CChar,+ c'THByteStorage'allocator :: Ptr C'THAllocator,+ c'THByteStorage'allocatorContext :: Ptr (),+ c'THByteStorage'view :: Ptr C'THByteStorage+} deriving (Eq,Show)+p'THByteStorage'data p = plusPtr p 0+p'THByteStorage'data :: Ptr (C'THByteStorage) -> Ptr (Ptr CUChar)+p'THByteStorage'size p = plusPtr p 8+p'THByteStorage'size :: Ptr (C'THByteStorage) -> Ptr (CLong)+p'THByteStorage'refcount p = plusPtr p 16+p'THByteStorage'refcount :: Ptr (C'THByteStorage) -> Ptr (CInt)+p'THByteStorage'flag p = plusPtr p 20+p'THByteStorage'flag :: Ptr (C'THByteStorage) -> Ptr (CChar)+p'THByteStorage'allocator p = plusPtr p 24+p'THByteStorage'allocator :: Ptr (C'THByteStorage) -> Ptr (Ptr C'THAllocator)+p'THByteStorage'allocatorContext p = plusPtr p 32+p'THByteStorage'allocatorContext :: Ptr (C'THByteStorage) -> Ptr (Ptr ())+p'THByteStorage'view p = plusPtr p 40+p'THByteStorage'view :: Ptr (C'THByteStorage) -> Ptr (Ptr C'THByteStorage)+instance Storable C'THByteStorage where+ sizeOf _ = 48+ 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+ return $ C'THByteStorage v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THByteStorage v0 v1 v2 v3 v4 v5 v6) = 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+ return ()+++{- typedef struct THByteTensor {+ long * size;+ long * stride;+ int nDimension;+ THByteStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THByteTensor; -}+++++++++data C'THByteTensor = C'THByteTensor{+ c'THByteTensor'size :: Ptr CLong,+ c'THByteTensor'stride :: Ptr CLong,+ c'THByteTensor'nDimension :: CInt,+ c'THByteTensor'storage :: Ptr C'THByteStorage,+ c'THByteTensor'storageOffset :: CLong,+ c'THByteTensor'refcount :: CInt,+ c'THByteTensor'flag :: CChar+} deriving (Eq,Show)+p'THByteTensor'size p = plusPtr p 0+p'THByteTensor'size :: Ptr (C'THByteTensor) -> Ptr (Ptr CLong)+p'THByteTensor'stride p = plusPtr p 8+p'THByteTensor'stride :: Ptr (C'THByteTensor) -> Ptr (Ptr CLong)+p'THByteTensor'nDimension p = plusPtr p 16+p'THByteTensor'nDimension :: Ptr (C'THByteTensor) -> Ptr (CInt)+p'THByteTensor'storage p = plusPtr p 24+p'THByteTensor'storage :: Ptr (C'THByteTensor) -> Ptr (Ptr C'THByteStorage)+p'THByteTensor'storageOffset p = plusPtr p 32+p'THByteTensor'storageOffset :: Ptr (C'THByteTensor) -> Ptr (CLong)+p'THByteTensor'refcount p = plusPtr p 40+p'THByteTensor'refcount :: Ptr (C'THByteTensor) -> Ptr (CInt)+p'THByteTensor'flag p = plusPtr p 44+p'THByteTensor'flag :: Ptr (C'THByteTensor) -> Ptr (CChar)+instance Storable C'THByteTensor 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'THByteTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THByteTensor 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 THLongStorage {+ long * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THAllocator * allocator;+ void * allocatorContext;+ struct THByteStorage * view;+ } THLongStorage; -}+++++++++data C'THLongStorage = C'THLongStorage{+ c'THLongStorage'data :: Ptr CLong,+ c'THLongStorage'size :: CLong,+ c'THLongStorage'refcount :: CInt,+ c'THLongStorage'flag :: CChar,+ c'THLongStorage'allocator :: Ptr C'THAllocator,+ c'THLongStorage'allocatorContext :: Ptr (),+ c'THLongStorage'view :: Ptr C'THByteStorage+} deriving (Eq,Show)+p'THLongStorage'data p = plusPtr p 0+p'THLongStorage'data :: Ptr (C'THLongStorage) -> Ptr (Ptr CLong)+p'THLongStorage'size p = plusPtr p 8+p'THLongStorage'size :: Ptr (C'THLongStorage) -> Ptr (CLong)+p'THLongStorage'refcount p = plusPtr p 16+p'THLongStorage'refcount :: Ptr (C'THLongStorage) -> Ptr (CInt)+p'THLongStorage'flag p = plusPtr p 20+p'THLongStorage'flag :: Ptr (C'THLongStorage) -> Ptr (CChar)+p'THLongStorage'allocator p = plusPtr p 24+p'THLongStorage'allocator :: Ptr (C'THLongStorage) -> Ptr (Ptr C'THAllocator)+p'THLongStorage'allocatorContext p = plusPtr p 32+p'THLongStorage'allocatorContext :: Ptr (C'THLongStorage) -> Ptr (Ptr ())+p'THLongStorage'view p = plusPtr p 40+p'THLongStorage'view :: Ptr (C'THLongStorage) -> Ptr (Ptr C'THByteStorage)+instance Storable C'THLongStorage where+ sizeOf _ = 48+ 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+ return $ C'THLongStorage v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THLongStorage v0 v1 v2 v3 v4 v5 v6) = 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+ return ()+++{- typedef struct THLongTensor {+ long * size;+ long * stride;+ int nDimension;+ THLongStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THLongTensor; -}+++++++++data C'THLongTensor = C'THLongTensor{+ c'THLongTensor'size :: Ptr CLong,+ c'THLongTensor'stride :: Ptr CLong,+ c'THLongTensor'nDimension :: CInt,+ c'THLongTensor'storage :: Ptr C'THLongStorage,+ c'THLongTensor'storageOffset :: CLong,+ c'THLongTensor'refcount :: CInt,+ c'THLongTensor'flag :: CChar+} deriving (Eq,Show)+p'THLongTensor'size p = plusPtr p 0+p'THLongTensor'size :: Ptr (C'THLongTensor) -> Ptr (Ptr CLong)+p'THLongTensor'stride p = plusPtr p 8+p'THLongTensor'stride :: Ptr (C'THLongTensor) -> Ptr (Ptr CLong)+p'THLongTensor'nDimension p = plusPtr p 16+p'THLongTensor'nDimension :: Ptr (C'THLongTensor) -> Ptr (CInt)+p'THLongTensor'storage p = plusPtr p 24+p'THLongTensor'storage :: Ptr (C'THLongTensor) -> Ptr (Ptr C'THLongStorage)+p'THLongTensor'storageOffset p = plusPtr p 32+p'THLongTensor'storageOffset :: Ptr (C'THLongTensor) -> Ptr (CLong)+p'THLongTensor'refcount p = plusPtr p 40+p'THLongTensor'refcount :: Ptr (C'THLongTensor) -> Ptr (CInt)+p'THLongTensor'flag p = plusPtr p 44+p'THLongTensor'flag :: Ptr (C'THLongTensor) -> Ptr (CChar)+instance Storable C'THLongTensor 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'THLongTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THLongTensor 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 THShortStorage {+ short * data;+ ptrdiff_t size;+ int refcount;+ char flag;+ THAllocator * allocator;+ void * allocatorContext;+ struct THByteStorage * view;+ } THShortStorage; -}+++++++++data C'THShortStorage = C'THShortStorage{+ c'THShortStorage'data :: Ptr CShort,+ c'THShortStorage'size :: CLong,+ c'THShortStorage'refcount :: CInt,+ c'THShortStorage'flag :: CChar,+ c'THShortStorage'allocator :: Ptr C'THAllocator,+ c'THShortStorage'allocatorContext :: Ptr (),+ c'THShortStorage'view :: Ptr C'THByteStorage+} deriving (Eq,Show)+p'THShortStorage'data p = plusPtr p 0+p'THShortStorage'data :: Ptr (C'THShortStorage) -> Ptr (Ptr CShort)+p'THShortStorage'size p = plusPtr p 8+p'THShortStorage'size :: Ptr (C'THShortStorage) -> Ptr (CLong)+p'THShortStorage'refcount p = plusPtr p 16+p'THShortStorage'refcount :: Ptr (C'THShortStorage) -> Ptr (CInt)+p'THShortStorage'flag p = plusPtr p 20+p'THShortStorage'flag :: Ptr (C'THShortStorage) -> Ptr (CChar)+p'THShortStorage'allocator p = plusPtr p 24+p'THShortStorage'allocator :: Ptr (C'THShortStorage) -> Ptr (Ptr C'THAllocator)+p'THShortStorage'allocatorContext p = plusPtr p 32+p'THShortStorage'allocatorContext :: Ptr (C'THShortStorage) -> Ptr (Ptr ())+p'THShortStorage'view p = plusPtr p 40+p'THShortStorage'view :: Ptr (C'THShortStorage) -> Ptr (Ptr C'THByteStorage)+instance Storable C'THShortStorage where+ sizeOf _ = 48+ 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+ return $ C'THShortStorage v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THShortStorage v0 v1 v2 v3 v4 v5 v6) = 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+ return ()+++{- typedef struct THShortTensor {+ long * size;+ long * stride;+ int nDimension;+ THShortStorage * storage;+ ptrdiff_t storageOffset;+ int refcount;+ char flag;+ } THShortTensor; -}+++++++++data C'THShortTensor = C'THShortTensor{+ c'THShortTensor'size :: Ptr CLong,+ c'THShortTensor'stride :: Ptr CLong,+ c'THShortTensor'nDimension :: CInt,+ c'THShortTensor'storage :: Ptr C'THShortStorage,+ c'THShortTensor'storageOffset :: CLong,+ c'THShortTensor'refcount :: CInt,+ c'THShortTensor'flag :: CChar+} deriving (Eq,Show)+p'THShortTensor'size p = plusPtr p 0+p'THShortTensor'size :: Ptr (C'THShortTensor) -> Ptr (Ptr CLong)+p'THShortTensor'stride p = plusPtr p 8+p'THShortTensor'stride :: Ptr (C'THShortTensor) -> Ptr (Ptr CLong)+p'THShortTensor'nDimension p = plusPtr p 16+p'THShortTensor'nDimension :: Ptr (C'THShortTensor) -> Ptr (CInt)+p'THShortTensor'storage p = plusPtr p 24+p'THShortTensor'storage :: Ptr (C'THShortTensor) -> Ptr (Ptr C'THShortStorage)+p'THShortTensor'storageOffset p = plusPtr p 32+p'THShortTensor'storageOffset :: Ptr (C'THShortTensor) -> Ptr (CLong)+p'THShortTensor'refcount p = plusPtr p 40+p'THShortTensor'refcount :: Ptr (C'THShortTensor) -> Ptr (CInt)+p'THShortTensor'flag p = plusPtr p 44+p'THShortTensor'flag :: Ptr (C'THShortTensor) -> Ptr (CChar)+instance Storable C'THShortTensor 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'THShortTensor v0 v1 v2 v3 v4 v5 v6+ poke _p (C'THShortTensor 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 ()++