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

import qualified Numeric.BLAS.FFI.ComplexFloat 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 Data.Complex (Complex)

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, (<*>))


axpy ::
   Int {- ^ n -} ->
   Complex Float {- ^ ca -} ->
   Array ZeroInt (Complex Float) {- ^ cx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt (Complex Float) {- ^ cy -} ->
   Int {- ^ incy -} ->
   IO ()
axpy :: Int
-> Complex Float
-> Array ZeroInt (Complex Float)
-> Int
-> IOArray ZeroInt (Complex Float)
-> Int
-> IO ()
axpy Int
n Complex Float
ca Array ZeroInt (Complex Float)
cx Int
incx IOArray ZeroInt (Complex Float)
cy Int
incy = do
   let cxDim0 :: Int
cxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt (Complex Float) -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt (Complex Float)
cx
   let cyDim0 :: Int
cyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Float) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Float)
cy
   String -> Bool -> IO ()
Call.assert String
"axpy: 1+(n-1)*abs(incx) == cxDim0" (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
cxDim0)
   String -> Bool -> IO ()
Call.assert String
"axpy: 1+(n-1)*abs(incy) == cyDim0" (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
cyDim0)
   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 (Complex Float)
caPtr <- Complex Float -> FortranIO () (Ptr (Complex Float))
forall r. Complex Float -> FortranIO r (Ptr (Complex Float))
Call.complexFloat Complex Float
ca
      Ptr (Complex Float)
cxPtr <- Array ZeroInt (Complex Float) -> FortranIO () (Ptr (Complex Float))
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt (Complex Float)
cx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr (Complex Float)
cyPtr <- IOArray ZeroInt (Complex Float)
-> FortranIO () (Ptr (Complex Float))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Float)
cy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr (Complex Float)
-> Ptr (Complex Float)
-> Ptr CInt
-> Ptr (Complex Float)
-> Ptr CInt
-> IO ()
FFI.axpy Ptr CInt
nPtr Ptr (Complex Float)
caPtr Ptr (Complex Float)
cxPtr Ptr CInt
incxPtr Ptr (Complex Float)
cyPtr Ptr CInt
incyPtr

casum ::
   Int {- ^ n -} ->
   IOArray ZeroInt (Complex Float) {- ^ cx -} ->
   Int {- ^ incx -} ->
   IO Float
casum :: Int -> IOArray ZeroInt (Complex Float) -> Int -> IO Float
casum Int
n IOArray ZeroInt (Complex Float)
cx Int
incx = do
   let cxDim0 :: Int
cxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Float) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Float)
cx
   String -> Bool -> IO ()
Call.assert String
"casum: 1+(n-1)*abs(incx) == cxDim0" (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
cxDim0)
   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 (Complex Float)
cxPtr <- IOArray ZeroInt (Complex Float)
-> FortranIO Float (Ptr (Complex Float))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Float)
cx
      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 a. IO a -> ContT Float IO a
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 (Complex Float) -> Ptr CInt -> IO Float
FFI.casum Ptr CInt
nPtr Ptr (Complex Float)
cxPtr Ptr CInt
incxPtr

cnrm2 ::
   Array ZeroInt (Complex Float) {- ^ x -} ->
   Int {- ^ incx -} ->
   IO Float
