{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE TypeFamilies #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Numeric.Vectorized
-- Copyright   :  (c) Alberto Ruiz 2007-15
-- License     :  BSD3
-- Maintainer  :  Alberto Ruiz
-- Stability   :  provisional
--
-- Low level interface to vector operations.
--
-----------------------------------------------------------------------------

module Internal.Vectorized where

import Internal.Vector
import Internal.Devel
import Data.Complex
import Foreign.Marshal.Alloc(free,malloc)
import Foreign.Marshal.Array(newArray,copyArray)
import Foreign.Ptr(Ptr)
import Foreign.Storable(peek,Storable)
import Foreign.C.Types
import Foreign.C.String
import System.IO.Unsafe(unsafePerformIO)
import Control.Monad(when)

infixr 1 #
(#) :: TransArray c => c -> (b -> IO r) -> TransRaw c b -> IO r
c
a # :: forall c b r.
TransArray c =>
c -> (b -> IO r) -> TransRaw c b -> IO r
# b -> IO r
b = forall c b r.
TransArray c =>
c -> (b -> IO r) -> TransRaw c b -> IO r
applyRaw c
a b -> IO r
b
{-# INLINE (#) #-}

(#!) :: (TransArray c, TransArray c1) => c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
c1
a #! :: forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! c
b = c1
a forall c b r.
TransArray c =>
c -> (b -> IO r) -> TransRaw c b -> IO r
# c
b forall c b r.
TransArray c =>
c -> (b -> IO r) -> TransRaw c b -> IO r
# forall a. a -> a
id
{-# INLINE (#!) #-}

fromei :: Enum a => a -> CInt
fromei :: forall a. Enum a => a -> CInt
fromei a
x = forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. Enum a => a -> Int
fromEnum a
x) :: CInt

data FunCodeV = Sin
              | Cos
              | Tan
              | Abs
              | ASin
              | ACos
              | ATan
              | Sinh
              | Cosh
              | Tanh
              | ASinh
              | ACosh
              | ATanh
              | Exp
              | Log
              | Sign
              | Sqrt
              deriving Int -> FunCodeV
FunCodeV -> Int
FunCodeV -> [FunCodeV]
FunCodeV -> FunCodeV
FunCodeV -> FunCodeV -> [FunCodeV]
FunCodeV -> FunCodeV -> FunCodeV -> [FunCodeV]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: FunCodeV -> FunCodeV -> FunCodeV -> [FunCodeV]
$cenumFromThenTo :: FunCodeV -> FunCodeV -> FunCodeV -> [FunCodeV]
enumFromTo :: FunCodeV -> FunCodeV -> [FunCodeV]
$cenumFromTo :: FunCodeV -> FunCodeV -> [FunCodeV]
enumFromThen :: FunCodeV -> FunCodeV -> [FunCodeV]
$cenumFromThen :: FunCodeV -> FunCodeV -> [FunCodeV]
enumFrom :: FunCodeV -> [FunCodeV]
$cenumFrom :: FunCodeV -> [FunCodeV]
fromEnum :: FunCodeV -> Int
$cfromEnum :: FunCodeV -> Int
toEnum :: Int -> FunCodeV
$ctoEnum :: Int -> FunCodeV
pred :: FunCodeV -> FunCodeV
$cpred :: FunCodeV -> FunCodeV
succ :: FunCodeV -> FunCodeV
$csucc :: FunCodeV -> FunCodeV
Enum

data FunCodeSV = Scale
               | Recip
               | AddConstant
               | Negate
               | PowSV
               | PowVS
               | ModSV
               | ModVS
               deriving Int -> FunCodeSV
FunCodeSV -> Int
FunCodeSV -> [FunCodeSV]
FunCodeSV -> FunCodeSV
FunCodeSV -> FunCodeSV -> [FunCodeSV]
FunCodeSV -> FunCodeSV -> FunCodeSV -> [FunCodeSV]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: FunCodeSV -> FunCodeSV -> FunCodeSV -> [FunCodeSV]
$cenumFromThenTo :: FunCodeSV -> FunCodeSV -> FunCodeSV -> [FunCodeSV]
enumFromTo :: FunCodeSV -> FunCodeSV -> [FunCodeSV]
$cenumFromTo :: FunCodeSV -> FunCodeSV -> [FunCodeSV]
enumFromThen :: FunCodeSV -> FunCodeSV -> [FunCodeSV]
$cenumFromThen :: FunCodeSV -> FunCodeSV -> [FunCodeSV]
enumFrom :: FunCodeSV -> [FunCodeSV]
$cenumFrom :: FunCodeSV -> [FunCodeSV]
fromEnum :: FunCodeSV -> Int
$cfromEnum :: FunCodeSV -> Int
toEnum :: Int -> FunCodeSV
$ctoEnum :: Int -> FunCodeSV
pred :: FunCodeSV -> FunCodeSV
$cpred :: FunCodeSV -> FunCodeSV
succ :: FunCodeSV -> FunCodeSV
$csucc :: FunCodeSV -> FunCodeSV
Enum

data FunCodeVV = Add
               | Sub
               | Mul
               | Div
               | Pow
               | ATan2
               | Mod
               deriving Int -> FunCodeVV
FunCodeVV -> Int
FunCodeVV -> [FunCodeVV]
FunCodeVV -> FunCodeVV
FunCodeVV -> FunCodeVV -> [FunCodeVV]
FunCodeVV -> FunCodeVV -> FunCodeVV -> [FunCodeVV]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: FunCodeVV -> FunCodeVV -> FunCodeVV -> [FunCodeVV]
$cenumFromThenTo :: FunCodeVV -> FunCodeVV -> FunCodeVV -> [FunCodeVV]
enumFromTo :: FunCodeVV -> FunCodeVV -> [FunCodeVV]
$cenumFromTo :: FunCodeVV -> FunCodeVV -> [FunCodeVV]
enumFromThen :: FunCodeVV -> FunCodeVV -> [FunCodeVV]
$cenumFromThen :: FunCodeVV -> FunCodeVV -> [FunCodeVV]
enumFrom :: FunCodeVV -> [FunCodeVV]
$cenumFrom :: FunCodeVV -> [FunCodeVV]
fromEnum :: FunCodeVV -> Int
$cfromEnum :: FunCodeVV -> Int
toEnum :: Int -> FunCodeVV
$ctoEnum :: Int -> FunCodeVV
pred :: FunCodeVV -> FunCodeVV
$cpred :: FunCodeVV -> FunCodeVV
succ :: FunCodeVV -> FunCodeVV
$csucc :: FunCodeVV -> FunCodeVV
Enum

data FunCodeS = Norm2
              | AbsSum
              | MaxIdx
              | Max
              | MinIdx
              | Min
              deriving Int -> FunCodeS
FunCodeS -> Int
FunCodeS -> [FunCodeS]
FunCodeS -> FunCodeS
FunCodeS -> FunCodeS -> [FunCodeS]
FunCodeS -> FunCodeS -> FunCodeS -> [FunCodeS]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: FunCodeS -> FunCodeS -> FunCodeS -> [FunCodeS]
$cenumFromThenTo :: FunCodeS -> FunCodeS -> FunCodeS -> [FunCodeS]
enumFromTo :: FunCodeS -> FunCodeS -> [FunCodeS]
$cenumFromTo :: FunCodeS -> FunCodeS -> [FunCodeS]
enumFromThen :: FunCodeS -> FunCodeS -> [FunCodeS]
$cenumFromThen :: FunCodeS -> FunCodeS -> [FunCodeS]
enumFrom :: FunCodeS -> [FunCodeS]
$cenumFrom :: FunCodeS -> [FunCodeS]
fromEnum :: FunCodeS -> Int
$cfromEnum :: FunCodeS -> Int
toEnum :: Int -> FunCodeS
$ctoEnum :: Int -> FunCodeS
pred :: FunCodeS -> FunCodeS
$cpred :: FunCodeS -> FunCodeS
succ :: FunCodeS -> FunCodeS
$csucc :: FunCodeS -> FunCodeS
Enum

------------------------------------------------------------------

-- | sum of elements
sumF :: Vector Float -> Float
sumF :: Vector Float -> Float
sumF = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
sumg TVV Float
c_sumF

-- | sum of elements
sumR :: Vector Double -> Double
sumR :: Vector Double -> Double
sumR = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
sumg TVV Double
c_sumR

-- | sum of elements
sumQ :: Vector (Complex Float) -> Complex Float
sumQ :: Vector (Complex Float) -> Complex Float
sumQ = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
sumg TVV (Complex Float)
c_sumQ

-- | sum of elements
sumC :: Vector (Complex Double) -> Complex Double
sumC :: Vector (Complex Double) -> Complex Double
sumC = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
sumg TVV (Complex Double)
c_sumC

sumI :: ( TransRaw c (CInt -> Ptr a -> IO CInt) ~ (CInt -> Ptr I -> I :> Ok)
        , TransArray c
        , Storable a
        )
     => I -> c -> a
sumI :: forall c a.
(TransRaw c (CInt -> Ptr a -> IO CInt)
 ~ (CInt -> Ptr CInt -> CInt :> IO CInt),
 TransArray c, Storable a) =>
CInt -> c -> a
sumI CInt
m = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
sumg (CInt -> CInt -> Ptr CInt -> CInt :> IO CInt
c_sumI CInt
m)

sumL :: ( TransRaw c (CInt -> Ptr a -> IO CInt) ~ (CInt -> Ptr Z -> Z :> Ok)
        , TransArray c
        , Storable a
        ) => Z -> c -> a
sumL :: forall c a.
(TransRaw c (CInt -> Ptr a -> IO CInt)
 ~ (CInt -> Ptr Z -> Z :> IO CInt),
 TransArray c, Storable a) =>
Z -> c -> a
sumL Z
m = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
sumg (Z -> CInt -> Ptr Z -> Z :> IO CInt
c_sumL Z
m)

sumg :: (TransArray c, Storable a) => TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
sumg :: forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
sumg TransRaw c (CInt -> Ptr a -> IO CInt)
f c
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a
r <- forall a. Storable a => Int -> IO (Vector a)
createVector Int
1
    (c
x forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector a
r) TransRaw c (CInt -> Ptr a -> IO CInt)
f IO CInt -> String -> IO ()
#| String
"sum"
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Vector a
r forall t. Storable t => Vector t -> Int -> t
@> Int
0

type TVV t = t :> t :> Ok

foreign import ccall unsafe "sumF" c_sumF :: TVV Float
foreign import ccall unsafe "sumR" c_sumR :: TVV Double
foreign import ccall unsafe "sumQ" c_sumQ :: TVV (Complex Float)
foreign import ccall unsafe "sumC" c_sumC :: TVV (Complex Double)
foreign import ccall unsafe "sumI" c_sumI :: I -> TVV I
foreign import ccall unsafe "sumL" c_sumL :: Z -> TVV Z

-- | product of elements
prodF :: Vector Float -> Float
prodF :: Vector Float -> Float
prodF = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
prodg TVV Float
c_prodF

-- | product of elements
prodR :: Vector Double -> Double
prodR :: Vector Double -> Double
prodR = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
prodg TVV Double
c_prodR

-- | product of elements
prodQ :: Vector (Complex Float) -> Complex Float
prodQ :: Vector (Complex Float) -> Complex Float
prodQ = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
prodg TVV (Complex Float)
c_prodQ

-- | product of elements
prodC :: Vector (Complex Double) -> Complex Double
prodC :: Vector (Complex Double) -> Complex Double
prodC = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
prodg TVV (Complex Double)
c_prodC

prodI :: I-> Vector I -> I
prodI :: CInt -> Vector CInt -> CInt
prodI = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
prodg forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> CInt -> Ptr CInt -> CInt :> IO CInt
c_prodI

prodL :: Z-> Vector Z -> Z
prodL :: Z -> Vector Z -> Z
prodL = forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
prodg forall b c a. (b -> c) -> (a -> b) -> a -> c
. Z -> CInt -> Ptr Z -> Z :> IO CInt
c_prodL

prodg :: (TransArray c, Storable a)
      => TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
prodg :: forall c a.
(TransArray c, Storable a) =>
TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
prodg TransRaw c (CInt -> Ptr a -> IO CInt)
f c
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a
r <- forall a. Storable a => Int -> IO (Vector a)
createVector Int
1
    (c
x forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector a
r) TransRaw c (CInt -> Ptr a -> IO CInt)
f IO CInt -> String -> IO ()
#| String
"prod"
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Vector a
r forall t. Storable t => Vector t -> Int -> t
@> Int
0


foreign import ccall unsafe "prodF" c_prodF :: TVV Float
foreign import ccall unsafe "prodR" c_prodR :: TVV Double
foreign import ccall unsafe "prodQ" c_prodQ :: TVV (Complex Float)
foreign import ccall unsafe "prodC" c_prodC :: TVV (Complex Double)
foreign import ccall unsafe "prodI" c_prodI :: I -> TVV I
foreign import ccall unsafe "prodL" c_prodL :: Z -> TVV Z

------------------------------------------------------------------

toScalarAux :: (Enum a, TransArray c, Storable a1)
            => (CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)) -> a -> c -> a1
toScalarAux :: forall a c a1.
(Enum a, TransArray c, Storable a1) =>
(CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)) -> a -> c -> a1
toScalarAux CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)
fun a
code c
v = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a1
r <- forall a. Storable a => Int -> IO (Vector a)
createVector Int
1
    (c
v forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector a1
r) (CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)
fun (forall a. Enum a => a -> CInt
fromei a
code)) IO CInt -> String -> IO ()
#|String
"toScalarAux"
    forall (m :: * -> *) a. Monad m => a -> m a
