-- Do not edit! Automatically generated by create-lapack-ffi.
module Numeric.BLAS.ComfortArray.Double where

import qualified Numeric.BLAS.FFI.Double as FFI
import qualified Numeric.Netlib.ComfortArray.Utility as Call
import Numeric.Netlib.ComfortArray.Utility (ZeroInt)

import qualified Data.Array.Comfort.Storable.Mutable as MutArray
import qualified Data.Array.Comfort.Storable as Array
import Data.Array.Comfort.Storable.Mutable (IOArray)
import Data.Array.Comfort.Storable (Array)

import Foreign.Storable.Complex ()
import Foreign.Storable (peek)
import Foreign.C.Types (CInt)

import Control.Monad.Trans.Cont (evalContT)
import Control.Monad.IO.Class (liftIO)
import Control.Applicative (pure, (<*>))


asum ::
   Int {- ^ n -} ->
   Array ZeroInt Double {- ^ dx -} ->
   Int {- ^ incx -} ->
   IO Double
asum :: Int -> Array ZeroInt Double -> Int -> IO Double
asum Int
n Array ZeroInt Double
dx Int
incx = do
   let dxDim0 :: Int
dxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
dx
   String -> Bool -> IO ()
Call.assert String
"asum: 1+(n-1)*abs(incx) == dxDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dxDim0)
   ContT Double IO Double -> IO Double
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Double IO Double -> IO Double)
-> ContT Double IO Double -> IO Double
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
dxPtr <- Array ZeroInt Double -> FortranIO Double (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
dx
      Ptr CInt
incxPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO Double -> ContT Double IO Double
forall a. IO a -> ContT Double IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> ContT Double IO Double)
-> IO Double -> ContT Double IO Double
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr Double -> Ptr CInt -> IO Double
FFI.asum Ptr CInt
nPtr Ptr Double
dxPtr Ptr CInt
incxPtr

axpy ::
   Int {- ^ n -} ->
   Double {- ^ da -} ->
   Array ZeroInt Double {- ^ dx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Double {- ^ dy -} ->
   Int {- ^ incy -} ->
   IO ()
axpy :: Int
-> Double
-> Array ZeroInt Double
-> Int
-> IOArray ZeroInt Double
-> Int
-> IO ()
axpy Int
n Double
da Array ZeroInt Double
dx Int
incx IOArray ZeroInt Double
dy Int
incy = do
   let dxDim0 :: Int
dxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
dx
   let dyDim0 :: Int
dyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
dy
   String -> Bool -> IO ()
Call.assert String
"axpy: 1+(n-1)*abs(incx) == dxDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dxDim0)
   String -> Bool -> IO ()
Call.assert String
"axpy: 1+(n-1)*abs(incy) == dyDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incy) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dyDim0)
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
daPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
da
      Ptr Double
dxPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
dx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
dyPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.axpy Ptr CInt
nPtr Ptr Double
daPtr Ptr Double
dxPtr Ptr CInt
incxPtr Ptr Double
dyPtr Ptr CInt
incyPtr

copy ::
   Int {- ^ n -} ->
   Array ZeroInt Double {- ^ dx -} ->
   Int {- ^ incx -} ->
   Int {- ^ incy -} ->
   IO (Array ZeroInt Double)
copy :: Int
-> Array ZeroInt Double -> Int -> Int -> IO (Array ZeroInt Double)
copy Int
n Array ZeroInt Double
dx Int
incx Int
incy = do
   let dxDim0 :: Int
dxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
dx
   String -> Bool -> IO ()
Call.assert String
"copy: 1+(n-1)*abs(incx) == dxDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dxDim0)
   IOArray ZeroInt Double
dy <- Int -> IO (IOArray ZeroInt Double)
forall e. Storable e => Int -> IO (IOArray ZeroInt e)
Call.newArray1 (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incy))
   ContT (Array ZeroInt Double) IO (Array ZeroInt Double)
-> IO (Array ZeroInt Double)
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT (Array ZeroInt Double) IO (Array ZeroInt Double)
 -> IO (Array ZeroInt Double))