cnrm2 :: Array ZeroInt (Complex Float) -> Int -> IO Float
cnrm2 Array ZeroInt (Complex 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 (Complex Float) -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt (Complex Float)
x
   let n :: Int
n = 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 (Complex Float)
xPtr <- Array ZeroInt (Complex Float)
-> FortranIO Float (Ptr (Complex Float))
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt (Complex 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 a. IO a -> ContT Float IO a
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 (Complex Float) -> Ptr CInt -> IO Float
FFI.cnrm2 Ptr CInt
nPtr Ptr (Complex Float)
xPtr Ptr CInt
incxPtr

copy ::
   Int {- ^ n -} ->
   Array ZeroInt (Complex Float) {- ^ cx -} ->
   Int {- ^ incx -} ->
   Int {- ^ incy -} ->
   IO (Array ZeroInt (Complex Float))
copy :: Int
-> Array ZeroInt (Complex Float)
-> Int
-> Int
-> IO (Array ZeroInt (Complex Float))
copy Int
n Array ZeroInt (Complex Float)
cx Int
incx Int
incy = do
   let cxDim0 :: Int
cxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt (Complex Float) -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt (Complex Float)
cx
   String -> Bool -> IO ()
Call.assert String
"copy: 1+(n-1)*abs(incx) == cxDim0" (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
cxDim0)
   IOArray ZeroInt (Complex Float)
cy <- Int -> IO (IOArray ZeroInt (Complex 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 (Complex Float)) IO (Array ZeroInt (Complex Float))
-> IO (Array ZeroInt (Complex Float))
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT
   (Array ZeroInt (Complex Float)) IO (Array ZeroInt (Complex Float))
 -> IO (Array ZeroInt (Complex Float)))
-> ContT
     (Array ZeroInt (Complex Float)) IO (Array ZeroInt (Complex Float))
-> IO (Array ZeroInt (Complex Float))
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO (Array ZeroInt (Complex Float)) (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr (Complex Float)
cxPtr <- Array ZeroInt (Complex Float)
-> FortranIO (Array ZeroInt (Complex Float)) (Ptr (Complex Float))
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt (Complex Float)
cx
      Ptr CInt
incxPtr <- Int -> FortranIO (Array ZeroInt (Complex Float)) (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr (Complex Float)
cyPtr <- IOArray ZeroInt (Complex Float)
-> FortranIO (Array ZeroInt (Complex Float)) (Ptr (Complex Float))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Float)
cy
      Ptr CInt
incyPtr <- Int -> FortranIO (Array ZeroInt (Complex Float)) (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT (Array ZeroInt (Complex Float)) IO ()
forall a. IO a -> ContT (Array ZeroInt (Complex Float)) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT (Array ZeroInt (Complex Float)) IO ())
-> IO () -> ContT (Array ZeroInt (Complex Float)) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr (Complex Float)
-> Ptr CInt
-> Ptr (Complex Float)
-> Ptr CInt
-> IO ()
FFI.copy Ptr CInt
nPtr Ptr (Complex Float)
cxPtr Ptr CInt
incxPtr Ptr (Complex Float)
cyPtr Ptr CInt
incyPtr
      IO (Array ZeroInt (Complex Float))
-> ContT
     (Array ZeroInt (Complex Float)) IO (Array ZeroInt (Complex Float))
forall a. IO a -> ContT (Array ZeroInt (Complex Float)) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Array ZeroInt (Complex Float))
 -> ContT
      (Array ZeroInt (Complex Float)) IO (Array ZeroInt (Complex Float)))
-> IO (Array ZeroInt (Complex Float))
-> ContT
     (Array ZeroInt (Complex Float)) IO (Array ZeroInt (Complex Float))
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Float)
-> IO (Array ZeroInt (Complex Float))
forall sh e. (C sh, Storable e) => IOArray sh e -> IO (Array sh e)
Call.freezeArray IOArray ZeroInt (Complex Float)
cy

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

iamax ::
   Int {- ^ n -} ->
   Array ZeroInt (Complex Float) {- ^ cx -} ->
   Int {- ^ incx -} ->
   IO CInt
iamax :: Int -> Array ZeroInt (Complex Float) -> Int -> IO CInt
iamax Int
n Array ZeroInt (Complex Float)
cx Int
incx = do
   let cxDim0 :: Int
cxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt (Complex Float) -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt (Complex Float)
cx
   String -> Bool -> IO ()
Call.assert String
"iamax: 1+(n-1)*abs(incx) == cxDim0" (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
cxDim0)
   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 (Complex Float)
cxPtr <- Array ZeroInt (Complex Float)
-> FortranIO CInt (Ptr (Complex Float))
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt (Complex Float)
cx
      Ptr CInt
incxPtr <- Int -> FortranIO CInt (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO CInt -> ContT CInt IO CInt
forall a. IO a -> ContT CInt IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> ContT CInt IO CInt) -> IO CInt -> ContT CInt IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr (Complex Float) -> Ptr CInt -> IO CInt
FFI.iamax Ptr CInt
nPtr Ptr (Complex Float)
cxPtr Ptr CInt
incxPtr

rotg ::
   Complex Float {- ^ ca -} ->
   Complex Float {- ^ cb -} ->
   IO (Float, Complex Float)
rotg :: Complex Float -> Complex Float -> IO (Float, Complex Float)
rotg Complex Float
ca Complex Float
cb = do
   ContT (Float, Complex Float) IO (Float, Complex Float)