return (Vector a1
r forall t. Storable t => Vector t -> Int -> t
@> Int
0)


vectorMapAux :: (Enum a, Storable t, Storable a1)
             => (CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
             -> a -> Vector t -> Vector a1
vectorMapAux :: forall a t a1.
(Enum a, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> Vector t -> Vector a1
vectorMapAux CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt
fun a
code Vector t
v = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a1
r <- forall a. Storable a => Int -> IO (Vector a)
createVector (forall t. Storable t => Vector t -> Int
dim Vector t
v)
    (Vector t
v forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector a1
r) (CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt
fun (forall a. Enum a => a -> CInt
fromei a
code)) IO CInt -> String -> IO ()
#|String
"vectorMapAux"
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector a1
r

vectorMapValAux :: (Enum a, Storable a2, Storable t, Storable a1)
                => (CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
                -> a -> a2 -> Vector t -> Vector a1
vectorMapValAux :: forall a a2 t a1.
(Enum a, Storable a2, Storable t, Storable a1) =>
(CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> a2 -> Vector t -> Vector a1
vectorMapValAux CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt
fun a
code a2
val Vector t
v = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a1
r <- forall a. Storable a => Int -> IO (Vector a)
createVector (forall t. Storable t => Vector t -> Int
dim Vector t
v)
    Ptr a2
pval <- forall a. Storable a => [a] -> IO (Ptr a)
newArray [a2
val]
    (Vector t
v forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector a1
r) (CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt
fun (forall a. Enum a => a -> CInt
fromei a
code) Ptr a2
pval) IO CInt -> String -> IO ()
#|String
"vectorMapValAux"
    forall a. Ptr a -> IO ()
free Ptr a2
pval
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector a1
r

vectorZipAux :: (Enum a, TransArray c, Storable t, Storable a1)
             => (CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt))
             -> a -> Vector t -> c -> Vector a1
vectorZipAux :: forall a c t a1.
(Enum a, TransArray c, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt))
-> a -> Vector t -> c -> Vector a1
vectorZipAux CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt)
fun a
code Vector t
u c
v = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a1
r <- forall a. Storable a => Int -> IO (Vector a)
createVector (forall t. Storable t => Vector t -> Int
dim Vector t
u)
    (Vector t
u forall c b r.
TransArray c =>
c -> (b -> IO r) -> TransRaw c b -> IO r
# c
v forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector a1
r) (CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt)
fun (forall a. Enum a => a -> CInt
fromei a
code)) IO CInt -> String -> IO ()
#|String
"vectorZipAux"
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector a1
r

