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

import qualified Numeric.BLAS.FFI.Float 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 Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   IO Float
asum :: Int -> Array ZeroInt Float -> Int -> IO Float
asum Int
n Array ZeroInt Float
sx Int
incx = 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
   String -> Bool -> IO ()
Call.assert String
"asum: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   ContT Float IO Float -> IO Float
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Float IO Float -> IO Float)
-> ContT Float IO Float -> IO Float
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Float
sxPtr <- Array ZeroInt Float -> FortranIO Float (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 Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO Float -> ContT Float IO Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> ContT Float IO Float)
-> IO Float -> ContT Float IO Float
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr Float -> Ptr CInt -> IO Float
FFI.asum Ptr CInt
nPtr Ptr Float
sxPtr Ptr CInt
incxPtr

axpy ::
   Int {- ^ n -} ->
   Float {- ^ sa -} ->
   Array ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Float {- ^ sy -} ->
   Int {- ^ incy -} ->
   IO ()
axpy :: Int
-> Float
-> Array ZeroInt Float
-> Int
-> IOArray ZeroInt Float
-> Int
-> IO ()
axpy Int
n Float
sa Array ZeroInt Float
sx Int
incx IOArray 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
$ IOArray ZeroInt Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
sy
   String -> Bool -> IO ()
Call.assert String
"axpy: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   String -> Bool -> IO ()
Call.assert String
"axpy: 1+(n-1)*abs(incy) == syDim0" (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
syDim0)
   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 Float
saPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
sa
      Ptr Float
sxPtr <- Array ZeroInt Float -> FortranIO () (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 () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
syPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.axpy Ptr CInt
nPtr Ptr Float
saPtr Ptr Float
sxPtr Ptr CInt
incxPtr Ptr Float
syPtr Ptr CInt
incyPtr

copy ::
   Int {- ^ n -} ->
   Array ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   Int {- ^ incy -} ->
   IO (Array ZeroInt Float)
copy :: Int
-> Array ZeroInt Float -> Int -> Int -> IO (Array ZeroInt Float)
copy Int
n Array ZeroInt Float
sx Int
incx 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
   String -> Bool -> IO ()
Call.assert String
"copy: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   IOArray ZeroInt Float
sy <- Int -> IO (IOArray ZeroInt Float)
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 Float) IO (Array ZeroInt Float)
-> IO (Array ZeroInt Float)
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT (Array ZeroInt Float) IO (Array ZeroInt Float)
 -> IO (Array ZeroInt Float))
