-- GENERATED by C->Haskell Compiler, version 0.28.6 Switcheroo, 25 November 2017 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}
{-# LANGUAGE CPP                      #-}
{-# LANGUAGE EmptyDataDecls           #-}
{-# LANGUAGE ForeignFunctionInterface #-}
-- |
-- Module      : Foreign.CUDA.BLAS.Internal.Types
-- Copyright   : [2014..2017] Trevor L. McDonell
-- License     : BSD3
--
-- Maintainer  : Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>
-- Stability   : experimental
-- Portability : non-portable (GHC extensions)
--

module Foreign.CUDA.BLAS.Internal.Types
  where
import qualified Foreign.Ptr as C2HSImp



import Prelude                                            hiding ( Either(..) )
import Foreign.Ptr



{-# LINE 21 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}



-- | An opaque handle to the cuBLAS library context, which is passed to all
-- library function calls.
--
-- <http://docs.nvidia.com/cuda/cublas/index.html#cublashandle_t>
--
newtype Handle = Handle { useHandle :: ((C2HSImp.Ptr ()))}


-- | Indicates which operation needs to be performed with a dense matrix.
--
--   * @N@: no transpose selected
--   * @T@: transpose operation
--   * @C@: conjugate transpose
--
-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasoperation_t>
--
data Operation = N
               | T
               | C
  deriving (Eq,Show)
instance Enum Operation where
  succ N = T
  succ T = C
  succ C = error "Operation.succ: C has no successor"

  pred T = N
  pred C = T
  pred N = error "Operation.pred: N has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from C

  fromEnum N = 0
  fromEnum T = 1
  fromEnum C = 2

  toEnum 0 = N
  toEnum 1 = T
  toEnum 2 = C
  toEnum unmatched = error ("Operation.toEnum: Cannot match " ++ show unmatched)

{-# LINE 42 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}



-- | Indicates which part, upper or lower, of a dense matrix was filled and
-- consequently should be used by the function.
--
-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasfillmode_t>
--
data Fill = Lower
          | Upper
  deriving (Eq,Show)
instance Enum Fill where
  succ Lower = Upper
  succ Upper = error "Fill.succ: Upper has no successor"

  pred Upper = Lower
  pred Lower = error "Fill.pred: Lower has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from Upper

  fromEnum Lower = 0
  fromEnum Upper = 1

  toEnum 0 = Lower
  toEnum 1 = Upper
  toEnum unmatched = error ("Fill.toEnum: Cannot match " ++ show unmatched)

{-# LINE 52 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}



-- | Indicates whether the main diagonal of a dense matrix is unity and
-- consequently should not be be touched or modified by the function.
--
-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasdiagtype_t>
--
data Diagonal = NonUnit
              | Unit
  deriving (Eq,Show)
instance Enum Diagonal where
  succ NonUnit = Unit
  succ Unit = error "Diagonal.succ: Unit has no successor"

  pred Unit = NonUnit
  pred NonUnit = error "Diagonal.pred: NonUnit has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from Unit

  fromEnum NonUnit = 0
  fromEnum Unit = 1

  toEnum 0 = NonUnit
  toEnum 1 = Unit
  toEnum unmatched = error ("Diagonal.toEnum: Cannot match " ++ show unmatched)

{-# LINE 62 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}



-- | Indicates whether the dense matrix is on the lift or right side in the
-- matrix equation solved by a particular function.
--
-- <http://docs.nvidia.com/cuda/cublas/index.html#cublassidemode_t>
--
data Side = Left
          | Right
  deriving (Eq,Show)
instance Enum Side where
  succ Left = Right
  succ Right = error "Side.succ: Right has no successor"

  pred Right = Left
  pred Left = error "Side.pred: Left has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from Right

  fromEnum Left = 0
  fromEnum Right = 1

  toEnum 0 = Left
  toEnum 1 = Right
  toEnum unmatched = error ("Side.toEnum: Cannot match " ++ show unmatched)

{-# LINE 72 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}



-- | For functions which take scalar value arguments, determines whether those
-- values are passed by reference on the host or device.
--
-- <http://docs.nvidia.com/cuda/cublas/index.html#cublaspointermode_t>
--
data PointerMode = Host
                 | Device
  deriving (Eq,Show)
instance Enum PointerMode where
  succ Host = Device
  succ Device = error "PointerMode.succ: Device has no successor"

  pred Device = Host
  pred Host = error "PointerMode.pred: Host has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from Device

  fromEnum Host = 0
  fromEnum Device = 1

  toEnum 0 = Host
  toEnum 1 = Device
  toEnum unmatched = error ("PointerMode.toEnum: Cannot match " ++ show unmatched)

{-# LINE 82 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}



-- | Determines whether cuBLAS routines can alternate implementations which make
-- use of atomic instructions.
--
-- <http://docs.nvidia.com/cuda/cublas/index.html#cublasatomicsmode_t>
--
data AtomicsMode = NotAllowed
                 | Allowed
  deriving (Eq,Show)
instance Enum AtomicsMode where
  succ NotAllowed = Allowed
  succ Allowed = error "AtomicsMode.succ: Allowed has no successor"

  pred Allowed = NotAllowed
  pred NotAllowed = error "AtomicsMode.pred: NotAllowed has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from Allowed

  fromEnum NotAllowed = 0
  fromEnum Allowed = 1

  toEnum 0 = NotAllowed
  toEnum 1 = Allowed
  toEnum unmatched = error ("AtomicsMode.toEnum: Cannot match " ++ show unmatched)

{-# LINE 92 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}



-- | Used to specify the type of data underlying a @void*@ pointer. For example,
-- it is used in the routine <http://docs.nvidia.com/cuda/cublas/index.html#cublas-gemmEx ?gemmEx>.
--
-- <http://docs.nvidia.com/cuda/cublas/index.html#cuda_datatype_t>
--
data Type = R32f
          | R64f
          | R16f
          | R8i
          | C32f
          | C64f
          | C16f
          | C8i
          | R8u
          | C8u
          | R32i
          | C32i
          | R32u
          | C32u
  deriving (Eq,Show)
instance Enum Type where
  succ R32f = R64f
  succ R64f = R16f
  succ R16f = R8i
  succ R8i = C32f
  succ C32f = C64f
  succ C64f = C16f
  succ C16f = C8i
  succ C8i = R8u
  succ R8u = C8u
  succ C8u = R32i
  succ R32i = C32i
  succ C32i = R32u
  succ R32u = C32u
  succ C32u = error "Type.succ: C32u has no successor"

  pred R64f = R32f
  pred R16f = R64f
  pred R8i = R16f
  pred C32f = R8i
  pred C64f = C32f
  pred C16f = C64f
  pred C8i = C16f
  pred R8u = C8i
  pred C8u = R8u
  pred R32i = C8u
  pred C32i = R32i
  pred R32u = C32i
  pred C32u = R32u
  pred R32f = error "Type.pred: R32f has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from C32u

  fromEnum R32f = 0
  fromEnum R64f = 1
  fromEnum R16f = 2
  fromEnum R8i = 3
  fromEnum C32f = 4
  fromEnum C64f = 5
  fromEnum C16f = 6
  fromEnum C8i = 7
  fromEnum R8u = 8
  fromEnum C8u = 9
  fromEnum R32i = 10
  fromEnum C32i = 11
  fromEnum R32u = 12
  fromEnum C32u = 13

  toEnum 0 = R32f
  toEnum 1 = R64f
  toEnum 2 = R16f
  toEnum 3 = R8i
  toEnum 4 = C32f
  toEnum 5 = C64f
  toEnum 6 = C16f
  toEnum 7 = C8i
  toEnum 8 = R8u
  toEnum 9 = C8u
  toEnum 10 = R32i
  toEnum 11 = C32i
  toEnum 12 = R32u
  toEnum 13 = C32u
  toEnum unmatched = error ("Type.toEnum: Cannot match " ++ show unmatched)

{-# LINE 115 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}



-- | Used to run <http://docs.nvidia.com/cuda/cublas/index.html#cublas-GemmEx gemmEx>
-- with a specific, yet completely unspecified, algorithm.
--
data GemmAlgorithm = CUBLAS_GEMM_DFALT
                   | GemmDefault
                   | GemmAlgo0
                   | GemmAlgo1
                   | GemmAlgo2
                   | GemmAlgo3
                   | GemmAlgo4
                   | GemmAlgo5
                   | GemmAlgo6
                   | GemmAlgo7
                   | GemmAlgo8
                   | GemmAlgo9
                   | GemmAlgo10
                   | GemmAlgo11
                   | GemmAlgo12
                   | GemmAlgo13
                   | GemmAlgo14
                   | GemmAlgo15
                   | GemmAlgo16
                   | GemmAlgo17
                   | GemmAlgo18
                   | GemmAlgo19
                   | GemmAlgo20
                   | GemmAlgo21
                   | GemmAlgo22
                   | GemmAlgo23
                   | GemmDefaultTensorOp
                   | GemmDfaltTensorOp
                   | GemmAlgo0TensorOp
                   | GemmAlgo1TensorOp
                   | GemmAlgo2TensorOp
                   | GemmAlgo3TensorOp
                   | GemmAlgo4TensorOp
                   | GemmAlgo5TensorOp
                   | GemmAlgo6TensorOp
                   | GemmAlgo7TensorOp
                   | GemmAlgo8TensorOp
                   | GemmAlgo9TensorOp
                   | GemmAlgo10TensorOp
                   | GemmAlgo11TensorOp
                   | GemmAlgo12TensorOp
                   | GemmAlgo13TensorOp
                   | GemmAlgo14TensorOp
                   | GemmAlgo15TensorOp
  deriving (Eq,Show)
instance Enum GemmAlgorithm where
  succ CUBLAS_GEMM_DFALT = GemmAlgo0
  succ GemmDefault = GemmAlgo0
  succ GemmAlgo0 = GemmAlgo1
  succ GemmAlgo1 = GemmAlgo2
  succ GemmAlgo2 = GemmAlgo3
  succ GemmAlgo3 = GemmAlgo4
  succ GemmAlgo4 = GemmAlgo5
  succ GemmAlgo5 = GemmAlgo6
  succ GemmAlgo6 = GemmAlgo7
  succ GemmAlgo7 = GemmAlgo8
  succ GemmAlgo8 = GemmAlgo9
  succ GemmAlgo9 = GemmAlgo10
  succ GemmAlgo10 = GemmAlgo11
  succ GemmAlgo11 = GemmAlgo12
  succ GemmAlgo12 = GemmAlgo13
  succ GemmAlgo13 = GemmAlgo14
  succ GemmAlgo14 = GemmAlgo15
  succ GemmAlgo15 = GemmAlgo16
  succ GemmAlgo16 = GemmAlgo17
  succ GemmAlgo17 = GemmAlgo18
  succ GemmAlgo18 = GemmAlgo19
  succ GemmAlgo19 = GemmAlgo20
  succ GemmAlgo20 = GemmAlgo21
  succ GemmAlgo21 = GemmAlgo22
  succ GemmAlgo22 = GemmAlgo23
  succ GemmAlgo23 = GemmDefaultTensorOp
  succ GemmDefaultTensorOp = GemmAlgo0TensorOp
  succ GemmDfaltTensorOp = GemmAlgo0TensorOp
  succ GemmAlgo0TensorOp = GemmAlgo1TensorOp
  succ GemmAlgo1TensorOp = GemmAlgo2TensorOp
  succ GemmAlgo2TensorOp = GemmAlgo3TensorOp
  succ GemmAlgo3TensorOp = GemmAlgo4TensorOp
  succ GemmAlgo4TensorOp = GemmAlgo5TensorOp
  succ GemmAlgo5TensorOp = GemmAlgo6TensorOp
  succ GemmAlgo6TensorOp = GemmAlgo7TensorOp
  succ GemmAlgo7TensorOp = GemmAlgo8TensorOp
  succ GemmAlgo8TensorOp = GemmAlgo9TensorOp
  succ GemmAlgo9TensorOp = GemmAlgo10TensorOp
  succ GemmAlgo10TensorOp = GemmAlgo11TensorOp
  succ GemmAlgo11TensorOp = GemmAlgo12TensorOp
  succ GemmAlgo12TensorOp = GemmAlgo13TensorOp
  succ GemmAlgo13TensorOp = GemmAlgo14TensorOp
  succ GemmAlgo14TensorOp = GemmAlgo15TensorOp
  succ GemmAlgo15TensorOp = error "GemmAlgorithm.succ: GemmAlgo15TensorOp has no successor"

  pred GemmAlgo0 = CUBLAS_GEMM_DFALT
  pred GemmAlgo1 = GemmAlgo0
  pred GemmAlgo2 = GemmAlgo1
  pred GemmAlgo3 = GemmAlgo2
  pred GemmAlgo4 = GemmAlgo3
  pred GemmAlgo5 = GemmAlgo4
  pred GemmAlgo6 = GemmAlgo5
  pred GemmAlgo7 = GemmAlgo6
  pred GemmAlgo8 = GemmAlgo7
  pred GemmAlgo9 = GemmAlgo8
  pred GemmAlgo10 = GemmAlgo9
  pred GemmAlgo11 = GemmAlgo10
  pred GemmAlgo12 = GemmAlgo11
  pred GemmAlgo13 = GemmAlgo12
  pred GemmAlgo14 = GemmAlgo13
  pred GemmAlgo15 = GemmAlgo14
  pred GemmAlgo16 = GemmAlgo15
  pred GemmAlgo17 = GemmAlgo16
  pred GemmAlgo18 = GemmAlgo17
  pred GemmAlgo19 = GemmAlgo18
  pred GemmAlgo20 = GemmAlgo19
  pred GemmAlgo21 = GemmAlgo20
  pred GemmAlgo22 = GemmAlgo21
  pred GemmAlgo23 = GemmAlgo22
  pred GemmDefaultTensorOp = GemmAlgo23
  pred GemmDfaltTensorOp = GemmAlgo23
  pred GemmAlgo0TensorOp = GemmDefaultTensorOp
  pred GemmAlgo1TensorOp = GemmAlgo0TensorOp
  pred GemmAlgo2TensorOp = GemmAlgo1TensorOp
  pred GemmAlgo3TensorOp = GemmAlgo2TensorOp
  pred GemmAlgo4TensorOp = GemmAlgo3TensorOp
  pred GemmAlgo5TensorOp = GemmAlgo4TensorOp
  pred GemmAlgo6TensorOp = GemmAlgo5TensorOp
  pred GemmAlgo7TensorOp = GemmAlgo6TensorOp
  pred GemmAlgo8TensorOp = GemmAlgo7TensorOp
  pred GemmAlgo9TensorOp = GemmAlgo8TensorOp
  pred GemmAlgo10TensorOp = GemmAlgo9TensorOp
  pred GemmAlgo11TensorOp = GemmAlgo10TensorOp
  pred GemmAlgo12TensorOp = GemmAlgo11TensorOp
  pred GemmAlgo13TensorOp = GemmAlgo12TensorOp
  pred GemmAlgo14TensorOp = GemmAlgo13TensorOp
  pred GemmAlgo15TensorOp = GemmAlgo14TensorOp
  pred CUBLAS_GEMM_DFALT = error "GemmAlgorithm.pred: CUBLAS_GEMM_DFALT has no predecessor"
  pred GemmDefault = error "GemmAlgorithm.pred: GemmDefault has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from GemmAlgo15TensorOp

  fromEnum CUBLAS_GEMM_DFALT = (-1)
  fromEnum GemmDefault = (-1)
  fromEnum GemmAlgo0 = 0
  fromEnum GemmAlgo1 = 1
  fromEnum GemmAlgo2 = 2
  fromEnum GemmAlgo3 = 3
  fromEnum GemmAlgo4 = 4
  fromEnum GemmAlgo5 = 5
  fromEnum GemmAlgo6 = 6
  fromEnum GemmAlgo7 = 7
  fromEnum GemmAlgo8 = 8
  fromEnum GemmAlgo9 = 9
  fromEnum GemmAlgo10 = 10
  fromEnum GemmAlgo11 = 11
  fromEnum GemmAlgo12 = 12
  fromEnum GemmAlgo13 = 13
  fromEnum GemmAlgo14 = 14
  fromEnum GemmAlgo15 = 15
  fromEnum GemmAlgo16 = 16
  fromEnum GemmAlgo17 = 17
  fromEnum GemmAlgo18 = 18
  fromEnum GemmAlgo19 = 19
  fromEnum GemmAlgo20 = 20
  fromEnum GemmAlgo21 = 21
  fromEnum GemmAlgo22 = 22
  fromEnum GemmAlgo23 = 23
  fromEnum GemmDefaultTensorOp = 99
  fromEnum GemmDfaltTensorOp = 99
  fromEnum GemmAlgo0TensorOp = 100
  fromEnum GemmAlgo1TensorOp = 101
  fromEnum GemmAlgo2TensorOp = 102
  fromEnum GemmAlgo3TensorOp = 103
  fromEnum GemmAlgo4TensorOp = 104
  fromEnum GemmAlgo5TensorOp = 105
  fromEnum GemmAlgo6TensorOp = 106
  fromEnum GemmAlgo7TensorOp = 107
  fromEnum GemmAlgo8TensorOp = 108
  fromEnum GemmAlgo9TensorOp = 109
  fromEnum GemmAlgo10TensorOp = 110
  fromEnum GemmAlgo11TensorOp = 111
  fromEnum GemmAlgo12TensorOp = 112
  fromEnum GemmAlgo13TensorOp = 113
  fromEnum GemmAlgo14TensorOp = 114
  fromEnum GemmAlgo15TensorOp = 115

  toEnum (-1) = CUBLAS_GEMM_DFALT
  toEnum 0 = GemmAlgo0
  toEnum 1 = GemmAlgo1
  toEnum 2 = GemmAlgo2
  toEnum 3 = GemmAlgo3
  toEnum 4 = GemmAlgo4
  toEnum 5 = GemmAlgo5
  toEnum 6 = GemmAlgo6
  toEnum 7 = GemmAlgo7
  toEnum 8 = GemmAlgo8
  toEnum 9 = GemmAlgo9
  toEnum 10 = GemmAlgo10
  toEnum 11 = GemmAlgo11
  toEnum 12 = GemmAlgo12
  toEnum 13 = GemmAlgo13
  toEnum 14 = GemmAlgo14
  toEnum 15 = GemmAlgo15
  toEnum 16 = GemmAlgo16
  toEnum 17 = GemmAlgo17
  toEnum 18 = GemmAlgo18
  toEnum 19 = GemmAlgo19
  toEnum 20 = GemmAlgo20
  toEnum 21 = GemmAlgo21
  toEnum 22 = GemmAlgo22
  toEnum 23 = GemmAlgo23
  toEnum 99 = GemmDefaultTensorOp
  toEnum 100 = GemmAlgo0TensorOp
  toEnum 101 = GemmAlgo1TensorOp
  toEnum 102 = GemmAlgo2TensorOp
  toEnum 103 = GemmAlgo3TensorOp
  toEnum 104 = GemmAlgo4TensorOp
  toEnum 105 = GemmAlgo5TensorOp
  toEnum 106 = GemmAlgo6TensorOp
  toEnum 107 = GemmAlgo7TensorOp
  toEnum 108 = GemmAlgo8TensorOp
  toEnum 109 = GemmAlgo9TensorOp
  toEnum 110 = GemmAlgo10TensorOp
  toEnum 111 = GemmAlgo11TensorOp
  toEnum 112 = GemmAlgo12TensorOp
  toEnum 113 = GemmAlgo13TensorOp
  toEnum 114 = GemmAlgo14TensorOp
  toEnum 115 = GemmAlgo15TensorOp
  toEnum unmatched = error ("GemmAlgorithm.toEnum: Cannot match " ++ show unmatched)

{-# LINE 136 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}



-- | Enum for default math mode / tensor math mode
--
data MathMode = DefaultMath
              | TensorMath
  deriving (Eq,Show)
instance Enum MathMode where
  succ DefaultMath = TensorMath
  succ TensorMath = error "MathMode.succ: TensorMath has no successor"

  pred TensorMath = DefaultMath
  pred DefaultMath = error "MathMode.pred: DefaultMath has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from TensorMath

  fromEnum DefaultMath = 0
  fromEnum TensorMath = 1

  toEnum 0 = DefaultMath
  toEnum 1 = TensorMath
  toEnum unmatched = error ("MathMode.toEnum: Cannot match " ++ show unmatched)

{-# LINE 149 "./Foreign/CUDA/BLAS/Internal/Types.chs" #-}