---------------------------------------------------------------------

-- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
toScalarR :: FunCodeS -> Vector Double -> Double
toScalarR :: FunCodeS -> Vector Double -> Double
toScalarR FunCodeS
oper =  forall a c a1.
(Enum a, TransArray c, Storable a1) =>
(CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)) -> a -> c -> a1
toScalarAux CInt -> TVV Double
c_toScalarR (forall a. Enum a => a -> CInt
fromei FunCodeS
oper)

foreign import ccall unsafe "toScalarR" c_toScalarR :: CInt -> TVV Double

-- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
toScalarF :: FunCodeS -> Vector Float -> Float
toScalarF :: FunCodeS -> Vector Float -> Float
toScalarF FunCodeS
oper =  forall a c a1.
(Enum a, TransArray c, Storable a1) =>
(CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)) -> a -> c -> a1
toScalarAux CInt -> TVV Float
c_toScalarF (forall a. Enum a => a -> CInt
fromei FunCodeS
oper)

foreign import ccall unsafe "toScalarF" c_toScalarF :: CInt -> TVV Float

-- | obtains different functions of a vector: only norm1, norm2
toScalarC :: FunCodeS -> Vector (Complex Double) -> Double
toScalarC :: FunCodeS -> Vector (Complex Double) -> Double
toScalarC FunCodeS
oper =  forall a c a1.
(Enum a, TransArray c, Storable a1) =>
(CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)) -> a -> c -> a1
toScalarAux CInt -> Complex Double :> (Double :> IO CInt)
c_toScalarC (forall a. Enum a => a -> CInt
fromei FunCodeS
oper)