-> ContT (Array ZeroInt Double) IO (Array ZeroInt Double)
-> IO (Array ZeroInt Double)
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO (Array ZeroInt Double) (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
dxPtr <- Array ZeroInt Double
-> FortranIO (Array ZeroInt Double) (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
dx
      Ptr CInt
incxPtr <- Int -> FortranIO (Array ZeroInt Double) (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
dyPtr <- IOArray ZeroInt Double
-> FortranIO (Array ZeroInt Double) (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dy
      Ptr CInt
incyPtr <- Int -> FortranIO (Array ZeroInt Double) (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT (Array ZeroInt Double) IO ()
forall a. IO a -> ContT (Array ZeroInt Double) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT (Array ZeroInt Double) IO ())
-> IO () -> ContT (Array ZeroInt Double) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr Double -> Ptr CInt -> Ptr Double -> Ptr CInt -> IO ()
FFI.copy Ptr CInt
nPtr Ptr Double
dxPtr Ptr CInt
incxPtr Ptr Double
dyPtr Ptr CInt
incyPtr
      IO (Array ZeroInt Double)
-> ContT (Array ZeroInt Double) IO (Array ZeroInt Double)
forall a. IO a -> ContT (Array ZeroInt Double) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Array ZeroInt Double)
 -> ContT (Array ZeroInt Double) IO (Array ZeroInt Double))
-> IO (Array ZeroInt Double)
-> ContT (Array ZeroInt Double) IO (Array ZeroInt Double)
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> IO (Array ZeroInt Double)
forall sh e. (C sh, Storable e) => IOArray sh e -> IO (Array sh e)
Call.freezeArray IOArray ZeroInt Double
dy

dot ::
   Int {- ^ n -} ->
   Array ZeroInt Double {- ^ dx -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Double {- ^ dy -} ->
   Int {- ^ incy -} ->
   IO Double
dot :: Int
-> Array ZeroInt Double
-> Int
-> Array ZeroInt Double
-> Int
-> IO Double
dot Int
n Array ZeroInt Double
dx Int
incx Array ZeroInt Double
dy Int
incy = do
   let dxDim0 :: Int
dxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
dx
   let dyDim0 :: Int
dyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
dy
   String -> Bool -> IO ()
Call.assert String
"dot: 1+(n-1)*abs(incx) == dxDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dxDim0)
   String -> Bool -> IO ()
Call.assert String
"dot: 1+(n-1)*abs(incy) == dyDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incy) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dyDim0)
   ContT Double IO Double -> IO Double
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Double IO Double -> IO Double)
-> ContT Double IO Double -> IO Double
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
dxPtr <- Array ZeroInt Double -> FortranIO Double (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
dx
      Ptr CInt
incxPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
dyPtr <- Array ZeroInt Double -> FortranIO Double (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
dy
      Ptr CInt
incyPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO Double -> ContT Double IO Double
forall a. IO a -> ContT Double IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> ContT Double IO Double)
-> IO Double -> ContT Double IO Double
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr Double -> Ptr CInt -> Ptr Double -> Ptr CInt -> IO Double
FFI.dot Ptr CInt
nPtr Ptr Double
dxPtr Ptr CInt
incxPtr Ptr Double
dyPtr Ptr CInt
incyPtr

gbmv ::
   Char {- ^ trans -} ->
   Int {- ^ m -} ->
   Int {- ^ kl -} ->
   Int {- ^ ku -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   Double {- ^ beta -} ->
   IOArray ZeroInt Double {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
gbmv :: Char
-> Int
-> Int
-> Int
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> Array ZeroInt Double
-> Int
-> Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
gbmv Char
trans Int
m Int
kl Int
ku Double
alpha Array (ZeroInt, ZeroInt) Double
a Array ZeroInt Double
x Int
incx Double
beta IOArray ZeroInt Double
y Int
incy = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let yDim0 :: Int
yDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
y
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _xSize :: Int
_xSize = Int
xDim0
   let _ySize :: Int
_ySize = Int
yDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CInt
mPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
m
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr CInt
klPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
kl
      Ptr CInt
kuPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ku
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
betaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
beta
      Ptr Double
yPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.gbmv Ptr CChar
transPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr CInt
klPtr Ptr CInt
kuPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
betaPtr Ptr Double
yPtr Ptr CInt
incyPtr

gemm ::
   Char {- ^ transa -} ->
   Char {- ^ transb -} ->
   Int {- ^ m -} ->
   Int {- ^ k -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ b -} ->
   Double {- ^ beta -} ->
   IOArray (ZeroInt,ZeroInt) Double {- ^ c -} ->
   IO ()
gemm :: Char
-> Char
-> Int
-> Int
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> Array (ZeroInt, ZeroInt) Double
-> Double
-> IOArray (ZeroInt, ZeroInt) Double
-> IO ()
gemm Char
transa Char
transb Int
m Int
k Double
alpha Array (ZeroInt, ZeroInt) Double
a Array (ZeroInt, ZeroInt) Double
b Double
beta IOArray (ZeroInt, ZeroInt) Double
c = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let (Int
bDim0,Int
bDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
b
   let (Int
cDim0,Int
cDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ IOArray (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Double
c
   let _ka :: Int
_ka = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _kb :: Int
_kb = Int
bDim0
   let ldb :: Int
ldb = Int
bDim1
   let n :: Int
n = Int
cDim0
   let ldc :: Int
ldc = Int
cDim1
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
transaPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
transa
      Ptr CChar
transbPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
transb
      Ptr CInt
mPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
m
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr CInt
kPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
k
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
bPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      Ptr Double
betaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
beta
      Ptr Double
cPtr <- IOArray (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Double
c
      Ptr CInt
ldcPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldc
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.gemm Ptr CChar
transaPtr Ptr CChar
transbPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
bPtr Ptr CInt
ldbPtr Ptr Double
betaPtr Ptr Double
cPtr Ptr CInt
ldcPtr

gemv ::
   Char {- ^ trans -} ->
   Int {- ^ m -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   Double {- ^ beta -} ->
   IOArray ZeroInt Double {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
gemv :: Char
-> Int
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> Array ZeroInt Double
-> Int
-> Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
gemv Char
trans Int
m Double
alpha Array (ZeroInt, ZeroInt) Double
a Array ZeroInt Double
x Int
incx Double
beta IOArray ZeroInt Double
y Int
incy = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let yDim0 :: Int
yDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
y
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _xSize :: Int
_xSize = Int
xDim0
   let _ySize :: Int
_ySize = Int
yDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CInt
mPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
m
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
betaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
beta
      Ptr Double
yPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.gemv Ptr CChar
transPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
betaPtr Ptr Double
yPtr Ptr CInt
incyPtr

ger ::
   Int {- ^ m -} ->
   Double {- ^ alpha -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Double {- ^ y -} ->
   Int {- ^ incy -} ->
   IOArray (ZeroInt,ZeroInt) Double {- ^ a -} ->
   IO ()
ger :: Int
-> Double
-> Array ZeroInt Double
-> Int
-> Array ZeroInt Double
-> Int
-> IOArray (ZeroInt, ZeroInt) Double
-> IO ()
ger Int
m Double
alpha Array ZeroInt Double
x Int
incx Array ZeroInt Double
y Int
incy IOArray (ZeroInt, ZeroInt) Double
a = do
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let yDim0 :: Int
yDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
y
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ IOArray (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Double
a
   let _xSize :: Int
_xSize = Int
xDim0
   let _ySize :: Int
_ySize = Int
yDim0
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
mPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
m
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
yPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Double
aPtr <- IOArray (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.ger Ptr CInt
mPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
yPtr Ptr CInt
incyPtr Ptr Double
aPtr Ptr CInt
ldaPtr

sbmv ::
   Char {- ^ uplo -} ->
   Int {- ^ k -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   Double {- ^ beta -} ->
   IOArray ZeroInt Double {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
sbmv :: Char
-> Int
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> Array ZeroInt Double
-> Int
-> Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
sbmv Char
uplo Int
k Double
alpha Array (ZeroInt, ZeroInt) Double
a Array ZeroInt Double
x Int
incx Double
beta IOArray ZeroInt Double
y Int
incy = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let yDim0 :: Int
yDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
y
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _xSize :: Int
_xSize = Int
xDim0
   let _ySize :: Int
_ySize = Int
yDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr CInt
kPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
k
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
betaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
beta
      Ptr Double
yPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.sbmv Ptr CChar
uploPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
betaPtr Ptr Double
yPtr Ptr CInt
incyPtr

symv ::
   Char {- ^ uplo -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   Double {- ^ beta -} ->
   IOArray ZeroInt Double {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
symv :: Char
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> Array ZeroInt Double
-> Int
-> Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
symv Char
uplo Double
alpha Array (ZeroInt, ZeroInt) Double
a Array ZeroInt Double
x Int
incx Double
beta IOArray ZeroInt Double
y Int
incy = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let yDim0 :: Int
yDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
y
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _xSize :: Int
_xSize = Int
xDim0
   let _ySize :: Int
_ySize = Int
yDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
betaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
beta
      Ptr Double
yPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.symv Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
betaPtr Ptr Double
yPtr Ptr CInt
incyPtr

syr ::
   Char {- ^ uplo -} ->
   Double {- ^ alpha -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   IOArray (ZeroInt,ZeroInt) Double {- ^ a -} ->
   IO ()
syr :: Char
-> Double
-> Array ZeroInt Double
-> Int
-> IOArray (ZeroInt, ZeroInt) Double
-> IO ()
syr Char
uplo Double
alpha Array ZeroInt Double
x Int
incx IOArray (ZeroInt, ZeroInt) Double
a = do
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ IOArray (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Double
a
   let _xSize :: Int
_xSize = Int
xDim0
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
aPtr <- IOArray (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.syr Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
aPtr Ptr CInt
ldaPtr

syr2 ::
   Char {- ^ uplo -} ->
   Double {- ^ alpha -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Double {- ^ y -} ->
   Int {- ^ incy -} ->
   IOArray (ZeroInt,ZeroInt) Double {- ^ a -} ->
   IO ()
syr2 :: Char
-> Double
-> Array ZeroInt Double
-> Int
-> Array ZeroInt Double
-> Int
-> IOArray (ZeroInt, ZeroInt) Double
-> IO ()
syr2 Char
uplo Double
alpha Array ZeroInt Double
x Int
incx Array ZeroInt Double
y Int
incy IOArray (ZeroInt, ZeroInt) Double
a = do
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let yDim0 :: Int
yDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
y
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ IOArray (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Double
a
   let _xSize :: Int
_xSize = Int
xDim0
   let _ySize :: Int
_ySize = Int
yDim0
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
yPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Double
aPtr <- IOArray (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.syr2 Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
yPtr Ptr CInt
incyPtr Ptr Double
aPtr Ptr CInt
ldaPtr

spmv ::
   Char {- ^ uplo -} ->
   Int {- ^ n -} ->
   Double {- ^ alpha -} ->
   Array ZeroInt Double {- ^ ap -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   Double {- ^ beta -} ->
   IOArray ZeroInt Double {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
spmv :: Char
-> Int
-> Double
-> Array ZeroInt Double
-> Array ZeroInt Double
-> Int
-> Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
spmv Char
uplo Int
n Double
alpha Array ZeroInt Double
ap Array ZeroInt Double
x Int
incx Double
beta IOArray ZeroInt Double
y Int
incy = do
   let apDim0 :: Int
apDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
ap
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let yDim0 :: Int
yDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
y
   let _apSize :: Int
_apSize = Int
apDim0
   let _xSize :: Int
_xSize = Int
xDim0
   let _ySize :: Int
_ySize = Int
yDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
apPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
ap
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
betaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
beta
      Ptr Double
yPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.spmv Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
apPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
betaPtr Ptr Double
yPtr Ptr CInt
incyPtr

spr ::
   Char {- ^ uplo -} ->
   Int {- ^ n -} ->
   Double {- ^ alpha -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Double {- ^ ap -} ->
   IO ()
spr :: Char
-> Int
-> Double
-> Array ZeroInt Double
-> Int
-> IOArray ZeroInt Double
-> IO ()
spr Char
uplo Int
n Double
alpha Array ZeroInt Double
x Int
incx IOArray ZeroInt Double
ap = do
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let apDim0 :: Int
apDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
ap
   let _xSize :: Int
_xSize = Int
xDim0
   let _apSize :: Int
_apSize = Int
apDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
apPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
ap
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> IO ()
FFI.spr Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
apPtr

spr2 ::
   Char {- ^ uplo -} ->
   Int {- ^ n -} ->
   Double {- ^ alpha -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Double {- ^ y -} ->
   Int {- ^ incy -} ->
   IOArray ZeroInt Double {- ^ ap -} ->
   IO ()
spr2 :: Char
-> Int
-> Double
-> Array ZeroInt Double
-> Int
-> Array ZeroInt Double
-> Int
-> IOArray ZeroInt Double
-> IO ()
spr2 Char
uplo Int
n Double
alpha Array ZeroInt Double
x Int
incx Array ZeroInt Double
y Int
incy IOArray ZeroInt Double
ap = do
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   let yDim0 :: Int
yDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
y
   let apDim0 :: Int
apDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
ap
   let _xSize :: Int
_xSize = Int
xDim0
   let _ySize :: Int
_ySize = Int
yDim0
   let _apSize :: Int
_apSize = Int
apDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
yPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Double
apPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
ap
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> IO ()
FFI.spr2 Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
xPtr Ptr CInt
incxPtr Ptr Double
yPtr Ptr CInt
incyPtr Ptr Double
apPtr

iamax ::
   Int {- ^ n -} ->
   Array ZeroInt Double {- ^ dx -} ->
   Int {- ^ incx -} ->
   IO CInt
iamax :: Int -> Array ZeroInt Double -> Int -> IO CInt
iamax Int
n Array ZeroInt Double
dx Int
incx = do
   let dxDim0 :: Int
dxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
dx
   String -> Bool -> IO ()
Call.assert String
"iamax: 1+(n-1)*abs(incx) == dxDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dxDim0)
   ContT CInt IO CInt -> IO CInt
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT CInt IO CInt -> IO CInt) -> ContT CInt IO CInt -> IO CInt
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO CInt (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
dxPtr <- Array ZeroInt Double -> FortranIO CInt (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
dx
      Ptr CInt
incxPtr <- Int -> FortranIO CInt (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO CInt -> ContT CInt IO CInt
forall a. IO a -> ContT CInt IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> ContT CInt IO CInt) -> IO CInt -> ContT CInt IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr Double -> Ptr CInt -> IO CInt
FFI.iamax Ptr CInt
nPtr Ptr Double
dxPtr Ptr CInt
incxPtr

nrm2 ::
   Int {- ^ n -} ->
   Array ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   IO Double
nrm2 :: Int -> Array ZeroInt Double -> Int -> IO Double
nrm2 Int
n Array ZeroInt Double
x Int
incx = do
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
x
   String -> Bool -> IO ()
Call.assert String
"nrm2: 1+(n-1)*abs(incx) == xDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
xDim0)
   ContT Double IO Double -> IO Double
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Double IO Double -> IO Double)
-> ContT Double IO Double -> IO Double
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
xPtr <- Array ZeroInt Double -> FortranIO Double (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO Double -> ContT Double IO Double
forall a. IO a -> ContT Double IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> ContT Double IO Double)
-> IO Double -> ContT Double IO Double
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr Double -> Ptr CInt -> IO Double
FFI.nrm2 Ptr CInt
nPtr Ptr Double
xPtr Ptr CInt
incxPtr

rot ::
   Int {- ^ n -} ->
   IOArray ZeroInt Double {- ^ dx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Double {- ^ dy -} ->
   Int {- ^ incy -} ->
   Double {- ^ c -} ->
   Double {- ^ s -} ->
   IO ()
rot :: Int
-> IOArray ZeroInt Double
-> Int
-> IOArray ZeroInt Double
-> Int
-> Double
-> Double
-> IO ()
rot Int
n IOArray ZeroInt Double
dx Int
incx IOArray ZeroInt Double
dy Int
incy Double
c Double
s = do
   let dxDim0 :: Int
dxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
dx
   let dyDim0 :: Int
dyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
dy
   String -> Bool -> IO ()
Call.assert String
"rot: 1+(n-1)*abs(incx) == dxDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dxDim0)
   String -> Bool -> IO ()
Call.assert String
"rot: 1+(n-1)*abs(incy) == dyDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incy) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dyDim0)
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
dxPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
dyPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Double
cPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
c
      Ptr Double
sPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
s
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> IO ()
FFI.rot Ptr CInt
nPtr Ptr Double
dxPtr Ptr CInt
incxPtr Ptr Double
dyPtr Ptr CInt
incyPtr Ptr Double
cPtr Ptr Double
sPtr

rotg ::
   Double {- ^ da -} ->
   Double {- ^ db -} ->
   IO (Double, Double)
rotg :: Double -> Double -> IO (Double, Double)
rotg Double
da Double
db = do
   ContT (Double, Double) IO (Double, Double) -> IO (Double, Double)
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT (Double, Double) IO (Double, Double) -> IO (Double, Double))
-> ContT (Double, Double) IO (Double, Double)
-> IO (Double, Double)
forall a b. (a -> b) -> a -> b
$ do
      Ptr Double
daPtr <- Double -> FortranIO (Double, Double) (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
da
      Ptr Double
dbPtr <- Double -> FortranIO (Double, Double) (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
db
      Ptr Double
cPtr <- FortranIO (Double, Double) (Ptr Double)
forall a r. Storable a => FortranIO r (Ptr a)
Call.alloca
      Ptr Double
sPtr <- FortranIO (Double, Double) (Ptr Double)
forall a r. Storable a => FortranIO r (Ptr a)
Call.alloca
      IO () -> ContT (Double, Double) IO ()
forall a. IO a -> ContT (Double, Double) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT (Double, Double) IO ())
-> IO () -> ContT (Double, Double) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> IO ()
FFI.rotg Ptr Double
daPtr Ptr Double
dbPtr Ptr Double
cPtr Ptr Double
sPtr
      IO (Double, Double) -> ContT (Double, Double) IO (Double, Double)
forall a. IO a -> ContT (Double, Double) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, Double) -> ContT (Double, Double) IO (Double, Double))
-> IO (Double, Double)
-> ContT (Double, Double) IO (Double, Double)
forall a b. (a -> b) -> a -> b
$ (Double -> Double -> (Double, Double))
-> IO (Double -> Double -> (Double, Double))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,)
         IO (Double -> Double -> (Double, Double))
-> IO Double -> IO (Double -> (Double, Double))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Double -> IO Double
forall a. Storable a => Ptr a -> IO a
peek Ptr Double
cPtr
         IO (Double -> (Double, Double)) -> IO Double -> IO (Double, Double)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Double -> IO Double
forall a. Storable a => Ptr a -> IO a
peek Ptr Double
sPtr

rotm ::
   Int {- ^ n -} ->
   IOArray ZeroInt Double {- ^ dx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Double {- ^ dy -} ->
   Int {- ^ incy -} ->
   Array ZeroInt Double {- ^ dparam -} ->
   IO ()
rotm :: Int
-> IOArray ZeroInt Double
-> Int
-> IOArray ZeroInt Double
-> Int
-> Array ZeroInt Double
-> IO ()
rotm Int
n IOArray ZeroInt Double
dx Int
incx IOArray ZeroInt Double
dy Int
incy Array ZeroInt Double
dparam = do
   let dxDim0 :: Int
dxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
dx
   let dyDim0 :: Int
dyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
dy
   let dparamDim0 :: Int
dparamDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
dparam
   String -> Bool -> IO ()
Call.assert String
"rotm: 1+(n-1)*abs(incx) == dxDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dxDim0)
   String -> Bool -> IO ()
Call.assert String
"rotm: 1+(n-1)*abs(incy) == dyDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incy) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dyDim0)
   String -> Bool -> IO ()
Call.assert String
"rotm: 5 == dparamDim0" (Int
5 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dparamDim0)
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
dxPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
dyPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Double
dparamPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
dparam
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> IO ()
FFI.rotm Ptr CInt
nPtr Ptr Double
dxPtr Ptr CInt
incxPtr Ptr Double
dyPtr Ptr CInt
incyPtr Ptr Double
dparamPtr

rotmg ::
   Double {- ^ dd1 -} ->
   Double {- ^ dd2 -} ->
   Double {- ^ dx1 -} ->
   Double {- ^ dy1 -} ->
   IO (Double, Double, Double, Array ZeroInt Double)
rotmg :: Double
-> Double
-> Double
-> Double
-> IO (Double, Double, Double, Array ZeroInt Double)
rotmg Double
dd1 Double
dd2 Double
dx1 Double
dy1 = do
   IOArray ZeroInt Double
dparam <- Int -> IO (IOArray ZeroInt Double)
forall e. Storable e => Int -> IO (IOArray ZeroInt e)
Call.newArray1 Int
5
   ContT
  (Double, Double, Double, Array ZeroInt Double)
  IO
  (Double, Double, Double, Array ZeroInt Double)
-> IO (Double, Double, Double, Array ZeroInt Double)
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT
   (Double, Double, Double, Array ZeroInt Double)
   IO
   (Double, Double, Double, Array ZeroInt Double)
 -> IO (Double, Double, Double, Array ZeroInt Double))
-> ContT
     (Double, Double, Double, Array ZeroInt Double)
     IO
     (Double, Double, Double, Array ZeroInt Double)
-> IO (Double, Double, Double, Array ZeroInt Double)
forall a b. (a -> b) -> a -> b
$ do
      Ptr Double
dd1Ptr <- Double
-> FortranIO
     (Double, Double, Double, Array ZeroInt Double) (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
dd1
      Ptr Double
dd2Ptr <- Double
-> FortranIO
     (Double, Double, Double, Array ZeroInt Double) (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
dd2
      Ptr Double
dx1Ptr <- Double
-> FortranIO
     (Double, Double, Double, Array ZeroInt Double) (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
dx1
      Ptr Double
dy1Ptr <- Double
-> FortranIO
     (Double, Double, Double, Array ZeroInt Double) (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
dy1
      Ptr Double
dparamPtr <- IOArray ZeroInt Double
-> FortranIO
     (Double, Double, Double, Array ZeroInt Double) (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dparam
      IO () -> ContT (Double, Double, Double, Array ZeroInt Double) IO ()
forall a.
IO a -> ContT (Double, Double, Double, Array ZeroInt Double) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ()
 -> ContT (Double, Double, Double, Array ZeroInt Double) IO ())
-> IO ()
-> ContT (Double, Double, Double, Array ZeroInt Double) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Double
-> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> IO ()
FFI.rotmg Ptr Double
dd1Ptr Ptr Double
dd2Ptr Ptr Double
dx1Ptr Ptr Double
dy1Ptr Ptr Double
dparamPtr
      IO (Double, Double, Double, Array ZeroInt Double)
-> ContT
     (Double, Double, Double, Array ZeroInt Double)
     IO
     (Double, Double, Double, Array ZeroInt Double)
forall a.
IO a -> ContT (Double, Double, Double, Array ZeroInt Double) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Double, Double, Double, Array ZeroInt Double)
 -> ContT
      (Double, Double, Double, Array ZeroInt Double)
      IO
      (Double, Double, Double, Array ZeroInt Double))
-> IO (Double, Double, Double, Array ZeroInt Double)
-> ContT
     (Double, Double, Double, Array ZeroInt Double)
     IO
     (Double, Double, Double, Array ZeroInt Double)
forall a b. (a -> b) -> a -> b
$ (Double
 -> Double
 -> Double
 -> Array ZeroInt Double
 -> (Double, Double, Double, Array ZeroInt Double))
-> IO
     (Double
      -> Double
      -> Double
      -> Array ZeroInt Double
      -> (Double, Double, Double, Array ZeroInt Double))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,,,)
         IO
  (Double
   -> Double
   -> Double
   -> Array ZeroInt Double
   -> (Double, Double, Double, Array ZeroInt Double))
-> IO Double
-> IO
     (Double
      -> Double
      -> Array ZeroInt Double
      -> (Double, Double, Double, Array ZeroInt Double))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Double -> IO Double
forall a. Storable a => Ptr a -> IO a
peek Ptr Double
dd1Ptr
         IO
  (Double
   -> Double
   -> Array ZeroInt Double
   -> (Double, Double, Double, Array ZeroInt Double))
-> IO Double
-> IO
     (Double
      -> Array ZeroInt Double
      -> (Double, Double, Double, Array ZeroInt Double))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Double -> IO Double
forall a. Storable a => Ptr a -> IO a
peek Ptr Double
dd2Ptr
         IO
  (Double
   -> Array ZeroInt Double
   -> (Double, Double, Double, Array ZeroInt Double))
-> IO Double
-> IO
     (Array ZeroInt Double
      -> (Double, Double, Double, Array ZeroInt Double))
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Double -> IO Double
forall a. Storable a => Ptr a -> IO a
peek Ptr Double
dx1Ptr
         IO
  (Array ZeroInt Double
   -> (Double, Double, Double, Array ZeroInt Double))
-> IO (Array ZeroInt Double)
-> IO (Double, Double, Double, Array ZeroInt Double)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IOArray ZeroInt Double -> IO (Array ZeroInt Double)
forall sh e. (C sh, Storable e) => IOArray sh e -> IO (Array sh e)
Call.freezeArray IOArray ZeroInt Double
dparam

scal ::
   Int {- ^ n -} ->
   Double {- ^ da -} ->
   IOArray ZeroInt Double {- ^ dx -} ->
   Int {- ^ incx -} ->
   IO ()
scal :: Int -> Double -> IOArray ZeroInt Double -> Int -> IO ()
scal Int
n Double
da IOArray ZeroInt Double
dx Int
incx = do
   let dxDim0 :: Int
dxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
dx
   String -> Bool -> IO ()
Call.assert String
"scal: 1+(n-1)*abs(incx) == dxDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dxDim0)
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
daPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
da
      Ptr Double
dxPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr Double -> Ptr Double -> Ptr CInt -> IO ()
FFI.scal Ptr CInt
nPtr Ptr Double
daPtr Ptr Double
dxPtr Ptr CInt
incxPtr

sdot ::
   Array ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Float {- ^ sy -} ->
   Int {- ^ incy -} ->
   IO Double
sdot :: Array ZeroInt Float
-> Int -> Array ZeroInt Float -> Int -> IO Double
sdot Array ZeroInt Float
sx Int
incx Array ZeroInt Float
sy Int
incy = do
   let sxDim0 :: Int
sxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
sx
   let syDim0 :: Int
syDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
sy
   let n :: Int
n = Int
sxDim0
   String -> Bool -> IO ()
Call.assert String
"sdot: n == syDim0" (Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
syDim0)
   ContT Double IO Double -> IO Double
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Double IO Double -> IO Double)
-> ContT Double IO Double -> IO Double
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Float
sxPtr <- Array ZeroInt Float -> FortranIO Double (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
sx
      Ptr CInt
incxPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
syPtr <- Array ZeroInt Float -> FortranIO Double (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
sy
      Ptr CInt
incyPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO Double -> ContT Double IO Double
forall a. IO a -> ContT Double IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> ContT Double IO Double)
-> IO Double -> ContT Double IO Double
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr Float -> Ptr CInt -> Ptr Float -> Ptr CInt -> IO Double
FFI.sdot Ptr CInt
nPtr Ptr Float
sxPtr Ptr CInt
incxPtr Ptr Float
syPtr Ptr CInt
incyPtr

swap ::
   Int {- ^ n -} ->
   IOArray ZeroInt Double {- ^ dx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Double {- ^ dy -} ->
   Int {- ^ incy -} ->
   IO ()
swap :: Int
-> IOArray ZeroInt Double
-> Int
-> IOArray ZeroInt Double
-> Int
-> IO ()
swap Int
n IOArray ZeroInt Double
dx Int
incx IOArray ZeroInt Double
dy Int
incy = do
   let dxDim0 :: Int
dxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
dx
   let dyDim0 :: Int
dyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
dy
   String -> Bool -> IO ()
Call.assert String
"swap: 1+(n-1)*abs(incx) == dxDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incx) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dxDim0)
   String -> Bool -> IO ()
Call.assert String
"swap: 1+(n-1)*abs(incy) == dyDim0" (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+(Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int -> Int
forall a. Num a => a -> a
abs(Int
incy) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
dyDim0)
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
dxPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Double
dyPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
dy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr Double -> Ptr CInt -> Ptr Double -> Ptr CInt -> IO ()
FFI.swap Ptr CInt
nPtr Ptr Double
dxPtr Ptr CInt
incxPtr Ptr Double
dyPtr Ptr CInt
incyPtr

symm ::
   Char {- ^ side -} ->
   Char {- ^ uplo -} ->
   Int {- ^ m -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ b -} ->
   Double {- ^ beta -} ->
   IOArray (ZeroInt,ZeroInt) Double {- ^ c -} ->
   IO ()
symm :: Char
-> Char
-> Int
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> Array (ZeroInt, ZeroInt) Double
-> Double
-> IOArray (ZeroInt, ZeroInt) Double
-> IO ()
symm Char
side Char
uplo Int
m Double
alpha Array (ZeroInt, ZeroInt) Double
a Array (ZeroInt, ZeroInt) Double
b Double
beta IOArray (ZeroInt, ZeroInt) Double
c = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let (Int
bDim0,Int
bDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
b
   let (Int
cDim0,Int
cDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ IOArray (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Double
c
   let _ka :: Int
_ka = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let n :: Int
n = Int
bDim0
   let ldb :: Int
ldb = Int
bDim1
   let ldc :: Int
ldc = Int
cDim1
   String -> Bool -> IO ()
Call.assert String
"symm: n == cDim0" (Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
cDim0)
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
sidePtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
side
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CInt
mPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
m
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
bPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      Ptr Double
betaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
beta
      Ptr Double
cPtr <- IOArray (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Double
c
      Ptr CInt
ldcPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldc
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.symm Ptr CChar
sidePtr Ptr CChar
uploPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
bPtr Ptr CInt
ldbPtr Ptr Double
betaPtr Ptr Double
cPtr Ptr CInt
ldcPtr

syr2k ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Int {- ^ k -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ b -} ->
   Double {- ^ beta -} ->
   IOArray (ZeroInt,ZeroInt) Double {- ^ c -} ->
   IO ()
syr2k :: Char
-> Char
-> Int
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> Array (ZeroInt, ZeroInt) Double
-> Double
-> IOArray (ZeroInt, ZeroInt) Double
-> IO ()
syr2k Char
uplo Char
trans Int
k Double
alpha Array (ZeroInt, ZeroInt) Double
a Array (ZeroInt, ZeroInt) Double
b Double
beta IOArray (ZeroInt, ZeroInt) Double
c = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let (Int
bDim0,Int
bDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
b
   let (Int
cDim0,Int
cDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ IOArray (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Double
c
   let _ka :: Int
_ka = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _kb :: Int
_kb = Int
bDim0
   let ldb :: Int
ldb = Int
bDim1
   let n :: Int
n = Int
cDim0
   let ldc :: Int
ldc = Int
cDim1
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr CInt
kPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
k
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
bPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      Ptr Double
betaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
beta
      Ptr Double
cPtr <- IOArray (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Double
c
      Ptr CInt
ldcPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldc
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.syr2k Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
bPtr Ptr CInt
ldbPtr Ptr Double
betaPtr Ptr Double
cPtr Ptr CInt
ldcPtr

syrk ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Int {- ^ k -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   Double {- ^ beta -} ->
   IOArray (ZeroInt,ZeroInt) Double {- ^ c -} ->
   IO ()
syrk :: Char
-> Char
-> Int
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> Double
-> IOArray (ZeroInt, ZeroInt) Double
-> IO ()
syrk Char
uplo Char
trans Int
k Double
alpha Array (ZeroInt, ZeroInt) Double
a Double
beta IOArray (ZeroInt, ZeroInt) Double
c = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let (Int
cDim0,Int
cDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ IOArray (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Double
c
   let _ka :: Int
_ka = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let n :: Int
n = Int
cDim0
   let ldc :: Int
ldc = Int
cDim1
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr CInt
kPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
k
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
betaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
beta
      Ptr Double
cPtr <- IOArray (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Double
c
      Ptr CInt
ldcPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldc
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.syrk Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
betaPtr Ptr Double
cPtr Ptr CInt
ldcPtr

tbmv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Int {- ^ k -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   IOArray ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
tbmv :: Char
-> Char
-> Char
-> Int
-> Array (ZeroInt, ZeroInt) Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
tbmv Char
uplo Char
trans Char
diag Int
k Array (ZeroInt, ZeroInt) Double
a IOArray ZeroInt Double
x Int
incx = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
x
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _xSize :: Int
_xSize = Int
xDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CChar
diagPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
diag
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr CInt
kPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
k
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
xPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.tbmv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
xPtr Ptr CInt
incxPtr

tbsv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Int {- ^ k -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   IOArray ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
tbsv :: Char
-> Char
-> Char
-> Int
-> Array (ZeroInt, ZeroInt) Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
tbsv Char
uplo Char
trans Char
diag Int
k Array (ZeroInt, ZeroInt) Double
a IOArray ZeroInt Double
x Int
incx = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
x
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _xSize :: Int
_xSize = Int
xDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CChar
diagPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
diag
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr CInt
kPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
k
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
xPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.tbsv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
xPtr Ptr CInt
incxPtr

tpmv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Int {- ^ n -} ->
   Array ZeroInt Double {- ^ ap -} ->
   IOArray ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
tpmv :: Char
-> Char
-> Char
-> Int
-> Array ZeroInt Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
tpmv Char
uplo Char
trans Char
diag Int
n Array ZeroInt Double
ap IOArray ZeroInt Double
x Int
incx = do
   let apDim0 :: Int
apDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
ap
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
x
   let _apSize :: Int
_apSize = Int
apDim0
   let _xSize :: Int
_xSize = Int
xDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CChar
diagPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
diag
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
apPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
ap
      Ptr Double
xPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.tpmv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr Double
apPtr Ptr Double
xPtr Ptr CInt
incxPtr

tpsv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Int {- ^ n -} ->
   Array ZeroInt Double {- ^ ap -} ->
   IOArray ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
tpsv :: Char
-> Char
-> Char
-> Int
-> Array ZeroInt Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
tpsv Char
uplo Char
trans Char
diag Int
n Array ZeroInt Double
ap IOArray ZeroInt Double
x Int
incx = do
   let apDim0 :: Int
apDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt Double -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Double
ap
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
x
   let _apSize :: Int
_apSize = Int
apDim0
   let _xSize :: Int
_xSize = Int
xDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CChar
diagPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
diag
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
apPtr <- Array ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Double
ap
      Ptr Double
xPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.tpsv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr Double
apPtr Ptr Double
xPtr Ptr CInt
incxPtr

trmm ::
   Char {- ^ side -} ->
   Char {- ^ uplo -} ->
   Char {- ^ transa -} ->
   Char {- ^ diag -} ->
   Int {- ^ m -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   IOArray (ZeroInt,ZeroInt) Double {- ^ b -} ->
   IO ()
trmm :: Char
-> Char
-> Char
-> Char
-> Int
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> IOArray (ZeroInt, ZeroInt) Double
-> IO ()
trmm Char
side Char
uplo Char
transa Char
diag Int
m Double
alpha Array (ZeroInt, ZeroInt) Double
a IOArray (ZeroInt, ZeroInt) Double
b = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let (Int
bDim0,Int
bDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ IOArray (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Double
b
   let _k :: Int
_k = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let n :: Int
n = Int
bDim0
   let ldb :: Int
ldb = Int
bDim1
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
sidePtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
side
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transaPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
transa
      Ptr CChar
diagPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
diag
      Ptr CInt
mPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
m
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
bPtr <- IOArray (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Double
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.trmm Ptr CChar
sidePtr Ptr CChar
uploPtr Ptr CChar
transaPtr Ptr CChar
diagPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
bPtr Ptr CInt
ldbPtr

trmv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   IOArray ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
trmv :: Char
-> Char
-> Char
-> Array (ZeroInt, ZeroInt) Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
trmv Char
uplo Char
trans Char
diag Array (ZeroInt, ZeroInt) Double
a IOArray ZeroInt Double
x Int
incx = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
x
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _xSize :: Int
_xSize = Int
xDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CChar
diagPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
diag
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
xPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.trmv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
xPtr Ptr CInt
incxPtr

trsm ::
   Char {- ^ side -} ->
   Char {- ^ uplo -} ->
   Char {- ^ transa -} ->
   Char {- ^ diag -} ->
   Int {- ^ m -} ->
   Double {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   IOArray (ZeroInt,ZeroInt) Double {- ^ b -} ->
   IO ()
trsm :: Char
-> Char
-> Char
-> Char
-> Int
-> Double
-> Array (ZeroInt, ZeroInt) Double
-> IOArray (ZeroInt, ZeroInt) Double
-> IO ()
trsm Char
side Char
uplo Char
transa Char
diag Int
m Double
alpha Array (ZeroInt, ZeroInt) Double
a IOArray (ZeroInt, ZeroInt) Double
b = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let (Int
bDim0,Int
bDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ IOArray (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Double
b
   let _k :: Int
_k = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let n :: Int
n = Int
bDim0
   let ldb :: Int
ldb = Int
bDim1
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
sidePtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
side
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transaPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
transa
      Ptr CChar
diagPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
diag
      Ptr CInt
mPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
m
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
alphaPtr <- Double -> FortranIO () (Ptr Double)
forall r. Double -> FortranIO r (Ptr Double)
Call.double Double
alpha
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
bPtr <- IOArray (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Double
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr CInt
-> Ptr Double
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.trsm Ptr CChar
sidePtr Ptr CChar
uploPtr Ptr CChar
transaPtr Ptr CChar
diagPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr Double
alphaPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
bPtr Ptr CInt
ldbPtr

trsv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Array (ZeroInt,ZeroInt) Double {- ^ a -} ->
   IOArray ZeroInt Double {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
trsv :: Char
-> Char
-> Char
-> Array (ZeroInt, ZeroInt) Double
-> IOArray ZeroInt Double
-> Int
-> IO ()
trsv Char
uplo Char
trans Char
diag Array (ZeroInt, ZeroInt) Double
a IOArray ZeroInt Double
x Int
incx = do
   let (Int
aDim0,Int
aDim1) = (ZeroInt, ZeroInt) -> (Int, Int)
forall sh0 sh1. (C sh0, C sh1) => (sh0, sh1) -> (Int, Int)
Call.sizes2 ((ZeroInt, ZeroInt) -> (Int, Int))
-> (ZeroInt, ZeroInt) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Array (ZeroInt, ZeroInt) Double -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Double
a
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Double -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Double
x
   let n :: Int
n = Int
aDim0
   let lda :: Int
lda = Int
aDim1
   let _xSize :: Int
_xSize = Int
xDim0
   ContT () IO () -> IO ()
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT () IO () -> IO ()) -> ContT () IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
      Ptr CChar
uploPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
uplo
      Ptr CChar
transPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
trans
      Ptr CChar
diagPtr <- Char -> FortranIO () (Ptr CChar)
forall r. Char -> FortranIO r (Ptr CChar)
Call.char Char
diag
      Ptr CInt
nPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Double
aPtr <- Array (ZeroInt, ZeroInt) Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Double
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Double
xPtr <- IOArray ZeroInt Double -> FortranIO () (Ptr Double)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Double
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CChar
-> Ptr CChar
-> Ptr CChar
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> Ptr Double
-> Ptr CInt
-> IO ()
FFI.trsv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr Double
aPtr Ptr CInt
ldaPtr Ptr Double
xPtr Ptr CInt
incxPtr