-> ContT (Array ZeroInt Float) IO (Array ZeroInt Float)
-> IO (Array ZeroInt Float)
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO (Array ZeroInt Float) (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Float
sxPtr <- Array ZeroInt Float -> FortranIO (Array ZeroInt Float) (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 (Array ZeroInt Float) (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
syPtr <- IOArray ZeroInt Float
-> FortranIO (Array ZeroInt Float) (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sy
      Ptr CInt
incyPtr <- Int -> FortranIO (Array ZeroInt Float) (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT (Array ZeroInt Float) IO ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT (Array ZeroInt Float) IO ())
-> IO () -> ContT (Array ZeroInt Float) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr Float -> Ptr CInt -> Ptr Float -> Ptr CInt -> IO ()
FFI.copy Ptr CInt
nPtr Ptr Float
sxPtr Ptr CInt
incxPtr Ptr Float
syPtr Ptr CInt
incyPtr
      IO (Array ZeroInt Float)
-> ContT (Array ZeroInt Float) IO (Array ZeroInt Float)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Array ZeroInt Float)
 -> ContT (Array ZeroInt Float) IO (Array ZeroInt Float))
-> IO (Array ZeroInt Float)
-> ContT (Array ZeroInt Float) IO (Array ZeroInt Float)
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt Float -> IO (Array ZeroInt Float)
forall sh e. (C sh, Storable e) => IOArray sh e -> IO (Array sh e)
Call.freezeArray IOArray ZeroInt Float
sy

dot ::
   Int {- ^ n -} ->
   Array ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Float {- ^ sy -} ->
   Int {- ^ incy -} ->
   IO Float
dot :: Int
-> Array ZeroInt Float
-> Int
-> Array ZeroInt Float
-> Int
-> IO Float
dot Int
n 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
   String -> Bool -> IO ()
Call.assert String
"dot: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   String -> Bool -> IO ()
Call.assert String
"dot: 1+(n-1)*abs(incy) == syDim0" (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
syDim0)
   ContT Float IO Float -> IO Float
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Float IO Float -> IO Float)
-> ContT Float IO Float -> IO Float
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Float
sxPtr <- Array ZeroInt Float -> FortranIO Float (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 Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
syPtr <- Array ZeroInt Float -> FortranIO Float (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 Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO Float -> ContT Float IO Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> ContT Float IO Float)
-> IO Float -> ContT Float IO Float
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr Float -> Ptr CInt -> Ptr Float -> Ptr CInt -> IO Float
FFI.dot Ptr CInt
nPtr Ptr Float
sxPtr Ptr CInt
incxPtr Ptr Float
syPtr Ptr CInt
incyPtr

dsdot ::
   Int {- ^ n -} ->
   Float {- ^ sb -} ->
   Array ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Float {- ^ sy -} ->
   Int {- ^ incy -} ->
   IO Float
dsdot :: Int
-> Float
-> Array ZeroInt Float
-> Int
-> Array ZeroInt Float
-> Int
-> IO Float
dsdot Int
n Float
sb 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
   String -> Bool -> IO ()
Call.assert String
"dsdot: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   String -> Bool -> IO ()
Call.assert String
"dsdot: 1+(n-1)*abs(incx) == syDim0" (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
syDim0)
   ContT Float IO Float -> IO Float
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Float IO Float -> IO Float)
-> ContT Float IO Float -> IO Float
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Float
sbPtr <- Float -> FortranIO Float (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
sb
      Ptr Float
sxPtr <- Array ZeroInt Float -> FortranIO Float (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 Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
syPtr <- Array ZeroInt Float -> FortranIO Float (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 Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO Float -> ContT Float IO Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> ContT Float IO Float)
-> IO Float -> ContT Float IO Float
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO Float
FFI.dsdot Ptr CInt
nPtr Ptr Float
sbPtr Ptr Float
sxPtr Ptr CInt
incxPtr Ptr Float
syPtr Ptr CInt
incyPtr

gbmv ::
   Char {- ^ trans -} ->
   Int {- ^ m -} ->
   Int {- ^ kl -} ->
   Int {- ^ ku -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   Float {- ^ beta -} ->
   IOArray ZeroInt Float {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
gbmv :: Char
-> Int
-> Int
-> Int
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> Array ZeroInt Float
-> Int
-> Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
gbmv Char
trans Int
m Int
kl Int
ku Float
alpha Array (ZeroInt, ZeroInt) Float
a Array ZeroInt Float
x Int
incx Float
beta IOArray ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
betaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
beta
      Ptr Float
yPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.gbmv Ptr CChar
transPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr CInt
klPtr Ptr CInt
kuPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
betaPtr Ptr Float
yPtr Ptr CInt
incyPtr

gemm ::
   Char {- ^ transa -} ->
   Char {- ^ transb -} ->
   Int {- ^ m -} ->
   Int {- ^ k -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ b -} ->
   Float {- ^ beta -} ->
   IOArray (ZeroInt,ZeroInt) Float {- ^ c -} ->
   IO ()
gemm :: Char
-> Char
-> Int
-> Int
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> Array (ZeroInt, ZeroInt) Float
-> Float
-> IOArray (ZeroInt, ZeroInt) Float
-> IO ()
gemm Char
transa Char
transb Int
m Int
k Float
alpha Array (ZeroInt, ZeroInt) Float
a Array (ZeroInt, ZeroInt) Float
b Float
beta IOArray (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
bPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      Ptr Float
betaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
beta
      Ptr Float
cPtr <- IOArray (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Float
c
      Ptr CInt
ldcPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldc
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.gemm Ptr CChar
transaPtr Ptr CChar
transbPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
bPtr Ptr CInt
ldbPtr Ptr Float
betaPtr Ptr Float
cPtr Ptr CInt
ldcPtr

gemv ::
   Char {- ^ trans -} ->
   Int {- ^ m -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   Float {- ^ beta -} ->
   IOArray ZeroInt Float {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
gemv :: Char
-> Int
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> Array ZeroInt Float
-> Int
-> Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
gemv Char
trans Int
m Float
alpha Array (ZeroInt, ZeroInt) Float
a Array ZeroInt Float
x Int
incx Float
beta IOArray ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
betaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
beta
      Ptr Float
yPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.gemv Ptr CChar
transPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
betaPtr Ptr Float
yPtr Ptr CInt
incyPtr

ger ::
   Int {- ^ m -} ->
   Float {- ^ alpha -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Float {- ^ y -} ->
   Int {- ^ incy -} ->
   IOArray (ZeroInt,ZeroInt) Float {- ^ a -} ->
   IO ()
ger :: Int
-> Float
-> Array ZeroInt Float
-> Int
-> Array ZeroInt Float
-> Int
-> IOArray (ZeroInt, ZeroInt) Float
-> IO ()
ger Int
m Float
alpha Array ZeroInt Float
x Int
incx Array ZeroInt Float
y Int
incy IOArray (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
yPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Float
aPtr <- IOArray (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.ger Ptr CInt
mPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
yPtr Ptr CInt
incyPtr Ptr Float
aPtr Ptr CInt
ldaPtr

sbmv ::
   Char {- ^ uplo -} ->
   Int {- ^ k -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   Float {- ^ beta -} ->
   IOArray ZeroInt Float {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
sbmv :: Char
-> Int
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> Array ZeroInt Float
-> Int
-> Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
sbmv Char
uplo Int
k Float
alpha Array (ZeroInt, ZeroInt) Float
a Array ZeroInt Float
x Int
incx Float
beta IOArray ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
betaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
beta
      Ptr Float
yPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.sbmv Ptr CChar
uploPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
betaPtr Ptr Float
yPtr Ptr CInt
incyPtr

symv ::
   Char {- ^ uplo -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   Float {- ^ beta -} ->
   IOArray ZeroInt Float {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
symv :: Char
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> Array ZeroInt Float
-> Int
-> Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
symv Char
uplo Float
alpha Array (ZeroInt, ZeroInt) Float
a Array ZeroInt Float
x Int
incx Float
beta IOArray ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
betaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
beta
      Ptr Float
yPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.symv Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
betaPtr Ptr Float
yPtr Ptr CInt
incyPtr

syr ::
   Char {- ^ uplo -} ->
   Float {- ^ alpha -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   IOArray (ZeroInt,ZeroInt) Float {- ^ a -} ->
   IO ()
syr :: Char
-> Float
-> Array ZeroInt Float
-> Int
-> IOArray (ZeroInt, ZeroInt) Float
-> IO ()
syr Char
uplo Float
alpha Array ZeroInt Float
x Int
incx IOArray (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
aPtr <- IOArray (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.syr Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
aPtr Ptr CInt
ldaPtr

syr2 ::
   Char {- ^ uplo -} ->
   Float {- ^ alpha -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Float {- ^ y -} ->
   Int {- ^ incy -} ->
   IOArray (ZeroInt,ZeroInt) Float {- ^ a -} ->
   IO ()
syr2 :: Char
-> Float
-> Array ZeroInt Float
-> Int
-> Array ZeroInt Float
-> Int
-> IOArray (ZeroInt, ZeroInt) Float
-> IO ()
syr2 Char
uplo Float
alpha Array ZeroInt Float
x Int
incx Array ZeroInt Float
y Int
incy IOArray (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
yPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Float
aPtr <- IOArray (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.syr2 Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
yPtr Ptr CInt
incyPtr Ptr Float
aPtr Ptr CInt
ldaPtr

spmv ::
   Char {- ^ uplo -} ->
   Int {- ^ n -} ->
   Float {- ^ alpha -} ->
   Array ZeroInt Float {- ^ ap -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   Float {- ^ beta -} ->
   IOArray ZeroInt Float {- ^ y -} ->
   Int {- ^ incy -} ->
   IO ()
spmv :: Char
-> Int
-> Float
-> Array ZeroInt Float
-> Array ZeroInt Float
-> Int
-> Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
spmv Char
uplo Int
n Float
alpha Array ZeroInt Float
ap Array ZeroInt Float
x Int
incx Float
beta IOArray ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
apPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
ap
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
betaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
beta
      Ptr Float
yPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.spmv Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
apPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
betaPtr Ptr Float
yPtr Ptr CInt
incyPtr

spr ::
   Char {- ^ uplo -} ->
   Int {- ^ n -} ->
   Float {- ^ alpha -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Float {- ^ ap -} ->
   IO ()
spr :: Char
-> Int
-> Float
-> Array ZeroInt Float
-> Int
-> IOArray ZeroInt Float
-> IO ()
spr Char
uplo Int
n Float
alpha Array ZeroInt Float
x Int
incx IOArray ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
apPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
ap
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> IO ()
FFI.spr Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
apPtr

spr2 ::
   Char {- ^ uplo -} ->
   Int {- ^ n -} ->
   Float {- ^ alpha -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   Array ZeroInt Float {- ^ y -} ->
   Int {- ^ incy -} ->
   IOArray ZeroInt Float {- ^ ap -} ->
   IO ()
spr2 :: Char
-> Int
-> Float
-> Array ZeroInt Float
-> Int
-> Array ZeroInt Float
-> Int
-> IOArray ZeroInt Float
-> IO ()
spr2 Char
uplo Int
n Float
alpha Array ZeroInt Float
x Int
incx Array ZeroInt Float
y Int
incy IOArray ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
yPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
y
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Float
apPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
ap
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> IO ()
FFI.spr2 Ptr CChar
uploPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
xPtr Ptr CInt
incxPtr Ptr Float
yPtr Ptr CInt
incyPtr Ptr Float
apPtr

iamax ::
   Int {- ^ n -} ->
   Array ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   IO CInt
iamax :: Int -> Array ZeroInt Float -> Int -> IO CInt
iamax Int
n Array ZeroInt Float
sx Int
incx = 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
   String -> Bool -> IO ()
Call.assert String
"iamax: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   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 Float
sxPtr <- Array ZeroInt Float -> FortranIO CInt (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 CInt (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO CInt -> ContT CInt IO CInt
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 Float -> Ptr CInt -> IO CInt
FFI.iamax Ptr CInt
nPtr Ptr Float
sxPtr Ptr CInt
incxPtr

nrm2 ::
   Int {- ^ n -} ->
   Array ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   IO Float
nrm2 :: Int -> Array ZeroInt Float -> Int -> IO Float
nrm2 Int
n Array ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float IO Float -> IO Float
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Float IO Float -> IO Float)
-> ContT Float IO Float -> IO Float
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr Float
xPtr <- Array ZeroInt Float -> FortranIO Float (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO Float (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO Float -> ContT Float IO Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> ContT Float IO Float)
-> IO Float -> ContT Float IO Float
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr Float -> Ptr CInt -> IO Float
FFI.nrm2 Ptr CInt
nPtr Ptr Float
xPtr Ptr CInt
incxPtr

rot ::
   Int {- ^ n -} ->
   IOArray ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Float {- ^ sy -} ->
   Int {- ^ incy -} ->
   Float {- ^ c -} ->
   Float {- ^ s -} ->
   IO ()
rot :: Int
-> IOArray ZeroInt Float
-> Int
-> IOArray ZeroInt Float
-> Int
-> Float
-> Float
-> IO ()
rot Int
n IOArray ZeroInt Float
sx Int
incx IOArray ZeroInt Float
sy Int
incy Float
c Float
s = 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
$ IOArray ZeroInt Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray 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
$ IOArray ZeroInt Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
sy
   String -> Bool -> IO ()
Call.assert String
"rot: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   String -> Bool -> IO ()
Call.assert String
"rot: 1+(n-1)*abs(incy) == syDim0" (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
syDim0)
   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 Float
sxPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
syPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Float
cPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
c
      Ptr Float
sPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
s
      IO () -> ContT () IO ()
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 Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> IO ()
FFI.rot Ptr CInt
nPtr Ptr Float
sxPtr Ptr CInt
incxPtr Ptr Float
syPtr Ptr CInt
incyPtr Ptr Float
cPtr Ptr Float
sPtr

rotg ::
   Float {- ^ sa -} ->
   Float {- ^ sb -} ->
   IO (Float, Float)
rotg :: Float -> Float -> IO (Float, Float)
rotg Float
sa Float
sb = do
   ContT (Float, Float) IO (Float, Float) -> IO (Float, Float)
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT (Float, Float) IO (Float, Float) -> IO (Float, Float))
-> ContT (Float, Float) IO (Float, Float) -> IO (Float, Float)
forall a b. (a -> b) -> a -> b
$ do
      Ptr Float
saPtr <- Float -> FortranIO (Float, Float) (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
sa
      Ptr Float
sbPtr <- Float -> FortranIO (Float, Float) (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
sb
      Ptr Float
cPtr <- FortranIO (Float, Float) (Ptr Float)
forall a r. Storable a => FortranIO r (Ptr a)
Call.alloca
      Ptr Float
sPtr <- FortranIO (Float, Float) (Ptr Float)
forall a r. Storable a => FortranIO r (Ptr a)
Call.alloca
      IO () -> ContT (Float, Float) IO ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT (Float, Float) IO ())
-> IO () -> ContT (Float, Float) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Float -> Ptr Float -> Ptr Float -> Ptr Float -> IO ()
FFI.rotg Ptr Float
saPtr Ptr Float
sbPtr Ptr Float
cPtr Ptr Float
sPtr
      IO (Float, Float) -> ContT (Float, Float) IO (Float, Float)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float) -> ContT (Float, Float) IO (Float, Float))
-> IO (Float, Float) -> ContT (Float, Float) IO (Float, Float)
forall a b. (a -> b) -> a -> b
$ (Float -> Float -> (Float, Float))
-> IO (Float -> Float -> (Float, Float))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,)
         IO (Float -> Float -> (Float, Float))
-> IO Float -> IO (Float -> (Float, Float))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Float -> IO Float
forall a. Storable a => Ptr a -> IO a
peek Ptr Float
cPtr
         IO (Float -> (Float, Float)) -> IO Float -> IO (Float, Float)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Float -> IO Float
forall a. Storable a => Ptr a -> IO a
peek Ptr Float
sPtr

rotm ::
   Int {- ^ n -} ->
   IOArray ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Float {- ^ sy -} ->
   Int {- ^ incy -} ->
   Array ZeroInt Float {- ^ sparam -} ->
   IO ()
rotm :: Int
-> IOArray ZeroInt Float
-> Int
-> IOArray ZeroInt Float
-> Int
-> Array ZeroInt Float
-> IO ()
rotm Int
n IOArray ZeroInt Float
sx Int
incx IOArray ZeroInt Float
sy Int
incy Array ZeroInt Float
sparam = 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
$ IOArray ZeroInt Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray 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
$ IOArray ZeroInt Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
sy
   let sparamDim0 :: Int
sparamDim0 = 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
sparam
   String -> Bool -> IO ()
Call.assert String
"rotm: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   String -> Bool -> IO ()
Call.assert String
"rotm: 1+(n-1)*abs(incy) == syDim0" (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
syDim0)
   String -> Bool -> IO ()
Call.assert String
"rotm: 5 == sparamDim0" (Int
5 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
sparamDim0)
   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 Float
sxPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
syPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      Ptr Float
sparamPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
sparam
      IO () -> ContT () IO ()
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 Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> IO ()
FFI.rotm Ptr CInt
nPtr Ptr Float
sxPtr Ptr CInt
incxPtr Ptr Float
syPtr Ptr CInt
incyPtr Ptr Float
sparamPtr

rotmg ::
   Float {- ^ sd1 -} ->
   Float {- ^ sd2 -} ->
   Float {- ^ sx1 -} ->
   Float {- ^ sy1 -} ->
   IO (Float, Float, Float, Array ZeroInt Float)
rotmg :: Float
-> Float
-> Float
-> Float
-> IO (Float, Float, Float, Array ZeroInt Float)
rotmg Float
sd1 Float
sd2 Float
sx1 Float
sy1 = do
   IOArray ZeroInt Float
sparam <- Int -> IO (IOArray ZeroInt Float)
forall e. Storable e => Int -> IO (IOArray ZeroInt e)
Call.newArray1 Int
5
   ContT
  (Float, Float, Float, Array ZeroInt Float)
  IO
  (Float, Float, Float, Array ZeroInt Float)
-> IO (Float, Float, Float, Array ZeroInt Float)
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT
   (Float, Float, Float, Array ZeroInt Float)
   IO
   (Float, Float, Float, Array ZeroInt Float)
 -> IO (Float, Float, Float, Array ZeroInt Float))
-> ContT
     (Float, Float, Float, Array ZeroInt Float)
     IO
     (Float, Float, Float, Array ZeroInt Float)
-> IO (Float, Float, Float, Array ZeroInt Float)
forall a b. (a -> b) -> a -> b
$ do
      Ptr Float
sd1Ptr <- Float
-> FortranIO (Float, Float, Float, Array ZeroInt Float) (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
sd1
      Ptr Float
sd2Ptr <- Float
-> FortranIO (Float, Float, Float, Array ZeroInt Float) (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
sd2
      Ptr Float
sx1Ptr <- Float
-> FortranIO (Float, Float, Float, Array ZeroInt Float) (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
sx1
      Ptr Float
sy1Ptr <- Float
-> FortranIO (Float, Float, Float, Array ZeroInt Float) (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
sy1
      Ptr Float
sparamPtr <- IOArray ZeroInt Float
-> FortranIO (Float, Float, Float, Array ZeroInt Float) (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sparam
      IO () -> ContT (Float, Float, Float, Array ZeroInt Float) IO ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT (Float, Float, Float, Array ZeroInt Float) IO ())
-> IO () -> ContT (Float, Float, Float, Array ZeroInt Float) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr Float
-> Ptr Float -> Ptr Float -> Ptr Float -> Ptr Float -> IO ()
FFI.rotmg Ptr Float
sd1Ptr Ptr Float
sd2Ptr Ptr Float
sx1Ptr Ptr Float
sy1Ptr Ptr Float
sparamPtr
      IO (Float, Float, Float, Array ZeroInt Float)
-> ContT
     (Float, Float, Float, Array ZeroInt Float)
     IO
     (Float, Float, Float, Array ZeroInt Float)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Float, Float, Array ZeroInt Float)
 -> ContT
      (Float, Float, Float, Array ZeroInt Float)
      IO
      (Float, Float, Float, Array ZeroInt Float))
-> IO (Float, Float, Float, Array ZeroInt Float)
-> ContT
     (Float, Float, Float, Array ZeroInt Float)
     IO
     (Float, Float, Float, Array ZeroInt Float)
forall a b. (a -> b) -> a -> b
$ (Float
 -> Float
 -> Float
 -> Array ZeroInt Float
 -> (Float, Float, Float, Array ZeroInt Float))
-> IO
     (Float
      -> Float
      -> Float
      -> Array ZeroInt Float
      -> (Float, Float, Float, Array ZeroInt Float))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,,,)
         IO
  (Float
   -> Float
   -> Float
   -> Array ZeroInt Float
   -> (Float, Float, Float, Array ZeroInt Float))
-> IO Float
-> IO
     (Float
      -> Float
      -> Array ZeroInt Float
      -> (Float, Float, Float, Array ZeroInt Float))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Float -> IO Float
forall a. Storable a => Ptr a -> IO a
peek Ptr Float
sd1Ptr
         IO
  (Float
   -> Float
   -> Array ZeroInt Float
   -> (Float, Float, Float, Array ZeroInt Float))
-> IO Float
-> IO
     (Float
      -> Array ZeroInt Float
      -> (Float, Float, Float, Array ZeroInt Float))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Float -> IO Float
forall a. Storable a => Ptr a -> IO a
peek Ptr Float
sd2Ptr
         IO
  (Float
   -> Array ZeroInt Float
   -> (Float, Float, Float, Array ZeroInt Float))
-> IO Float
-> IO
     (Array ZeroInt Float -> (Float, Float, Float, Array ZeroInt Float))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr Float -> IO Float
forall a. Storable a => Ptr a -> IO a
peek Ptr Float
sx1Ptr
         IO
  (Array ZeroInt Float -> (Float, Float, Float, Array ZeroInt Float))
-> IO (Array ZeroInt Float)
-> IO (Float, Float, Float, Array ZeroInt Float)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IOArray ZeroInt Float -> IO (Array ZeroInt Float)
forall sh e. (C sh, Storable e) => IOArray sh e -> IO (Array sh e)
Call.freezeArray IOArray ZeroInt Float
sparam

scal ::
   Int {- ^ n -} ->
   Float {- ^ sa -} ->
   IOArray ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   IO ()
scal :: Int -> Float -> IOArray ZeroInt Float -> Int -> IO ()
scal Int
n Float
sa IOArray ZeroInt Float
sx Int
incx = 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
$ IOArray ZeroInt Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
sx
   String -> Bool -> IO ()
Call.assert String
"scal: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   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 Float
saPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
sa
      Ptr Float
sxPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
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 Float -> Ptr Float -> Ptr CInt -> IO ()
FFI.scal Ptr CInt
nPtr Ptr Float
saPtr Ptr Float
sxPtr Ptr CInt
incxPtr

swap ::
   Int {- ^ n -} ->
   IOArray ZeroInt Float {- ^ sx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt Float {- ^ sy -} ->
   Int {- ^ incy -} ->
   IO ()
swap :: Int
-> IOArray ZeroInt Float
-> Int
-> IOArray ZeroInt Float
-> Int
-> IO ()
swap Int
n IOArray ZeroInt Float
sx Int
incx IOArray 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
$ IOArray ZeroInt Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray 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
$ IOArray ZeroInt Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
sy
   String -> Bool -> IO ()
Call.assert String
"swap: 1+(n-1)*abs(incx) == sxDim0" (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
sxDim0)
   String -> Bool -> IO ()
Call.assert String
"swap: 1+(n-1)*abs(incy) == syDim0" (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
syDim0)
   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 Float
sxPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr Float
syPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
sy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
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 Float -> Ptr CInt -> Ptr Float -> Ptr CInt -> IO ()
FFI.swap Ptr CInt
nPtr Ptr Float
sxPtr Ptr CInt
incxPtr Ptr Float
syPtr Ptr CInt
incyPtr

symm ::
   Char {- ^ side -} ->
   Char {- ^ uplo -} ->
   Int {- ^ m -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ b -} ->
   Float {- ^ beta -} ->
   IOArray (ZeroInt,ZeroInt) Float {- ^ c -} ->
   IO ()
symm :: Char
-> Char
-> Int
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> Array (ZeroInt, ZeroInt) Float
-> Float
-> IOArray (ZeroInt, ZeroInt) Float
-> IO ()
symm Char
side Char
uplo Int
m Float
alpha Array (ZeroInt, ZeroInt) Float
a Array (ZeroInt, ZeroInt) Float
b Float
beta IOArray (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
bPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      Ptr Float
betaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
beta
      Ptr Float
cPtr <- IOArray (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Float
c
      Ptr CInt
ldcPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldc
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.symm Ptr CChar
sidePtr Ptr CChar
uploPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
bPtr Ptr CInt
ldbPtr Ptr Float
betaPtr Ptr Float
cPtr Ptr CInt
ldcPtr

syr2k ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Int {- ^ k -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ b -} ->
   Float {- ^ beta -} ->
   IOArray (ZeroInt,ZeroInt) Float {- ^ c -} ->
   IO ()
syr2k :: Char
-> Char
-> Int
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> Array (ZeroInt, ZeroInt) Float
-> Float
-> IOArray (ZeroInt, ZeroInt) Float
-> IO ()
syr2k Char
uplo Char
trans Int
k Float
alpha Array (ZeroInt, ZeroInt) Float
a Array (ZeroInt, ZeroInt) Float
b Float
beta IOArray (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
bPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      Ptr Float
betaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
beta
      Ptr Float
cPtr <- IOArray (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Float
c
      Ptr CInt
ldcPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldc
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.syr2k Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
bPtr Ptr CInt
ldbPtr Ptr Float
betaPtr Ptr Float
cPtr Ptr CInt
ldcPtr

syrk ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Int {- ^ k -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   Float {- ^ beta -} ->
   IOArray (ZeroInt,ZeroInt) Float {- ^ c -} ->
   IO ()
syrk :: Char
-> Char
-> Int
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> Float
-> IOArray (ZeroInt, ZeroInt) Float
-> IO ()
syrk Char
uplo Char
trans Int
k Float
alpha Array (ZeroInt, ZeroInt) Float
a Float
beta IOArray (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
betaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
beta
      Ptr Float
cPtr <- IOArray (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Float
c
      Ptr CInt
ldcPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldc
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.syrk Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
betaPtr Ptr Float
cPtr Ptr CInt
ldcPtr

tbmv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Int {- ^ k -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   IOArray ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
tbmv :: Char
-> Char
-> Char
-> Int
-> Array (ZeroInt, ZeroInt) Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
tbmv Char
uplo Char
trans Char
diag Int
k Array (ZeroInt, ZeroInt) Float
a IOArray ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
xPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
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 Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.tbmv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
xPtr Ptr CInt
incxPtr

tbsv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Int {- ^ k -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   IOArray ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
tbsv :: Char
-> Char
-> Char
-> Int
-> Array (ZeroInt, ZeroInt) Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
tbsv Char
uplo Char
trans Char
diag Int
k Array (ZeroInt, ZeroInt) Float
a IOArray ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
xPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
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 Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.tbsv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr CInt
kPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
xPtr Ptr CInt
incxPtr

tpmv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Int {- ^ n -} ->
   Array ZeroInt Float {- ^ ap -} ->
   IOArray ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
tpmv :: Char
-> Char
-> Char
-> Int
-> Array ZeroInt Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
tpmv Char
uplo Char
trans Char
diag Int
n Array ZeroInt Float
ap IOArray ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
apPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
ap
      Ptr Float
xPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.tpmv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr Float
apPtr Ptr Float
xPtr Ptr CInt
incxPtr

tpsv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Int {- ^ n -} ->
   Array ZeroInt Float {- ^ ap -} ->
   IOArray ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
tpsv :: Char
-> Char
-> Char
-> Int
-> Array ZeroInt Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
tpsv Char
uplo Char
trans Char
diag Int
n Array ZeroInt Float
ap IOArray ZeroInt Float
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 Float -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
apPtr <- Array ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt Float
ap
      Ptr Float
xPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.tpsv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr Float
apPtr Ptr Float
xPtr Ptr CInt
incxPtr

trmm ::
   Char {- ^ side -} ->
   Char {- ^ uplo -} ->
   Char {- ^ transa -} ->
   Char {- ^ diag -} ->
   Int {- ^ m -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   IOArray (ZeroInt,ZeroInt) Float {- ^ b -} ->
   IO ()
trmm :: Char
-> Char
-> Char
-> Char
-> Int
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> IOArray (ZeroInt, ZeroInt) Float
-> IO ()
trmm Char
side Char
uplo Char
transa Char
diag Int
m Float
alpha Array (ZeroInt, ZeroInt) Float
a IOArray (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
bPtr <- IOArray (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Float
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.trmm Ptr CChar
sidePtr Ptr CChar
uploPtr Ptr CChar
transaPtr Ptr CChar
diagPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
bPtr Ptr CInt
ldbPtr

trmv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   IOArray ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
trmv :: Char
-> Char
-> Char
-> Array (ZeroInt, ZeroInt) Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
trmv Char
uplo Char
trans Char
diag Array (ZeroInt, ZeroInt) Float
a IOArray ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
xPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
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 Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.trmv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
xPtr Ptr CInt
incxPtr

trsm ::
   Char {- ^ side -} ->
   Char {- ^ uplo -} ->
   Char {- ^ transa -} ->
   Char {- ^ diag -} ->
   Int {- ^ m -} ->
   Float {- ^ alpha -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   IOArray (ZeroInt,ZeroInt) Float {- ^ b -} ->
   IO ()
trsm :: Char
-> Char
-> Char
-> Char
-> Int
-> Float
-> Array (ZeroInt, ZeroInt) Float
-> IOArray (ZeroInt, ZeroInt) Float
-> IO ()
trsm Char
side Char
uplo Char
transa Char
diag Int
m Float
alpha Array (ZeroInt, ZeroInt) Float
a IOArray (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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) Float -> (ZeroInt, ZeroInt)
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray (ZeroInt, ZeroInt) Float
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 Float
alphaPtr <- Float -> FortranIO () (Ptr Float)
forall r. Float -> FortranIO r (Ptr Float)
Call.float Float
alpha
      Ptr Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
bPtr <- IOArray (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray (ZeroInt, ZeroInt) Float
b
      Ptr CInt
ldbPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
ldb
      IO () -> ContT () IO ()
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 Float
-> Ptr Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.trsm Ptr CChar
sidePtr Ptr CChar
uploPtr Ptr CChar
transaPtr Ptr CChar
diagPtr Ptr CInt
mPtr Ptr CInt
nPtr Ptr Float
alphaPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
bPtr Ptr CInt
ldbPtr

trsv ::
   Char {- ^ uplo -} ->
   Char {- ^ trans -} ->
   Char {- ^ diag -} ->
   Array (ZeroInt,ZeroInt) Float {- ^ a -} ->
   IOArray ZeroInt Float {- ^ x -} ->
   Int {- ^ incx -} ->
   IO ()
trsv :: Char
-> Char
-> Char
-> Array (ZeroInt, ZeroInt) Float
-> IOArray ZeroInt Float
-> Int
-> IO ()
trsv Char
uplo Char
trans Char
diag Array (ZeroInt, ZeroInt) Float
a IOArray ZeroInt Float
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) Float -> (ZeroInt, ZeroInt)
forall sh a. Array sh a -> sh
Array.shape Array (ZeroInt, ZeroInt) Float
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 Float -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt Float
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 Float
aPtr <- Array (ZeroInt, ZeroInt) Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array (ZeroInt, ZeroInt) Float
a
      Ptr CInt
ldaPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
lda
      Ptr Float
xPtr <- IOArray ZeroInt Float -> FortranIO () (Ptr Float)
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt Float
x
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
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 Float
-> Ptr CInt
-> Ptr Float
-> Ptr CInt
-> IO ()
FFI.trsv Ptr CChar
uploPtr Ptr CChar
transPtr Ptr CChar
diagPtr Ptr CInt
nPtr Ptr Float
aPtr Ptr CInt
ldaPtr Ptr Float
xPtr Ptr CInt
incxPtr