foreign import ccall unsafe "toScalarC" c_toScalarC :: CInt -> Complex Double :> Double :> Ok

-- | obtains different functions of a vector: only norm1, norm2
toScalarQ :: FunCodeS -> Vector (Complex Float) -> Float
toScalarQ :: FunCodeS -> Vector (Complex Float) -> Float
toScalarQ FunCodeS
oper =  forall a c a1.
(Enum a, TransArray c, Storable a1) =>
(CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)) -> a -> c -> a1
toScalarAux CInt -> Complex Float :> (Float :> IO CInt)
c_toScalarQ (forall a. Enum a => a -> CInt
fromei FunCodeS
oper)

foreign import ccall unsafe "toScalarQ" c_toScalarQ :: CInt -> Complex Float :> Float :> Ok

-- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
toScalarI :: FunCodeS -> Vector CInt -> CInt
toScalarI :: FunCodeS -> Vector CInt -> CInt
toScalarI FunCodeS
oper =  forall a c a1.
(Enum a, TransArray c, Storable a1) =>
(CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)) -> a -> c -> a1
toScalarAux CInt -> CInt -> Ptr CInt -> CInt :> IO CInt
c_toScalarI (forall a. Enum a => a -> CInt
fromei FunCodeS
oper)

foreign import ccall unsafe "toScalarI" c_toScalarI :: CInt -> TVV CInt

-- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
toScalarL :: FunCodeS -> Vector Z -> Z
toScalarL :: FunCodeS -> Vector Z -> Z
toScalarL FunCodeS
oper =  forall a c a1.
(Enum a, TransArray c, Storable a1) =>
(CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)) -> a -> c -> a1
toScalarAux CInt -> CInt -> Ptr Z -> Z :> IO CInt
c_toScalarL (forall a. Enum a => a -> CInt
fromei FunCodeS
oper)

foreign import ccall unsafe "toScalarL" c_toScalarL :: CInt -> TVV Z


------------------------------------------------------------------

