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

import qualified Numeric.BLAS.FFI.ComplexDouble 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 Double {- ^ za -} ->
   Array ZeroInt (Complex Double) {- ^ zx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt (Complex Double) {- ^ zy -} ->
   Int {- ^ incy -} ->
   IO ()
axpy :: Int
-> Complex Double
-> Array ZeroInt (Complex Double)
-> Int
-> IOArray ZeroInt (Complex Double)
-> Int
-> IO ()
axpy Int
n Complex Double
za Array ZeroInt (Complex Double)
zx Int
incx IOArray ZeroInt (Complex Double)
zy Int
incy = do
   let zxDim0 :: Int
zxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt (Complex Double) -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt (Complex Double)
zx
   let zyDim0 :: Int
zyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Double) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Double)
zy
   String -> Bool -> IO ()
Call.assert String
"axpy: 1+(n-1)*abs(incx) == zxDim0" (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
zxDim0)
   String -> Bool -> IO ()
Call.assert String
"axpy: 1+(n-1)*abs(incy) == zyDim0" (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
zyDim0)
   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 Double)
zaPtr <- Complex Double -> FortranIO () (Ptr (Complex Double))
forall r. Complex Double -> FortranIO r (Ptr (Complex Double))
Call.complexDouble Complex Double
za
      Ptr (Complex Double)
zxPtr <- Array ZeroInt (Complex Double)
-> FortranIO () (Ptr (Complex Double))
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt (Complex Double)
zx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr (Complex Double)
zyPtr <- IOArray ZeroInt (Complex Double)
-> FortranIO () (Ptr (Complex Double))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Double)
zy
      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 Double)
-> Ptr (Complex Double)
-> Ptr CInt
-> Ptr (Complex Double)
-> Ptr CInt
-> IO ()
FFI.axpy Ptr CInt
nPtr Ptr (Complex Double)
zaPtr Ptr (Complex Double)
zxPtr Ptr CInt
incxPtr Ptr (Complex Double)
zyPtr Ptr CInt
incyPtr

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

cnrm2 ::
   Array ZeroInt (Complex Double) {- ^ x -} ->
   Int {- ^ incx -} ->
   IO Double
cnrm2 :: Array ZeroInt (Complex Double) -> Int -> IO Double
cnrm2 Array ZeroInt (Complex Double)
x Int
incx = do
   let xDim0 :: Int
xDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ Array ZeroInt (Complex Double) -> ZeroInt
forall sh a. Array sh a -> sh
Array.shape Array ZeroInt (Complex Double)
x
   let n :: Int
n = Int
xDim0
   ContT Double IO Double -> IO Double
forall (m :: * -> *) r. Monad m => ContT r m r -> m r
evalContT (ContT Double IO Double -> IO Double)
-> ContT Double IO Double -> IO Double
forall a b. (a -> b) -> a -> b
$ do
      Ptr CInt
nPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
n
      Ptr (Complex Double)
xPtr <- Array ZeroInt (Complex Double)
-> FortranIO Double (Ptr (Complex Double))
forall a i r. Storable a => Array i a -> FortranIO r (Ptr a)
Call.array Array ZeroInt (Complex Double)
x
      Ptr CInt
incxPtr <- Int -> FortranIO Double (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      IO Double -> ContT Double IO Double
forall a. IO a -> ContT Double IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> ContT Double IO Double)
-> IO Double -> ContT Double IO Double
forall a b. (a -> b) -> a -> b
$ Ptr CInt -> Ptr (Complex Double) -> Ptr CInt -> IO Double
FFI.cnrm2 Ptr CInt
nPtr Ptr (Complex Double)
xPtr Ptr CInt
incxPtr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

swap ::
   Int {- ^ n -} ->
   IOArray ZeroInt (Complex Double) {- ^ zx -} ->
   Int {- ^ incx -} ->
   IOArray ZeroInt (Complex Double) {- ^ zy -} ->
   Int {- ^ incy -} ->
   IO ()
swap :: Int
-> IOArray ZeroInt (Complex Double)
-> Int
-> IOArray ZeroInt (Complex Double)
-> Int
-> IO ()
swap Int
n IOArray ZeroInt (Complex Double)
zx Int
incx IOArray ZeroInt (Complex Double)
zy Int
incy = do
   let zxDim0 :: Int
zxDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Double) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Double)
zx
   let zyDim0 :: Int
zyDim0 = ZeroInt -> Int
forall sh0. C sh0 => sh0 -> Int
Call.sizes1 (ZeroInt -> Int) -> ZeroInt -> Int
forall a b. (a -> b) -> a -> b
$ IOArray ZeroInt (Complex Double) -> ZeroInt
forall (m :: * -> *) sh a. Array m sh a -> sh
MutArray.shape IOArray ZeroInt (Complex Double)
zy
   String -> Bool -> IO ()
Call.assert String
"swap: 1+(n-1)*abs(incx) == zxDim0" (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
zxDim0)
   String -> Bool -> IO ()
Call.assert String
"swap: 1+(n-1)*abs(incy) == zyDim0" (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
zyDim0)
   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 Double)
zxPtr <- IOArray ZeroInt (Complex Double)
-> FortranIO () (Ptr (Complex Double))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Double)
zx
      Ptr CInt
incxPtr <- Int -> FortranIO () (Ptr CInt)
forall r. Int -> FortranIO r (Ptr CInt)
Call.cint Int
incx
      Ptr (Complex Double)
zyPtr <- IOArray ZeroInt (Complex Double)
-> FortranIO () (Ptr (Complex Double))
forall a i r. Storable a => IOArray i a -> FortranIO r (Ptr a)
Call.ioarray IOArray ZeroInt (Complex Double)
zy
      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 Double)
-> Ptr CInt
-> Ptr (Complex Double)
-> Ptr CInt
-> IO ()
FFI.swap Ptr CInt
nPtr Ptr (Complex Double)
zxPtr Ptr CInt
incxPtr Ptr (Complex Double)
zyPtr Ptr CInt
incyPtr

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

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

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

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

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

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

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

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

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

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

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