-> IO (Float, Complex Float)
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT (Float, Complex Float) IO (Float, Complex Float)
 -> IO (Float, Complex Float))
-> ContT (Float, Complex Float) IO (Float, Complex Float)
-> IO (Float, Complex Float)
forall a b. (a -> b) -> a -> b
$ do
      Ptr (Complex Float)
caPtr <- Complex Float
-> FortranIO (Float, Complex Float) (Ptr (Complex Float))
forall r. Complex Float -> FortranIO r (Ptr (Complex Float))
Call.complexFloat Complex Float
ca
      Ptr (Complex Float)
cbPtr <- Complex Float
-> FortranIO (Float, Complex Float) (Ptr (Complex Float))
forall r. Complex Float -> FortranIO r (Ptr (Complex Float))
Call.complexFloat Complex Float
cb
      Ptr Float
cPtr <- FortranIO (Float, Complex Float) (Ptr Float)
forall a r. Storable a => FortranIO r (Ptr a)
Call.alloca
      Ptr (Complex Float)
sPtr <- FortranIO (Float, Complex Float) (Ptr (Complex Float))
forall a r. Storable a => FortranIO r (Ptr a)
Call.alloca
      IO () -> ContT (Float, Complex Float) IO ()
forall a. IO a -> ContT (Float, Complex Float) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT (Float, Complex Float) IO ())
-> IO () -> ContT (Float, Complex Float) IO ()
forall a b. (a -> b) -> a -> b
$ Ptr (Complex Float)
-> Ptr (Complex Float) -> Ptr Float -> Ptr (Complex Float) -> IO ()
FFI.rotg Ptr (Complex Float)
caPtr Ptr (Complex Float)
cbPtr Ptr Float
cPtr Ptr (Complex Float)
sPtr
      IO (Float, Complex Float)
-> ContT (Float, Complex Float) IO (Float, Complex Float)
forall a. IO a -> ContT (Float, Complex Float) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Float, Complex Float)
 -> ContT (Float, Complex Float) IO (Float, Complex Float))
-> IO (Float, Complex Float)
-> ContT (Float, Complex Float) IO (Float, Complex Float)
forall a b. (a -> b) -> a -> b
$ (Float -> Complex Float -> (Float, Complex Float))
-> IO (Float -> Complex Float -> (Float, Complex Float))
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (,)
         IO (Float -> Complex Float -> (Float, Complex Float))
-> IO Float -> IO (Complex Float -> (Float, Complex Float))
forall a b. IO (a -> b) -> IO a -> IO b
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 (Complex Float -> (Float, Complex Float))
-> IO (Complex Float) -> IO (Float, Complex Float)
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Ptr (Complex Float) -> IO (Complex Float)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Complex Float)
sPtr

rrot ::
   Int {- ^ n -} ->
   IOArray ZeroInt (Complex Float) {- ^ cx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt (Complex Float) {- ^ cy -} ->
   Int {- ^ incy -} ->
   Float {- ^ c -} ->
   Float {- ^ s -} ->
   IO ()
rrot :: Int
-> IOArray ZeroInt (Complex Float)
-> Int
-> IOArray ZeroInt (Complex Float)
-> Int
-> Float
-> Float
-> IO ()
rrot Int
n IOArray ZeroInt (Complex Float)
cx Int
incx IOArray ZeroInt (Complex Float)
cy Int
incy Float
c Float
s = do
   let cxDim0 :: Int
cxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Float) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Float)
cx
   let cyDim0 :: Int
cyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Float) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Float)
cy
   let _cxSize :: Int
_cxSize = Int
cxDim0
   let _cySize :: Int
_cySize = Int
cyDim0
   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 (Complex Float)
cxPtr <- IOArray ZeroInt (Complex Float)
-> FortranIO () (Ptr (Complex Float))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Float)
cx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr (Complex Float)
cyPtr <- IOArray ZeroInt (Complex Float)
-> FortranIO () (Ptr (Complex Float))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Float)
cy
      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 a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr (Complex Float)
-> Ptr CInt
-> Ptr (Complex Float)
-> Ptr CInt
-> Ptr Float
-> Ptr Float
-> IO ()
FFI.rrot Ptr CInt
nPtr Ptr (Complex Float)
cxPtr Ptr CInt
incxPtr Ptr (Complex Float)
cyPtr Ptr CInt
incyPtr Ptr Float
cPtr Ptr Float
sPtr

