-- GENERATED by C->Haskell Compiler, version 0.28.2 Switcheroo, 1 April 2016 (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 = GemmDefault
                   | GemmAlgo0
                   | GemmAlgo1
                   | GemmAlgo2
                   | GemmAlgo3
                   | GemmAlgo4
                   | GemmAlgo5
                   | GemmAlgo6
                   | GemmAlgo7
  deriving (Eq,Show)
instance Enum GemmAlgorithm where
  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 = error "GemmAlgorithm.succ: GemmAlgo7 has no successor"

  pred GemmAlgo0 = GemmDefault
  pred GemmAlgo1 = GemmAlgo0
  pred GemmAlgo2 = GemmAlgo1
  pred GemmAlgo3 = GemmAlgo2
  pred GemmAlgo4 = GemmAlgo3
  pred GemmAlgo5 = GemmAlgo4
  pred GemmAlgo6 = GemmAlgo5
  pred GemmAlgo7 = GemmAlgo6
  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 GemmAlgo7

  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

  toEnum (-1) = GemmDefault
  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 unmatched = error ("GemmAlgorithm.toEnum: Cannot match " ++ show unmatched)

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