-- | map of real vectors with given function
vectorMapR :: FunCodeV -> Vector Double -> Vector Double
vectorMapR :: FunCodeV -> Vector Double -> Vector Double
vectorMapR = forall a t a1.
(Enum a, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> Vector t -> Vector a1
vectorMapAux CInt -> TVV Double
c_vectorMapR

foreign import ccall unsafe "mapR" c_vectorMapR :: CInt -> TVV Double

-- | map of complex vectors with given function
vectorMapC :: FunCodeV -> Vector (Complex Double) -> Vector (Complex Double)
vectorMapC :: FunCodeV -> Vector (Complex Double) -> Vector (Complex Double)
vectorMapC FunCodeV
oper = forall a t a1.
(Enum a, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> Vector t -> Vector a1
vectorMapAux CInt -> TVV (Complex Double)
c_vectorMapC (forall a. Enum a => a -> CInt
fromei FunCodeV
oper)

foreign import ccall unsafe "mapC" c_vectorMapC :: CInt -> TVV (Complex Double)

-- | map of real vectors with given function
vectorMapF :: FunCodeV -> Vector Float -> Vector Float
vectorMapF :: FunCodeV -> Vector Float -> Vector Float
vectorMapF = forall a t a1.
(Enum a, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> Vector t -> Vector a1
vectorMapAux CInt -> TVV Float
c_vectorMapF

foreign import ccall unsafe "mapF" c_vectorMapF :: CInt -> TVV Float

-- | map of real vectors with given function
vectorMapQ :: FunCodeV -> Vector (Complex Float) -> Vector (Complex Float)
vectorMapQ :: FunCodeV -> Vector (Complex Float) -> Vector (Complex Float)
vectorMapQ = forall a t a1.
(Enum a, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> Vector t -> Vector a1
vectorMapAux CInt -> TVV (Complex Float)
c_vectorMapQ

foreign import ccall unsafe "mapQ" c_vectorMapQ :: CInt -> TVV (Complex Float)

-- | map of real vectors with given function
vectorMapI :: FunCodeV -> Vector CInt -> Vector CInt
vectorMapI :: FunCodeV -> Vector CInt -> Vector CInt
vectorMapI = forall a t a1.
(Enum a, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> Vector t -> Vector a1
vectorMapAux CInt -> CInt -> Ptr CInt -> CInt :> IO CInt
c_vectorMapI

foreign import ccall unsafe "mapI" c_vectorMapI :: CInt -> TVV CInt

-- | map of real vectors with given function
vectorMapL :: FunCodeV -> Vector Z -> Vector Z
vectorMapL :: FunCodeV -> Vector Z -> Vector Z
vectorMapL = forall a t a1.
(Enum a, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> Vector t -> Vector a1
vectorMapAux CInt -> CInt -> Ptr Z -> Z :> IO CInt
c_vectorMapL

foreign import ccall unsafe "mapL" c_vectorMapL :: CInt -> TVV Z

-------------------------------------------------------------------

-- | map of real vectors with given function
vectorMapValR :: FunCodeSV -> Double -> Vector Double -> Vector Double
vectorMapValR :: FunCodeSV -> Double -> Vector Double -> Vector Double
vectorMapValR FunCodeSV
oper = forall a a2 t a1.
(Enum a, Storable a2, Storable t, Storable a1) =>
(CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> a2 -> Vector t -> Vector a1
vectorMapValAux CInt -> Ptr Double -> TVV Double
c_vectorMapValR (forall a. Enum a => a -> CInt
fromei FunCodeSV
oper)

foreign import ccall unsafe "mapValR" c_vectorMapValR :: CInt -> Ptr Double -> TVV Double

-- | map of complex vectors with given function
vectorMapValC :: FunCodeSV -> Complex Double -> Vector (Complex Double) -> Vector (Complex Double)
vectorMapValC :: FunCodeSV
-> Complex Double
-> Vector (Complex Double)
-> Vector (Complex Double)
vectorMapValC = forall a a2 t a1.
(Enum a, Storable a2, Storable t, Storable a1) =>
(CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> a2 -> Vector t -> Vector a1
vectorMapValAux CInt -> Ptr (Complex Double) -> TVV (Complex Double)
c_vectorMapValC

foreign import ccall unsafe "mapValC" c_vectorMapValC :: CInt -> Ptr (Complex Double) -> TVV (Complex Double)

-- | map of real vectors with given function
vectorMapValF :: FunCodeSV -> Float -> Vector Float -> Vector Float
vectorMapValF :: FunCodeSV -> Float -> Vector Float -> Vector Float
vectorMapValF FunCodeSV
oper = forall a a2 t a1.
(Enum a, Storable a2, Storable t, Storable a1) =>
(CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> a2 -> Vector t -> Vector a1
vectorMapValAux CInt -> Ptr Float -> TVV Float
c_vectorMapValF (forall a. Enum a => a -> CInt
fromei FunCodeSV
oper)

foreign import ccall unsafe "mapValF" c_vectorMapValF :: CInt -> Ptr Float -> TVV Float

-- | map of complex vectors with given function
vectorMapValQ :: FunCodeSV -> Complex Float -> Vector (Complex Float) -> Vector (Complex Float)
vectorMapValQ :: FunCodeSV
-> Complex Float
-> Vector (Complex Float)
-> Vector (Complex Float)
vectorMapValQ FunCodeSV
oper = forall a a2 t a1.
(Enum a, Storable a2, Storable t, Storable a1) =>
(CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> a2 -> Vector t -> Vector a1
vectorMapValAux CInt -> Ptr (Complex Float) -> TVV (Complex Float)
c_vectorMapValQ (forall a. Enum a => a -> CInt
fromei FunCodeSV
oper)

foreign import ccall unsafe "mapValQ" c_vectorMapValQ :: CInt -> Ptr (Complex Float) -> TVV (Complex Float)

-- | map of real vectors with given function
vectorMapValI :: FunCodeSV -> CInt -> Vector CInt -> Vector CInt
vectorMapValI :: FunCodeSV -> CInt -> Vector CInt -> Vector CInt
vectorMapValI FunCodeSV
oper = forall a a2 t a1.
(Enum a, Storable a2, Storable t, Storable a1) =>
(CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> a2 -> Vector t -> Vector a1
vectorMapValAux CInt -> Ptr CInt -> CInt -> Ptr CInt -> CInt :> IO CInt
c_vectorMapValI (forall a. Enum a => a -> CInt
fromei FunCodeSV
oper)

foreign import ccall unsafe "mapValI" c_vectorMapValI :: CInt -> Ptr CInt -> TVV CInt

-- | map of real vectors with given function
vectorMapValL :: FunCodeSV -> Z -> Vector Z -> Vector Z
vectorMapValL :: FunCodeSV -> Z -> Vector Z -> Vector Z
vectorMapValL FunCodeSV
oper = forall a a2 t a1.
(Enum a, Storable a2, Storable t, Storable a1) =>
(CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
-> a -> a2 -> Vector t -> Vector a1
vectorMapValAux CInt -> Ptr Z -> CInt -> Ptr Z -> Z :> IO CInt
c_vectorMapValL (forall a. Enum a => a -> CInt
fromei FunCodeSV
oper)

foreign import ccall unsafe "mapValL" c_vectorMapValL :: CInt -> Ptr Z -> TVV Z


-------------------------------------------------------------------

type TVVV t = t :> t :> t :> Ok

-- | elementwise operation on real vectors
vectorZipR :: FunCodeVV -> Vector Double -> Vector Double -> Vector Double
vectorZipR :: FunCodeVV -> Vector Double -> Vector Double -> Vector Double
vectorZipR = forall a c t a1.
(Enum a, TransArray c, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt))
-> a -> Vector t -> c -> Vector a1
vectorZipAux CInt -> CInt -> Ptr Double -> TVV Double
c_vectorZipR

foreign import ccall unsafe "zipR" c_vectorZipR :: CInt -> TVVV Double

-- | elementwise operation on complex vectors
vectorZipC :: FunCodeVV -> Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double)
vectorZipC :: FunCodeVV
-> Vector (Complex Double)
-> Vector (Complex Double)
-> Vector (Complex Double)
vectorZipC = forall a c t a1.
(Enum a, TransArray c, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt))
-> a -> Vector t -> c -> Vector a1
vectorZipAux CInt -> CInt -> Ptr (Complex Double) -> TVV (Complex Double)
c_vectorZipC

foreign import ccall unsafe "zipC" c_vectorZipC :: CInt -> TVVV (Complex Double)

-- | elementwise operation on real vectors
vectorZipF :: FunCodeVV -> Vector Float -> Vector Float -> Vector Float
vectorZipF :: FunCodeVV -> Vector Float -> Vector Float -> Vector Float
vectorZipF = forall a c t a1.
(Enum a, TransArray c, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt))
-> a -> Vector t -> c -> Vector a1
vectorZipAux CInt -> CInt -> Ptr Float -> TVV Float
c_vectorZipF

foreign import ccall unsafe "zipF" c_vectorZipF :: CInt -> TVVV Float

-- | elementwise operation on complex vectors
vectorZipQ :: FunCodeVV -> Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float)
vectorZipQ :: FunCodeVV
-> Vector (Complex Float)
-> Vector (Complex Float)
-> Vector (Complex Float)
vectorZipQ = forall a c t a1.
(Enum a, TransArray c, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt))
-> a -> Vector t -> c -> Vector a1
vectorZipAux CInt -> CInt -> Ptr (Complex Float) -> TVV (Complex Float)
c_vectorZipQ

foreign import ccall unsafe "zipQ" c_vectorZipQ :: CInt -> TVVV (Complex Float)

-- | elementwise operation on CInt vectors
vectorZipI :: FunCodeVV -> Vector CInt -> Vector CInt -> Vector CInt
vectorZipI :: FunCodeVV -> Vector CInt -> Vector CInt -> Vector CInt
vectorZipI = forall a c t a1.
(Enum a, TransArray c, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt))
-> a -> Vector t -> c -> Vector a1
vectorZipAux CInt -> CInt -> Ptr CInt -> CInt -> Ptr CInt -> CInt :> IO CInt
c_vectorZipI

foreign import ccall unsafe "zipI" c_vectorZipI :: CInt -> TVVV CInt

-- | elementwise operation on CInt vectors
vectorZipL :: FunCodeVV -> Vector Z -> Vector Z -> Vector Z
vectorZipL :: FunCodeVV -> Vector Z -> Vector Z -> Vector Z
vectorZipL = forall a c t a1.
(Enum a, TransArray c, Storable t, Storable a1) =>
(CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt))
-> a -> Vector t -> c -> Vector a1
vectorZipAux CInt -> CInt -> Ptr Z -> CInt -> Ptr Z -> Z :> IO CInt
c_vectorZipL

foreign import ccall unsafe "zipL" c_vectorZipL :: CInt -> TVVV Z

--------------------------------------------------------------------------------

foreign import ccall unsafe "vectorScan" c_vectorScan
    :: CString -> Ptr CInt -> Ptr (Ptr Double) -> IO CInt

vectorScan :: FilePath -> IO (Vector Double)
vectorScan :: String -> IO (Vector Double)
vectorScan String
s = do
    Ptr (Ptr Double)
pp <- forall a. Storable a => IO (Ptr a)
malloc
    Ptr CInt
pn <- forall a. Storable a => IO (Ptr a)
malloc
    CString
cs <- String -> IO CString
newCString String
s
    CInt
ok <- CString -> Ptr CInt -> Ptr (Ptr Double) -> IO CInt
c_vectorScan CString
cs Ptr CInt
pn Ptr (Ptr Double)
pp
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not (CInt
ok forall a. Eq a => a -> a -> Bool
== CInt
0)) forall a b. (a -> b) -> a -> b
$
        forall a. HasCallStack => String -> a
error (String
"vectorScan: file \"" forall a. [a] -> [a] -> [a]
++ String
s forall a. [a] -> [a] -> [a]
++String
"\" not found")
    Int
n <- forall a b. (Integral a, Num b) => a -> b
fromIntegral forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
pn
    Ptr Double
p <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Double)
pp
    Vector Double
v <- forall a. Storable a => Int -> IO (Vector a)
createVector Int
n
    forall a. Ptr a -> IO ()
free Ptr CInt
pn
    forall a. Ptr a -> IO ()
free CString
cs
    forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
unsafeWith Vector Double
v forall a b. (a -> b) -> a -> b
$ \Ptr Double
pv -> forall a. Storable a => Ptr a -> Ptr a -> Int -> IO ()
copyArray Ptr Double
pv Ptr Double
p Int
n
    forall a. Ptr a -> IO ()
free Ptr Double
p
    forall a. Ptr a -> IO ()
free Ptr (Ptr Double)
pp
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector Double
v

--------------------------------------------------------------------------------

type Seed = Int

data RandDist = Uniform  -- ^ uniform distribution in [0,1)
              | Gaussian -- ^ normal distribution with mean zero and standard deviation one
              deriving Int -> RandDist
RandDist -> Int
RandDist -> [RandDist]
RandDist -> RandDist
RandDist -> RandDist -> [RandDist]
RandDist -> RandDist -> RandDist -> [RandDist]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: RandDist -> RandDist -> RandDist -> [RandDist]
$cenumFromThenTo :: RandDist -> RandDist -> RandDist -> [RandDist]
enumFromTo :: RandDist -> RandDist -> [RandDist]
$cenumFromTo :: RandDist -> RandDist -> [RandDist]
enumFromThen :: RandDist -> RandDist -> [RandDist]
$cenumFromThen :: RandDist -> RandDist -> [RandDist]
enumFrom :: RandDist -> [RandDist]
$cenumFrom :: RandDist -> [RandDist]
fromEnum :: RandDist -> Int
$cfromEnum :: RandDist -> Int
toEnum :: Int -> RandDist
$ctoEnum :: Int -> RandDist
pred :: RandDist -> RandDist
$cpred :: RandDist -> RandDist
succ :: RandDist -> RandDist
$csucc :: RandDist -> RandDist
Enum

-- | Obtains a vector of pseudorandom elements (use randomIO to get a random seed).
randomVector :: Seed
             -> RandDist -- ^ distribution
             -> Int      -- ^ vector size
             -> Vector Double
randomVector :: Int -> RandDist -> Int -> Vector Double
randomVector Int
seed RandDist
dist Int
n = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector Double
r <- forall a. Storable a => Int -> IO (Vector a)
createVector Int
n
    (Vector Double
r forall c b r.
TransArray c =>
c -> (b -> IO r) -> TransRaw c b -> IO r
# forall a. a -> a
id) (CInt -> CInt -> Double :> IO CInt
c_random_vector (Int -> CInt
fi Int
seed) ((Int -> CInt
fiforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a. Enum a => a -> Int
fromEnum) RandDist
dist)) IO CInt -> String -> IO ()
#|String
"randomVector"
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector Double
r

foreign import ccall unsafe "random_vector" c_random_vector :: CInt -> CInt -> Double :> Ok

--------------------------------------------------------------------------------

roundVector :: Vector Double -> Vector Double
roundVector :: Vector Double -> Vector Double
roundVector Vector Double
v = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector Double
r <- forall a. Storable a => Int -> IO (Vector a)
createVector (forall t. Storable t => Vector t -> Int
dim Vector Double
v)
    (Vector Double
v forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector Double
r) TVV Double
c_round_vector IO CInt -> String -> IO ()
#|String
"roundVector"
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector Double
r

foreign import ccall unsafe "round_vector" c_round_vector :: TVV Double

--------------------------------------------------------------------------------

-- |
-- >>> range 5
-- [0,1,2,3,4]
-- it :: Vector I
--
range :: Int -> Vector I
range :: Int -> Vector CInt
range Int
n = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector CInt
r <- forall a. Storable a => Int -> IO (Vector a)
createVector Int
n
    (Vector CInt
r forall c b r.
TransArray c =>
c -> (b -> IO r) -> TransRaw c b -> IO r
# forall a. a -> a
id) CInt :> IO CInt
c_range_vector IO CInt -> String -> IO ()
#|String
"range"
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector CInt
r

foreign import ccall unsafe "range_vector" c_range_vector :: CInt :> Ok


float2DoubleV :: Vector Float -> Vector Double
float2DoubleV :: Vector Float -> Vector Double
float2DoubleV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog Float :> (Double :> IO CInt)
c_float2double

double2FloatV :: Vector Double -> Vector Float
double2FloatV :: Vector Double -> Vector Float
double2FloatV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog Double :> (Float :> IO CInt)
c_double2float

double2IntV :: Vector Double -> Vector CInt
double2IntV :: Vector Double -> Vector CInt
double2IntV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog Double :> (CInt :> IO CInt)
c_double2int

int2DoubleV :: Vector CInt -> Vector Double
int2DoubleV :: Vector CInt -> Vector Double
int2DoubleV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog CInt :> (Double :> IO CInt)
c_int2double

double2longV :: Vector Double -> Vector Z
double2longV :: Vector Double -> Vector Z
double2longV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog Double :> (Z :> IO CInt)
c_double2long

long2DoubleV :: Vector Z -> Vector Double
long2DoubleV :: Vector Z -> Vector Double
long2DoubleV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog Z :> (Double :> IO CInt)
c_long2double


float2IntV :: Vector Float -> Vector CInt
float2IntV :: Vector Float -> Vector CInt
float2IntV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog Float :> (CInt :> IO CInt)
c_float2int

int2floatV :: Vector CInt -> Vector Float
int2floatV :: Vector CInt -> Vector Float
int2floatV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog CInt :> (Float :> IO CInt)
c_int2float

int2longV :: Vector I -> Vector Z
int2longV :: Vector CInt -> Vector Z
int2longV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog CInt :> (Z :> IO CInt)
c_int2long

long2intV :: Vector Z -> Vector I
long2intV :: Vector Z -> Vector CInt
long2intV = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog Z :> (CInt :> IO CInt)
c_long2int


tog :: (Storable t, Storable a)
    => (CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog :: forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
tog CInt -> Ptr t -> CInt -> Ptr a -> IO CInt
f Vector t
v = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a
r <- forall a. Storable a => Int -> IO (Vector a)
createVector (forall t. Storable t => Vector t -> Int
dim Vector t
v)
    (Vector t
v forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector a
r) CInt -> Ptr t -> CInt -> Ptr a -> IO CInt
f IO CInt -> String -> IO ()
#|String
"tog"
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector a
r

foreign import ccall unsafe "float2double" c_float2double :: Float :> Double :> Ok
foreign import ccall unsafe "double2float" c_double2float :: Double :> Float :> Ok
foreign import ccall unsafe "int2double"   c_int2double   :: CInt :> Double :> Ok
foreign import ccall unsafe "double2int"   c_double2int   :: Double :> CInt :> Ok
foreign import ccall unsafe "long2double"  c_long2double   :: Z :> Double :> Ok
foreign import ccall unsafe "double2long"  c_double2long   :: Double :> Z :> Ok
foreign import ccall unsafe "int2float"    c_int2float    :: CInt :> Float :> Ok
foreign import ccall unsafe "float2int"    c_float2int    :: Float :> CInt :> Ok
foreign import ccall unsafe "int2long"    c_int2long    :: I :> Z :> Ok
foreign import ccall unsafe "long2int"    c_long2int    :: Z :> I :> Ok


---------------------------------------------------------------

stepg :: (Storable t, Storable a)
      => (CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
stepg :: forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
stepg CInt -> Ptr t -> CInt -> Ptr a -> IO CInt
f Vector t
v = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a
r <- forall a. Storable a => Int -> IO (Vector a)
createVector (forall t. Storable t => Vector t -> Int
dim Vector t
v)
    (Vector t
v forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector a
r) CInt -> Ptr t -> CInt -> Ptr a -> IO CInt
f IO CInt -> String -> IO ()
#|String
"step"
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector a
r

stepD :: Vector Double -> Vector Double
stepD :: Vector Double -> Vector Double
stepD = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
stepg TVV Double
c_stepD

stepF :: Vector Float -> Vector Float
stepF :: Vector Float -> Vector Float
stepF = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
stepg TVV Float
c_stepF

stepI :: Vector CInt -> Vector CInt
stepI :: Vector CInt -> Vector CInt
stepI = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
stepg CInt -> Ptr CInt -> CInt :> IO CInt
c_stepI

stepL :: Vector Z -> Vector Z
stepL :: Vector Z -> Vector Z
stepL = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
stepg CInt -> Ptr Z -> Z :> IO CInt
c_stepL


foreign import ccall unsafe "stepF" c_stepF :: TVV Float
foreign import ccall unsafe "stepD" c_stepD :: TVV Double
foreign import ccall unsafe "stepI" c_stepI :: TVV CInt
foreign import ccall unsafe "stepL" c_stepL :: TVV Z

--------------------------------------------------------------------------------

conjugateAux :: (Storable t, Storable a)
             => (CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
conjugateAux :: forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
conjugateAux CInt -> Ptr t -> CInt -> Ptr a -> IO CInt
fun Vector t
x = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a
v <- forall a. Storable a => Int -> IO (Vector a)
createVector (forall t. Storable t => Vector t -> Int
dim Vector t
x)
    (Vector t
x forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector a
v) CInt -> Ptr t -> CInt -> Ptr a -> IO CInt
fun IO CInt -> String -> IO ()
#|String
"conjugateAux"
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector a
v

conjugateQ :: Vector (Complex Float) -> Vector (Complex Float)
conjugateQ :: Vector (Complex Float) -> Vector (Complex Float)
conjugateQ = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
conjugateAux TVV (Complex Float)
c_conjugateQ
foreign import ccall unsafe "conjugateQ" c_conjugateQ :: TVV (Complex Float)

conjugateC :: Vector (Complex Double) -> Vector (Complex Double)
conjugateC :: Vector (Complex Double) -> Vector (Complex Double)
conjugateC = forall t a.
(Storable t, Storable a) =>
(CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
conjugateAux TVV (Complex Double)
c_conjugateC
foreign import ccall unsafe "conjugateC" c_conjugateC :: TVV (Complex Double)

--------------------------------------------------------------------------------

cloneVector :: Storable t => Vector t -> IO (Vector t)
cloneVector :: forall t. Storable t => Vector t -> IO (Vector t)
cloneVector Vector t
v = do
        let n :: Int
n = forall t. Storable t => Vector t -> Int
dim Vector t
v
        Vector t
r <- forall a. Storable a => Int -> IO (Vector a)
createVector Int
n
        let f :: CInt -> Ptr t -> CInt -> Ptr t -> IO CInt
f CInt
_ Ptr t
s CInt
_ Ptr t
d =  forall a. Storable a => Ptr a -> Ptr a -> Int -> IO ()
copyArray Ptr t
d Ptr t
s Int
n forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return CInt
0
        (Vector t
v forall c c1 r.
(TransArray c, TransArray c1) =>
c1 -> c -> TransRaw c1 (TransRaw c (IO r)) -> IO r
#! Vector t
r) CInt -> Ptr t -> CInt -> Ptr t -> IO CInt
f IO CInt -> String -> IO ()
#|String
"cloneVector"
        forall (m :: * -> *) a. Monad m => a -> m a
return Vector t
r

--------------------------------------------------------------------------------

constantAux :: (Storable a1, Storable a)
            => (Ptr a1 -> CInt -> Ptr a -> IO CInt) -> a1 -> Int -> Vector a
constantAux :: forall a1 a.
(Storable a1, Storable a) =>
(Ptr a1 -> CInt -> Ptr a -> IO CInt) -> a1 -> Int -> Vector a
constantAux Ptr a1 -> CInt -> Ptr a -> IO CInt
fun a1
x Int
n = forall a. IO a -> a
unsafePerformIO forall a b. (a -> b) -> a -> b
$ do
    Vector a
v <- forall a. Storable a => Int -> IO (Vector a)
createVector Int
n
    Ptr a1
px <- forall a. Storable a => [a] -> IO (Ptr a)
newArray [a1
x]
    (Vector a
v forall c b r.
TransArray c =>
c -> (b -> IO r) -> TransRaw c b -> IO r
# forall a. a -> a
id) (Ptr a1 -> CInt -> Ptr a -> IO CInt
fun Ptr a1
px) IO CInt -> String -> IO ()
#|String
"constantAux"
    forall a. Ptr a -> IO ()
free Ptr a1
px
    forall (m :: * -> *) a. Monad m => a -> m a
return Vector a
v

type TConst t = Ptr t -> t :> Ok

foreign import ccall unsafe "constantF" cconstantF :: TConst Float
foreign import ccall unsafe "constantR" cconstantR :: TConst Double
foreign import ccall unsafe "constantQ" cconstantQ :: TConst (Complex Float)
foreign import ccall unsafe "constantC" cconstantC :: TConst (Complex Double)
foreign import ccall unsafe "constantI" cconstantI :: TConst CInt
foreign import ccall unsafe "constantL" cconstantL :: TConst Z

----------------------------------------------------------------------