rscal ::
   Int {- ^ n -} ->
   Float {- ^ sa -} ->
   IOArray ZeroInt (Complex Float) {- ^ cx -} ->
   Int {- ^ incx -} ->
   IO ()
rscal :: Int -> Float -> IOArray ZeroInt (Complex Float) -> Int -> IO ()
rscal Int
n Float
sa IOArray ZeroInt (Complex Float)
cx Int
incx = do
   let cxDim0 :: Int
cxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Float) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Float)
cx
   String -> Bool -> IO ()
Call.assert String
"rscal: 1+(n-1)*abs(incx) == cxDim0" (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
cxDim0)
   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 (Complex Float)
cxPtr <- IOArray ZeroInt (Complex Float)
-> FortranIO () (Ptr (Complex Float))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Float)
cx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr Float -> Ptr (Complex Float) -> Ptr CInt -> IO ()
FFI.rscal Ptr CInt
nPtr Ptr Float
saPtr Ptr (Complex Float)
cxPtr Ptr CInt
incxPtr

scal ::
   Int {- ^ n -} ->
   Complex Float {- ^ ca -} ->
   IOArray ZeroInt (Complex Float) {- ^ cx -} ->
   Int {- ^ incx -} ->
   IO ()
scal :: Int
-> Complex Float -> IOArray ZeroInt (Complex Float) -> Int -> IO ()
scal Int
n Complex Float
ca IOArray ZeroInt (Complex Float)
cx Int
incx = do
   let cxDim0 :: Int
cxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Float) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Float)
cx
   String -> Bool -> IO ()
Call.assert String
"scal: 1+(n-1)*abs(incx) == cxDim0" (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
cxDim0)
   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 (Complex Float)
caPtr <- Complex Float -> FortranIO () (Ptr (Complex Float))
forall r. Complex Float -> FortranIO r (Ptr (Complex Float))
Call.complexFloat Complex Float
ca
      Ptr (Complex Float)
cxPtr <- IOArray ZeroInt (Complex Float)
-> FortranIO () (Ptr (Complex Float))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Float)
cx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr (Complex Float) -> Ptr (Complex Float) -> Ptr CInt -> IO ()
FFI.scal Ptr CInt
nPtr Ptr (Complex Float)
caPtr Ptr (Complex Float)
cxPtr Ptr CInt
incxPtr

swap ::
   Int {- ^ n -} ->
   IOArray ZeroInt (Complex Float) {- ^ cx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt (Complex Float) {- ^ cy -} ->
   Int {- ^ incy -} ->
   IO ()
swap :: Int
-> IOArray ZeroInt (Complex Float)
-> Int
-> IOArray ZeroInt (Complex Float)
-> Int
-> IO ()
swap Int
n IOArray ZeroInt (Complex Float)
cx Int
incx IOArray ZeroInt (Complex Float)
cy Int
incy = do
   let cxDim0 :: Int
cxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Float) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Float)
cx
   let cyDim0 :: Int
cyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Float) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Float)
cy
   String -> Bool -> IO ()
Call.assert String
"swap: 1+(n-1)*abs(incx) == cxDim0" (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
cxDim0)
   String -> Bool -> IO ()
Call.assert String
"swap: 1+(n-1)*abs(incy) == cyDim0" (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
cyDim0)
   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 (Complex Float)
cxPtr <- IOArray ZeroInt (Complex Float)
-> FortranIO () (Ptr (Complex Float))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Float)
cx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr (Complex Float)
cyPtr <- IOArray ZeroInt (Complex Float)
-> FortranIO () (Ptr (Complex Float))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Float)
cy
      Ptr CInt
incyPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incy
      IO () -> ContT () IO ()
forall a. IO a -> ContT () IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ContT () IO ()) -> IO () -> ContT () IO ()
forall a b. (a -> b) -> a -> b
$ Ptr CInt
-> Ptr (Complex Float)
-> Ptr CInt
-> Ptr (Complex Float)
-> Ptr CInt
-> IO ()
FFI.swap Ptr CInt
nPtr Ptr (Complex Float)
cxPtr Ptr CInt
incxPtr Ptr (Complex Float)
cyPtr Ptr CInt
incyPtr

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

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

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

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

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

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

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

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

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

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

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