{-# LANGUAGE CPP #-}
#if __GLASGOW_HASKELL__ >= 708

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveGeneric #-}

{-# OPTIONS_GHC -fno-warn-missing-signatures #-}

{- |
Module      :  Internal.Static
Copyright   :  (c) Alberto Ruiz 2006-14
License     :  BSD3
Stability   :  provisional

-}

module Internal.Static where


import GHC.TypeLits
import qualified Numeric.LinearAlgebra as LA
import Numeric.LinearAlgebra hiding (konst,size,R,C)
import Internal.Vector as D hiding (R,C)
import Internal.ST
import Control.DeepSeq
import Data.Proxy(Proxy)
import Foreign.Storable(Storable)
import Text.Printf

import Data.Binary
import GHC.Generics (Generic)
import Data.Proxy (Proxy(..))

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

type ℝ = Double
type ℂ = Complex Double

newtype Dim (n :: Nat) t = Dim t
  deriving (Int -> Dim n t -> ShowS
forall (n :: Nat) t. Show t => Int -> Dim n t -> ShowS
forall (n :: Nat) t. Show t => [Dim n t] -> ShowS
forall (n :: Nat) t. Show t => Dim n t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Dim n t] -> ShowS
$cshowList :: forall (n :: Nat) t. Show t => [Dim n t] -> ShowS
show :: Dim n t -> String
$cshow :: forall (n :: Nat) t. Show t => Dim n t -> String
showsPrec :: Int -> Dim n t -> ShowS
$cshowsPrec :: forall (n :: Nat) t. Show t => Int -> Dim n t -> ShowS
Show, forall (n :: Nat) t x. Rep (Dim n t) x -> Dim n t
forall (n :: Nat) t x. Dim n t -> Rep (Dim n t) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall (n :: Nat) t x. Rep (Dim n t) x -> Dim n t
$cfrom :: forall (n :: Nat) t x. Dim n t -> Rep (Dim n t) x
Generic)

instance (KnownNat n, Binary a) => Binary (Dim n a) where
  get :: Get (Dim n a)
get = do
    Integer
k <- forall t. Binary t => Get t
get
    let n :: Integer
n = forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n)
    if Integer
n forall a. Eq a => a -> a -> Bool
== Integer
k
      then forall (n :: Nat) t. t -> Dim n t
Dim forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall t. Binary t => Get t
get
      else forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"Expected dimension " forall a. [a] -> [a] -> [a]
++ (forall a. Show a => a -> String
show Integer
n) forall a. [a] -> [a] -> [a]
++ String
", but found dimension " forall a. [a] -> [a] -> [a]
++ (forall a. Show a => a -> String
show Integer
k))

  put :: Dim n a -> Put
put (Dim a
x) = do
    forall t. Binary t => t -> Put
put (forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (forall {k} (t :: k). Proxy t
Proxy :: Proxy n))
    forall t. Binary t => t -> Put
put a
x

lift1F
  :: (c t -> c t)
  -> Dim n (c t) -> Dim n (c t)
lift1F :: forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F c t -> c t
f (Dim c t
v) = forall (n :: Nat) t. t -> Dim n t
Dim (c t -> c t
f c t
v)

lift2F
  :: (c t -> c t -> c t)
  -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F :: forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F c t -> c t -> c t
f (Dim c t
u) (Dim c t
v) = forall (n :: Nat) t. t -> Dim n t
Dim (c t -> c t -> c t
f c t
u c t
v)

instance NFData t => NFData (Dim n t) where
    rnf :: Dim n t -> ()
rnf (Dim (forall a. NFData a => a -> a
force -> !t
_)) = ()

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

newtype R n = R (Dim n (Vector ℝ))
  deriving (Integer -> R n
R n -> R n
R n -> R n -> R n
forall (n :: Nat). Integer -> R n
forall (n :: Nat). R n -> R n
forall (n :: Nat). R n -> R n -> R n
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> R n
$cfromInteger :: forall (n :: Nat). Integer -> R n
signum :: R n -> R n
$csignum :: forall (n :: Nat). R n -> R n
abs :: R n -> R n
$cabs :: forall (n :: Nat). R n -> R n
negate :: R n -> R n
$cnegate :: forall (n :: Nat). R n -> R n
* :: R n -> R n -> R n
$c* :: forall (n :: Nat). R n -> R n -> R n
- :: R n -> R n -> R n
$c- :: forall (n :: Nat). R n -> R n -> R n
+ :: R n -> R n -> R n
$c+ :: forall (n :: Nat). R n -> R n -> R n
Num,Rational -> R n
R n -> R n
R n -> R n -> R n
forall (n :: Nat). Num (R n)
forall (n :: Nat). Rational -> R n
forall (n :: Nat). R n -> R n
forall (n :: Nat). R n -> R n -> R n
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> R n
$cfromRational :: forall (n :: Nat). Rational -> R n
recip :: R n -> R n
$crecip :: forall (n :: Nat). R n -> R n
/ :: R n -> R n -> R n
$c/ :: forall (n :: Nat). R n -> R n -> R n
Fractional,R n
R n -> R n
R n -> R n -> R n
forall (n :: Nat). Fractional (R n)
forall (n :: Nat). R n
forall (n :: Nat). R n -> R n
forall (n :: Nat). R n -> R n -> R n
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: R n -> R n
$clog1mexp :: forall (n :: Nat). R n -> R n
log1pexp :: R n -> R n
$clog1pexp :: forall (n :: Nat). R n -> R n
expm1 :: R n -> R n
$cexpm1 :: forall (n :: Nat). R n -> R n
log1p :: R n -> R n
$clog1p :: forall (n :: Nat). R n -> R n
atanh :: R n -> R n
$catanh :: forall (n :: Nat). R n -> R n
acosh :: R n -> R n
$cacosh :: forall (n :: Nat). R n -> R n
asinh :: R n -> R n
$casinh :: forall (n :: Nat). R n -> R n
tanh :: R n -> R n
$ctanh :: forall (n :: Nat). R n -> R n
cosh :: R n -> R n
$ccosh :: forall (n :: Nat). R n -> R n
sinh :: R n -> R n
$csinh :: forall (n :: Nat). R n -> R n
atan :: R n -> R n
$catan :: forall (n :: Nat). R n -> R n
acos :: R n -> R n
$cacos :: forall (n :: Nat). R n -> R n
asin :: R n -> R n
$casin :: forall (n :: Nat). R n -> R n
tan :: R n -> R n
$ctan :: forall (n :: Nat). R n -> R n
cos :: R n -> R n
$ccos :: forall (n :: Nat). R n -> R n
sin :: R n -> R n
$csin :: forall (n :: Nat). R n -> R n
logBase :: R n -> R n -> R n
$clogBase :: forall (n :: Nat). R n -> R n -> R n
** :: R n -> R n -> R n
$c** :: forall (n :: Nat). R n -> R n -> R n
sqrt :: R n -> R n
$csqrt :: forall (n :: Nat). R n -> R n
log :: R n -> R n
$clog :: forall (n :: Nat). R n -> R n
exp :: R n -> R n
$cexp :: forall (n :: Nat). R n -> R n
pi :: R n
$cpi :: forall (n :: Nat). R n
Floating,forall (n :: Nat) x. Rep (R n) x -> R n
forall (n :: Nat) x. R n -> Rep (R n) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall (n :: Nat) x. Rep (R n) x -> R n
$cfrom :: forall (n :: Nat) x. R n -> Rep (R n) x
Generic,Get (R n)
[R n] -> Put
R n -> Put
forall (n :: Nat). KnownNat n => Get (R n)
forall (n :: Nat). KnownNat n => [R n] -> Put
forall (n :: Nat). KnownNat n => R n -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [R n] -> Put
$cputList :: forall (n :: Nat). KnownNat n => [R n] -> Put
get :: Get (R n)
$cget :: forall (n :: Nat). KnownNat n => Get (R n)
put :: R n -> Put
$cput :: forall (n :: Nat). KnownNat n => R n -> Put
Binary)

newtype C n = C (Dim n (Vector ℂ))
  deriving (Integer -> C n
C n -> C n
C n -> C n -> C n
forall (n :: Nat). Integer -> C n
forall (n :: Nat). C n -> C n
forall (n :: Nat). C n -> C n -> C n
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> C n
$cfromInteger :: forall (n :: Nat). Integer -> C n
signum :: C n -> C n
$csignum :: forall (n :: Nat). C n -> C n
abs :: C n -> C n
$cabs :: forall (n :: Nat). C n -> C n
negate :: C n -> C n
$cnegate :: forall (n :: Nat). C n -> C n
* :: C n -> C n -> C n
$c* :: forall (n :: Nat). C n -> C n -> C n
- :: C n -> C n -> C n
$c- :: forall (n :: Nat). C n -> C n -> C n
+ :: C n -> C n -> C n
$c+ :: forall (n :: Nat). C n -> C n -> C n
Num,Rational -> C n
C n -> C n
C n -> C n -> C n
forall (n :: Nat). Num (C n)
forall (n :: Nat). Rational -> C n
forall (n :: Nat). C n -> C n
forall (n :: Nat). C n -> C n -> C n
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> C n
$cfromRational :: forall (n :: Nat). Rational -> C n
recip :: C n -> C n
$crecip :: forall (n :: Nat). C n -> C n
/ :: C n -> C n -> C n
$c/ :: forall (n :: Nat). C n -> C n -> C n
Fractional,C n
C n -> C n
C n -> C n -> C n
forall (n :: Nat). Fractional (C n)
forall (n :: Nat). C n
forall (n :: Nat). C n -> C n
forall (n :: Nat). C n -> C n -> C n
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: C n -> C n
$clog1mexp :: forall (n :: Nat). C n -> C n
log1pexp :: C n -> C n
$clog1pexp :: forall (n :: Nat). C n -> C n
expm1 :: C n -> C n
$cexpm1 :: forall (n :: Nat). C n -> C n
log1p :: C n -> C n
$clog1p :: forall (n :: Nat). C n -> C n
atanh :: C n -> C n
$catanh :: forall (n :: Nat). C n -> C n
acosh :: C n -> C n
$cacosh :: forall (n :: Nat). C n -> C n
asinh :: C n -> C n
$casinh :: forall (n :: Nat). C n -> C n
tanh :: C n -> C n
$ctanh :: forall (n :: Nat). C n -> C n
cosh :: C n -> C n
$ccosh :: forall (n :: Nat). C n -> C n
sinh :: C n -> C n
$csinh :: forall (n :: Nat). C n -> C n
atan :: C n -> C n
$catan :: forall (n :: Nat). C n -> C n
acos :: C n -> C n
$cacos :: forall (n :: Nat). C n -> C n
asin :: C n -> C n
$casin :: forall (n :: Nat). C n -> C n
tan :: C n -> C n
$ctan :: forall (n :: Nat). C n -> C n
cos :: C n -> C n
$ccos :: forall (n :: Nat). C n -> C n
sin :: C n -> C n
$csin :: forall (n :: Nat). C n -> C n
logBase :: C n -> C n -> C n
$clogBase :: forall (n :: Nat). C n -> C n -> C n
** :: C n -> C n -> C n
$c** :: forall (n :: Nat). C n -> C n -> C n
sqrt :: C n -> C n
$csqrt :: forall (n :: Nat). C n -> C n
log :: C n -> C n
$clog :: forall (n :: Nat). C n -> C n
exp :: C n -> C n
$cexp :: forall (n :: Nat). C n -> C n
pi :: C n
$cpi :: forall (n :: Nat). C n
Floating,forall (n :: Nat) x. Rep (C n) x -> C n
forall (n :: Nat) x. C n -> Rep (C n) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall (n :: Nat) x. Rep (C n) x -> C n
$cfrom :: forall (n :: Nat) x. C n -> Rep (C n) x
Generic)

newtype L m n = L (Dim m (Dim n (Matrix ℝ)))
  deriving (forall (m :: Nat) (n :: Nat) x. Rep (L m n) x -> L m n
forall (m :: Nat) (n :: Nat) x. L m n -> Rep (L m n) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall (m :: Nat) (n :: Nat) x. Rep (L m n) x -> L m n
$cfrom :: forall (m :: Nat) (n :: Nat) x. L m n -> Rep (L m n) x
Generic, Get (L m n)
[L m n] -> Put
L m n -> Put
forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
Get (L m n)
forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
[L m n] -> Put
forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
L m n -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [L m n] -> Put
$cputList :: forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
[L m n] -> Put
get :: Get (L m n)
$cget :: forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
Get (L m n)
put :: L m n -> Put
$cput :: forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
L m n -> Put
Binary)

newtype M m n = M (Dim m (Dim n (Matrix ℂ)))
  deriving (forall (m :: Nat) (n :: Nat) x. Rep (M m n) x -> M m n
forall (m :: Nat) (n :: Nat) x. M m n -> Rep (M m n) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall (m :: Nat) (n :: Nat) x. Rep (M m n) x -> M m n
$cfrom :: forall (m :: Nat) (n :: Nat) x. M m n -> Rep (M m n) x
Generic)

mkR :: Vector ℝ -> R n
mkR :: forall (n :: Nat). Vector ℝ -> R n
mkR = forall (n :: Nat). Dim n (Vector ℝ) -> R n
R forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim

mkC :: Vector ℂ -> C n
mkC :: forall (n :: Nat). Vector ℂ -> C n
mkC = forall (n :: Nat). Dim n (Vector ℂ) -> C n
C forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim

mkL :: Matrix ℝ -> L m n
mkL :: forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
mkL Matrix ℝ
x = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
L (forall (n :: Nat) t. t -> Dim n t
Dim (forall (n :: Nat) t. t -> Dim n t
Dim Matrix ℝ
x))

mkM :: Matrix ℂ -> M m n
mkM :: forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM Matrix ℂ
x = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
M (forall (n :: Nat) t. t -> Dim n t
Dim (forall (n :: Nat) t. t -> Dim n t
Dim Matrix ℂ
x))

instance NFData (R n) where
    rnf :: R n -> ()
rnf (R (forall a. NFData a => a -> a
force -> !Dim n (Vector ℝ)
_)) = ()

instance NFData (C n) where
    rnf :: C n -> ()
rnf (C (forall a. NFData a => a -> a
force -> !Dim n (Vector ℂ)
_)) = ()

instance NFData (L n m) where
    rnf :: L n m -> ()
rnf (L (forall a. NFData a => a -> a
force -> !Dim n (Dim m (Matrix ℝ))
_)) = ()

instance NFData (M n m) where
    rnf :: M n m -> ()
rnf (M (forall a. NFData a => a -> a
force -> !Dim n (Dim m (Matrix ℂ))
_)) = ()

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

type V n t = Dim n (Vector t)

ud :: Dim n (Vector t) -> Vector t
ud :: forall (n :: Nat) t. Dim n (Vector t) -> Vector t
ud (Dim Vector t
v) = Vector t
v

mkV :: forall (n :: Nat) t . t -> Dim n t
mkV :: forall (n :: Nat) t. t -> Dim n t
mkV = forall (n :: Nat) t. t -> Dim n t
Dim


vconcat :: forall n m t . (KnownNat n, KnownNat m, Numeric t)
    => V n t -> V m t -> V (n+m) t
(forall (n :: Nat) t. Dim n (Vector t) -> Vector t
ud -> Vector t
u) vconcat :: forall (n :: Nat) (m :: Nat) t.
(KnownNat n, KnownNat m, Numeric t) =>
V n t -> V m t -> V (n + m) t
`vconcat` (forall (n :: Nat) t. Dim n (Vector t) -> Vector t
ud -> Vector t
v) = forall (n :: Nat) t. t -> Dim n t
mkV (forall t. Storable t => [Vector t] -> Vector t
vjoin [Vector t
u', Vector t
v'])
  where
    du :: Int
du = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal forall a b. (a -> b) -> a -> b
$ (forall a. HasCallStack => a
undefined :: Proxy n)
    dv :: Int
dv = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal forall a b. (a -> b) -> a -> b
$ (forall a. HasCallStack => a
undefined :: Proxy m)
    u' :: Vector t
u' | Int
du forall a. Eq a => a -> a -> Bool
/= Int
1 Bool -> Bool -> Bool
&& forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Vector t
u forall a. Eq a => a -> a -> Bool
== Int
1 = forall e d (c :: * -> *). Konst e d c => e -> d -> c e
LA.konst (Vector t
u forall t. Storable t => Vector t -> Int -> t
D.@> Int
0) Int
du
       | Bool
otherwise = Vector t
u
    v' :: Vector t
v' | Int
dv forall a. Eq a => a -> a -> Bool
/= Int
1 Bool -> Bool -> Bool
&& forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Vector t
v forall a. Eq a => a -> a -> Bool
== Int
1 = forall e d (c :: * -> *). Konst e d c => e -> d -> c e
LA.konst (Vector t
v forall t. Storable t => Vector t -> Int -> t
D.@> Int
0) Int
dv
       | Bool
otherwise = Vector t
v


gvec2 :: Storable t => t -> t -> V 2 t
gvec2 :: forall t. Storable t => t -> t -> V 2 t
gvec2 t
a t
b = forall (n :: Nat) t. t -> Dim n t
mkV forall a b. (a -> b) -> a -> b
$ forall t. Storable t => (forall s. ST s (STVector s t)) -> Vector t
runSTVector forall a b. (a -> b) -> a -> b
$ do
    STVector s t
v <- forall t s. Storable t => Int -> ST s (STVector s t)
newUndefinedVector Int
2
    forall t s. Storable t => STVector s t -> Int -> t -> ST s ()
writeVector STVector s t
v Int
0 t
a
    forall t s. Storable t => STVector s t -> Int -> t -> ST s ()
writeVector STVector s t
v Int
1 t
b
    forall (m :: * -> *) a. Monad m => a -> m a
return STVector s t
v

gvec3 :: Storable t => t -> t -> t -> V 3 t
gvec3 :: forall t. Storable t => t -> t -> t -> V 3 t
gvec3 t
a t
b t
c = forall (n :: Nat) t. t -> Dim n t
mkV forall a b. (a -> b) -> a -> b
$ forall t. Storable t => (forall s. ST s (STVector s t)) -> Vector t
runSTVector forall a b. (a -> b) -> a -> b
$ do
    STVector s t
v <- forall t s. Storable t => Int -> ST s (STVector s t)
newUndefinedVector Int
3
    forall t s. Storable t => STVector s t -> Int -> t -> ST s ()
writeVector STVector s t
v Int
0 t
a
    forall t s. Storable t => STVector s t -> Int -> t -> ST s ()
writeVector STVector s t
v Int
1 t
b
    forall t s. Storable t => STVector s t -> Int -> t -> ST s ()
writeVector STVector s t
v Int
2 t
c
    forall (m :: * -> *) a. Monad m => a -> m a
return STVector s t
v


gvec4 :: Storable t => t -> t -> t -> t -> V 4 t
gvec4 :: forall t. Storable t => t -> t -> t -> t -> V 4 t
gvec4 t
a t
b t
c t
d = forall (n :: Nat) t. t -> Dim n t
mkV forall a b. (a -> b) -> a -> b
$ forall t. Storable t => (forall s. ST s (STVector s t)) -> Vector t
runSTVector forall a b. (a -> b) -> a -> b
$ do
    STVector s t
v <- forall t s. Storable t => Int -> ST s (STVector s t)
newUndefinedVector Int
4
    forall t s. Storable t => STVector s t -> Int -> t -> ST s ()
writeVector STVector s t
v Int
0 t
a
    forall t s. Storable t => STVector s t -> Int -> t -> ST s ()
writeVector STVector s t
v Int
1 t
b
    forall t s. Storable t => STVector s t -> Int -> t -> ST s ()
writeVector STVector s t
v Int
2 t
c
    forall t s. Storable t => STVector s t -> Int -> t -> ST s ()
writeVector STVector s t
v Int
3 t
d
    forall (m :: * -> *) a. Monad m => a -> m a
return STVector s t
v


gvect :: forall n t . (Show t, KnownNat n, Numeric t) => String -> [t] -> V n t
gvect :: forall (n :: Nat) t.
(Show t, KnownNat n, Numeric t) =>
String -> [t] -> V n t
gvect String
st [t]
xs'
    | Bool
ok = forall (n :: Nat) t. t -> Dim n t
mkV Vector t
v
    | Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [t]
rest) Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Bool
null (forall a. [a] -> [a]
tail [t]
rest) = forall {a}. String -> a
abort (forall a. Show a => a -> String
show [t]
xs')
    | Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [t]
rest) = forall {a}. String -> a
abort (forall a. [a] -> [a]
init (forall a. Show a => a -> String
show ([t]
xsforall a. [a] -> [a] -> [a]
++forall a. Int -> [a] -> [a]
take Int
1 [t]
rest))forall a. [a] -> [a] -> [a]
++String
", ... ]")
    | Bool
otherwise = forall {a}. String -> a
abort (forall a. Show a => a -> String
show [t]
xs)
  where
    ([t]
xs,[t]
rest) = forall a. Int -> [a] -> ([a], [a])
splitAt Int
d [t]
xs'
    ok :: Bool
ok = forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Vector t
v forall a. Eq a => a -> a -> Bool
== Int
d Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Bool
null [t]
rest
    v :: Vector t
v = forall a. Storable a => [a] -> Vector a
LA.fromList [t]
xs
    d :: Int
d = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal forall a b. (a -> b) -> a -> b
$ (forall a. HasCallStack => a
undefined :: Proxy n)
    abort :: String -> a
abort String
info = forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
stforall a. [a] -> [a] -> [a]
++String
" "forall a. [a] -> [a] -> [a]
++forall a. Show a => a -> String
show Int
dforall a. [a] -> [a] -> [a]
++String
" can't be created from elements "forall a. [a] -> [a] -> [a]
++String
info


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

type GM m n t = Dim m (Dim n (Matrix t))


gmat :: forall m n t . (Show t, KnownNat m, KnownNat n, Numeric t) => String -> [t] -> GM m n t
gmat :: forall (m :: Nat) (n :: Nat) t.
(Show t, KnownNat m, KnownNat n, Numeric t) =>
String -> [t] -> GM m n t
gmat String
st [t]
xs'
    | Bool
ok = forall (n :: Nat) t. t -> Dim n t
Dim (forall (n :: Nat) t. t -> Dim n t
Dim Matrix t
x)
    | Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [t]
rest) Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Bool
null (forall a. [a] -> [a]
tail [t]
rest) = forall {a}. String -> a
abort (forall a. Show a => a -> String
show [t]
xs')
    | Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [t]
rest) = forall {a}. String -> a
abort (forall a. [a] -> [a]
init (forall a. Show a => a -> String
show ([t]
xsforall a. [a] -> [a] -> [a]
++forall a. Int -> [a] -> [a]
take Int
1 [t]
rest))forall a. [a] -> [a] -> [a]
++String
", ... ]")
    | Bool
otherwise = forall {a}. String -> a
abort (forall a. Show a => a -> String
show [t]
xs)
  where
    ([t]
xs,[t]
rest) = forall a. Int -> [a] -> ([a], [a])
splitAt (Int
m'forall a. Num a => a -> a -> a
*Int
n') [t]
xs'
    v :: Vector t
v = forall a. Storable a => [a] -> Vector a
LA.fromList [t]
xs
    x :: Matrix t
x = forall t. Storable t => Int -> Vector t -> Matrix t
reshape Int
n' Vector t
v
    ok :: Bool
ok = forall (t :: * -> *) a. Foldable t => t a -> Bool
null [t]
rest Bool -> Bool -> Bool
&& ((Int
n' forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
&& forall t. Storable t => Vector t -> Int
dim Vector t
v forall a. Eq a => a -> a -> Bool
== Int
0) Bool -> Bool -> Bool
|| Int
n'forall a. Ord a => a -> a -> Bool
> Int
0 Bool -> Bool -> Bool
&& (forall a. Integral a => a -> a -> a
rem (forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Vector t
v) Int
n' forall a. Eq a => a -> a -> Bool
== Int
0) Bool -> Bool -> Bool
&& forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Matrix t
x forall a. Eq a => a -> a -> Bool
== (Int
m',Int
n'))
    m' :: Int
m' = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal forall a b. (a -> b) -> a -> b
$ (forall a. HasCallStack => a
undefined :: Proxy m) :: Int
    n' :: Int
n' = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal forall a b. (a -> b) -> a -> b
$ (forall a. HasCallStack => a
undefined :: Proxy n) :: Int
    abort :: String -> a
abort String
info = forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
st forall a. [a] -> [a] -> [a]
++String
" "forall a. [a] -> [a] -> [a]
++forall a. Show a => a -> String
show Int
m' forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
n'forall a. [a] -> [a] -> [a]
++String
" can't be created from elements " forall a. [a] -> [a] -> [a]
++ String
info

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

class Num t => Sized t s d | s -> t, s -> d
  where
    konst     ::  t   -> s
    unwrap    ::  s   -> d t
    fromList  :: [t]  -> s
    extract   ::  s   -> d t
    create    ::  d t -> Maybe s
    size      ::  s   -> IndexOf d

singleV :: c t -> Bool
singleV c t
v = forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size c t
v forall a. Eq a => a -> a -> Bool
== IndexOf c
1
singleM :: Matrix t -> Bool
singleM Matrix t
m = forall t. Matrix t -> Int
rows Matrix t
m forall a. Eq a => a -> a -> Bool
== Int
1 Bool -> Bool -> Bool
&& forall t. Matrix t -> Int
cols Matrix t
m forall a. Eq a => a -> a -> Bool
== Int
1


instance KnownNat n => Sized ℂ (C n) Vector
  where
    size :: C n -> IndexOf Vector
size C n
_ = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal forall a b. (a -> b) -> a -> b
$ (forall a. HasCallStack => a
undefined :: Proxy n)
    konst :: ℂ -> C n
konst ℂ
x = forall (n :: Nat). Vector ℂ -> C n
mkC (forall (c :: * -> *) e. Container c e => e -> c e
LA.scalar ℂ
x)
    unwrap :: C n -> Vector ℂ
unwrap (C (Dim Vector ℂ
v)) = Vector ℂ
v
    fromList :: [ℂ] -> C n
fromList [ℂ]
xs = forall (n :: Nat). Dim n (Vector ℂ) -> C n
C (forall (n :: Nat) t.
(Show t, KnownNat n, Numeric t) =>
String -> [t] -> V n t
gvect String
"C" [ℂ]
xs)
    extract :: C n -> Vector ℂ
extract s :: C n
s@(forall t s (d :: * -> *). Sized t s d => s -> d t
unwrap -> Vector ℂ
v)
      | forall {c :: * -> *} {t}.
(Eq (IndexOf c), Container c t, Num (IndexOf c)) =>
c t -> Bool
singleV Vector ℂ
v = forall e d (c :: * -> *). Konst e d c => e -> d -> c e
LA.konst (Vector ℂ
vforall c t. Indexable c t => c -> Int -> t
!Int
0) (forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size C n
s)
      | Bool
otherwise = Vector ℂ
v
    create :: Vector ℂ -> Maybe (C n)
create Vector ℂ
v
        | forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Vector ℂ
v forall a. Eq a => a -> a -> Bool
== forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size C n
r = forall a. a -> Maybe a
Just C n
r
        | Bool
otherwise = forall a. Maybe a
Nothing
      where
        r :: C n
r = forall (n :: Nat). Vector ℂ -> C n
mkC Vector ℂ
v :: C n


instance KnownNat n => Sized ℝ (R n) Vector
  where
    size :: R n -> IndexOf Vector
size R n
_ = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal forall a b. (a -> b) -> a -> b
$ (forall a. HasCallStack => a
undefined :: Proxy n)
    konst :: ℝ -> R n
konst ℝ
x = forall (n :: Nat). Vector ℝ -> R n
mkR (forall (c :: * -> *) e. Container c e => e -> c e
LA.scalar ℝ
x)
    unwrap :: R n -> Vector ℝ
unwrap (R (Dim Vector ℝ
v)) = Vector ℝ
v
    fromList :: [ℝ] -> R n
fromList [ℝ]
xs = forall (n :: Nat). Dim n (Vector ℝ) -> R n
R (forall (n :: Nat) t.
(Show t, KnownNat n, Numeric t) =>
String -> [t] -> V n t
gvect String
"R" [ℝ]
xs)
    extract :: R n -> Vector ℝ
extract s :: R n
s@(forall t s (d :: * -> *). Sized t s d => s -> d t
unwrap -> Vector ℝ
v)
      | forall {c :: * -> *} {t}.
(Eq (IndexOf c), Container c t, Num (IndexOf c)) =>
c t -> Bool
singleV Vector ℝ
v = forall e d (c :: * -> *). Konst e d c => e -> d -> c e
LA.konst (Vector ℝ
vforall c t. Indexable c t => c -> Int -> t
!Int
0) (forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size R n
s)
      | Bool
otherwise = Vector ℝ
v
    create :: Vector ℝ -> Maybe (R n)
create Vector ℝ
v
        | forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Vector ℝ
v forall a. Eq a => a -> a -> Bool
== forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size R n
r = forall a. a -> Maybe a
Just R n
r
        | Bool
otherwise = forall a. Maybe a
Nothing
      where
        r :: R n
r = forall (n :: Nat). Vector ℝ -> R n
mkR Vector ℝ
v :: R n



instance (KnownNat m, KnownNat n) => Sized ℝ (L m n) Matrix
  where
    size :: L m n -> IndexOf Matrix
size L m n
_ = ((forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal) (forall a. HasCallStack => a
undefined :: Proxy m)
             ,(forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal) (forall a. HasCallStack => a
undefined :: Proxy n))
    konst :: ℝ -> L m n
konst ℝ
x = forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
mkL (forall (c :: * -> *) e. Container c e => e -> c e
LA.scalar ℝ
x)
    fromList :: [ℝ] -> L m n
fromList [ℝ]
xs = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
L (forall (m :: Nat) (n :: Nat) t.
(Show t, KnownNat m, KnownNat n, Numeric t) =>
String -> [t] -> GM m n t
gmat String
"L" [ℝ]
xs)
    unwrap :: L m n -> Matrix ℝ
unwrap (L (Dim (Dim Matrix ℝ
m))) = Matrix ℝ
m
    extract :: L m n -> Matrix ℝ
extract (forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
isDiag -> Just (ℝ
z,Vector ℝ
y,(Int
m',Int
n'))) = forall t. Storable t => t -> Vector t -> Int -> Int -> Matrix t
diagRect ℝ
z Vector ℝ
y Int
m' Int
n'
    extract s :: L m n
s@(forall t s (d :: * -> *). Sized t s d => s -> d t
unwrap -> Matrix ℝ
a)
        | forall {t}. Matrix t -> Bool
singleM Matrix ℝ
a = forall e d (c :: * -> *). Konst e d c => e -> d -> c e
LA.konst (Matrix ℝ
a forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
`atIndex` (Int
0,Int
0)) (forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size L m n
s)
        | Bool
otherwise = Matrix ℝ
a
    create :: Matrix ℝ -> Maybe (L m n)
create Matrix ℝ
x
        | forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Matrix ℝ
x forall a. Eq a => a -> a -> Bool
== forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size L m n
r = forall a. a -> Maybe a
Just L m n
r
        | Bool
otherwise = forall a. Maybe a
Nothing
      where
        r :: L m n
r = forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
mkL Matrix ℝ
x :: L m n


instance (KnownNat m, KnownNat n) => Sized ℂ (M m n) Matrix
  where
    size :: M m n -> IndexOf Matrix
size M m n
_ = ((forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal) (forall a. HasCallStack => a
undefined :: Proxy m)
             ,(forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal) (forall a. HasCallStack => a
undefined :: Proxy n))
    konst :: ℂ -> M m n
konst ℂ
x = forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM (forall (c :: * -> *) e. Container c e => e -> c e
LA.scalar ℂ
x)
    fromList :: [ℂ] -> M m n
fromList [ℂ]
xs = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
M (forall (m :: Nat) (n :: Nat) t.
(Show t, KnownNat m, KnownNat n, Numeric t) =>
String -> [t] -> GM m n t
gmat String
"M" [ℂ]
xs)
    unwrap :: M m n -> Matrix ℂ
unwrap (M (Dim (Dim Matrix ℂ
m))) = Matrix ℂ
m
    extract :: M m n -> Matrix ℂ
extract (forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
isDiagC -> Just (ℂ
z,Vector ℂ
y,(Int
m',Int
n'))) = forall t. Storable t => t -> Vector t -> Int -> Int -> Matrix t
diagRect ℂ
z Vector ℂ
y Int
m' Int
n'
    extract s :: M m n
s@(forall t s (d :: * -> *). Sized t s d => s -> d t
unwrap -> Matrix ℂ
a)
        | forall {t}. Matrix t -> Bool
singleM Matrix ℂ
a = forall e d (c :: * -> *). Konst e d c => e -> d -> c e
LA.konst (Matrix ℂ
a forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
`atIndex` (Int
0,Int
0)) (forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size M m n
s)
        | Bool
otherwise = Matrix ℂ
a
    create :: Matrix ℂ -> Maybe (M m n)
create Matrix ℂ
x
        | forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Matrix ℂ
x forall a. Eq a => a -> a -> Bool
== forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size M m n
r = forall a. a -> Maybe a
Just M m n
r
        | Bool
otherwise = forall a. Maybe a
Nothing
      where
        r :: M m n
r = forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM Matrix ℂ
x :: M m n

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

instance (KnownNat n, KnownNat m) => Transposable (L m n) (L n m)
  where
    tr :: L m n -> L n m
tr a :: L m n
a@(forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
isDiag -> Just (ℝ, Vector ℝ, (Int, Int))
_) = forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
mkL (forall t s (d :: * -> *). Sized t s d => s -> d t
extract L m n
a)
    tr (forall t s (d :: * -> *). Sized t s d => s -> d t
extract -> Matrix ℝ
a) = forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
mkL (forall m mt. Transposable m mt => m -> mt
tr Matrix ℝ
a)
    tr' :: L m n -> L n m
tr' = forall m mt. Transposable m mt => m -> mt
tr

instance (KnownNat n, KnownNat m) => Transposable (M m n) (M n m)
  where
    tr :: M m n -> M n m
tr a :: M m n
a@(forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
isDiagC -> Just (ℂ, Vector ℂ, (Int, Int))
_) = forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM (forall t s (d :: * -> *). Sized t s d => s -> d t
extract M m n
a)
    tr (forall t s (d :: * -> *). Sized t s d => s -> d t
extract -> Matrix ℂ
a) = forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM (forall m mt. Transposable m mt => m -> mt
tr Matrix ℂ
a)
    tr' :: M m n -> M n m
tr' a :: M m n
a@(forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
isDiagC -> Just (ℂ, Vector ℂ, (Int, Int))
_) = forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM (forall t s (d :: * -> *). Sized t s d => s -> d t
extract M m n
a)
    tr' (forall t s (d :: * -> *). Sized t s d => s -> d t
extract -> Matrix ℂ
a) = forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM (forall m mt. Transposable m mt => m -> mt
tr' Matrix ℂ
a)

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

isDiag :: forall m n . (KnownNat m, KnownNat n) => L m n -> Maybe (ℝ, Vector ℝ, (Int,Int))
isDiag :: forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
isDiag (L Dim m (Dim n (Matrix ℝ))
x) = forall (m :: Nat) (n :: Nat) t.
(Numeric t, KnownNat m, KnownNat n) =>
GM m n t -> Maybe (t, Vector t, (Int, Int))
isDiagg Dim m (Dim n (Matrix ℝ))
x

isDiagC :: forall m n . (KnownNat m, KnownNat n) => M m n -> Maybe (ℂ, Vector ℂ, (Int,Int))
isDiagC :: forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
isDiagC (M Dim m (Dim n (Matrix ℂ))
x) = forall (m :: Nat) (n :: Nat) t.
(Numeric t, KnownNat m, KnownNat n) =>
GM m n t -> Maybe (t, Vector t, (Int, Int))
isDiagg Dim m (Dim n (Matrix ℂ))
x


isDiagg :: forall m n t . (Numeric t, KnownNat m, KnownNat n) => GM m n t -> Maybe (t, Vector t, (Int,Int))
isDiagg :: forall (m :: Nat) (n :: Nat) t.
(Numeric t, KnownNat m, KnownNat n) =>
GM m n t -> Maybe (t, Vector t, (Int, Int))
isDiagg (Dim (Dim Matrix t
x))
    | forall {t}. Matrix t -> Bool
singleM Matrix t
x = forall a. Maybe a
Nothing
    | forall t. Matrix t -> Int
rows Matrix t
x forall a. Eq a => a -> a -> Bool
== Int
1 Bool -> Bool -> Bool
&& Int
m' forall a. Ord a => a -> a -> Bool
> Int
1 Bool -> Bool -> Bool
|| forall t. Matrix t -> Int
cols Matrix t
x forall a. Eq a => a -> a -> Bool
== Int
1 Bool -> Bool -> Bool
&& Int
n' forall a. Ord a => a -> a -> Bool
> Int
1 = forall a. a -> Maybe a
Just (t
z,Vector t
yz,(Int
m',Int
n'))
    | Bool
otherwise = forall a. Maybe a
Nothing
  where
    m' :: Int
m' = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal forall a b. (a -> b) -> a -> b
$ (forall a. HasCallStack => a
undefined :: Proxy m) :: Int
    n' :: Int
n' = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal forall a b. (a -> b) -> a -> b
$ (forall a. HasCallStack => a
undefined :: Proxy n) :: Int
    v :: Vector t
v = forall t. Element t => Matrix t -> Vector t
flatten Matrix t
x
    z :: t
z = Vector t
v forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
`atIndex` Int
0
    y :: Vector t
y = forall t. Storable t => Int -> Int -> Vector t -> Vector t
subVector Int
1 (forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Vector t
vforall a. Num a => a -> a -> a
-Int
1) Vector t
v
    ny :: IndexOf Vector
ny = forall (c :: * -> *) t. Container c t => c t -> IndexOf c
LA.size Vector t
y
    zeros :: Vector t
zeros = forall e d (c :: * -> *). Konst e d c => e -> d -> c e
LA.konst t
0 (forall a. Ord a => a -> a -> a
max Int
0 (forall a. Ord a => a -> a -> a
min Int
m' Int
n' forall a. Num a => a -> a -> a
- Int
ny))
    yz :: Vector t
yz = forall t. Storable t => [Vector t] -> Vector t
vjoin [Vector t
y,Vector t
zeros]

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

instance KnownNat n => Show (R n)
  where
    show :: R n -> String
show s :: R n
s@(R (Dim Vector ℝ
v))
      | forall {c :: * -> *} {t}.
(Eq (IndexOf c), Container c t, Num (IndexOf c)) =>
c t -> Bool
singleV Vector ℝ
v = String
"(" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (Vector ℝ
vforall c t. Indexable c t => c -> Int -> t
!Int
0) forall a. [a] -> [a] -> [a]
++ String
" :: R " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
d forall a. [a] -> [a] -> [a]
++ String
")"
      | Bool
otherwise = String
"(vector " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Vector ℝ
v forall a. [a] -> [a] -> [a]
++ String
" :: R " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
d forall a. [a] -> [a] -> [a]
++String
")"
      where
        d :: IndexOf Vector
d = forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size R n
s

instance KnownNat n => Show (C n)
  where
    show :: C n -> String
show s :: C n
s@(C (Dim Vector ℂ
v))
      | forall {c :: * -> *} {t}.
(Eq (IndexOf c), Container c t, Num (IndexOf c)) =>
c t -> Bool
singleV Vector ℂ
v = String
"(" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (Vector ℂ
vforall c t. Indexable c t => c -> Int -> t
!Int
0) forall a. [a] -> [a] -> [a]
++ String
" :: C " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
d forall a. [a] -> [a] -> [a]
++ String
")"
      | Bool
otherwise = String
"(vector " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Vector ℂ
v forall a. [a] -> [a] -> [a]
++ String
" :: C " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
d forall a. [a] -> [a] -> [a]
++String
")"
      where
        d :: IndexOf Vector
d = forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size C n
s

instance (KnownNat m, KnownNat n) => Show (L m n)
  where
    show :: L m n -> String
show (forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
isDiag -> Just (ℝ
z,Vector ℝ
y,(Int
m',Int
n'))) = forall r. PrintfType r => String -> r
printf String
"(diag %s %s :: L %d %d)" (forall a. Show a => a -> String
show ℝ
z) (forall a. Show a => a -> String
show Vector ℝ
y) Int
m' Int
n'
    show s :: L m n
s@(L (Dim (Dim Matrix ℝ
x)))
       | forall {t}. Matrix t -> Bool
singleM Matrix ℝ
x = forall r. PrintfType r => String -> r
printf String
"(%s :: L %d %d)" (forall a. Show a => a -> String
show (Matrix ℝ
x forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
`atIndex` (Int
0,Int
0))) Int
m' Int
n'
       | Bool
otherwise = String
"(matrix" forall a. [a] -> [a] -> [a]
++ forall a. (a -> Bool) -> [a] -> [a]
dropWhile (forall a. Eq a => a -> a -> Bool
/=Char
'\n') (forall a. Show a => a -> String
show Matrix ℝ
x) forall a. [a] -> [a] -> [a]
++ String
" :: L " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
m' forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
n' forall a. [a] -> [a] -> [a]
++ String
")"
      where
        (Int
m',Int
n') = forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size L m n
s

instance (KnownNat m, KnownNat n) => Show (M m n)
  where
    show :: M m n -> String
show (forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
isDiagC -> Just (ℂ
z,Vector ℂ
y,(Int
m',Int
n'))) = forall r. PrintfType r => String -> r
printf String
"(diag %s %s :: M %d %d)" (forall a. Show a => a -> String
show ℂ
z) (forall a. Show a => a -> String
show Vector ℂ
y) Int
m' Int
n'
    show s :: M m n
s@(M (Dim (Dim Matrix ℂ
x)))
       | forall {t}. Matrix t -> Bool
singleM Matrix ℂ
x = forall r. PrintfType r => String -> r
printf String
"(%s :: M %d %d)" (forall a. Show a => a -> String
show (Matrix ℂ
x forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
`atIndex` (Int
0,Int
0))) Int
m' Int
n'
       | Bool
otherwise = String
"(matrix" forall a. [a] -> [a] -> [a]
++ forall a. (a -> Bool) -> [a] -> [a]
dropWhile (forall a. Eq a => a -> a -> Bool
/=Char
'\n') (forall a. Show a => a -> String
show Matrix ℂ
x) forall a. [a] -> [a] -> [a]
++ String
" :: M " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
m' forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
n' forall a. [a] -> [a] -> [a]
++ String
")"
      where
        (Int
m',Int
n') = forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
size M m n
s

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

instance (Num (Vector t), Numeric t )=> Num (Dim n (Vector t))
  where
    + :: Dim n (Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
(+) = forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F forall a. Num a => a -> a -> a
(+)
    * :: Dim n (Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
(*) = forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F forall a. Num a => a -> a -> a
(*)
    (-) = forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F (-)
    abs :: Dim n (Vector t) -> Dim n (Vector t)
abs = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Num a => a -> a
abs
    signum :: Dim n (Vector t) -> Dim n (Vector t)
signum = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Num a => a -> a
signum
    negate :: Dim n (Vector t) -> Dim n (Vector t)
negate = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Num a => a -> a
negate
    fromInteger :: Integer -> Dim n (Vector t)
fromInteger Integer
x = forall (n :: Nat) t. t -> Dim n t
Dim (forall a. Num a => Integer -> a
fromInteger Integer
x)

instance (Num (Vector t), Fractional t, Numeric t) => Fractional (Dim n (Vector t))
  where
    fromRational :: Rational -> Dim n (Vector t)
fromRational Rational
x = forall (n :: Nat) t. t -> Dim n t
Dim (forall a. Fractional a => Rational -> a
fromRational Rational
x)
    / :: Dim n (Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
(/) = forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F forall a. Fractional a => a -> a -> a
(/)

instance (Fractional t, Floating (Vector t), Numeric t) => Floating (Dim n (Vector t)) where
    sin :: Dim n (Vector t) -> Dim n (Vector t)
sin   = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
sin
    cos :: Dim n (Vector t) -> Dim n (Vector t)
cos   = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
cos
    tan :: Dim n (Vector t) -> Dim n (Vector t)
tan   = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
tan
    asin :: Dim n (Vector t) -> Dim n (Vector t)
asin  = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
asin
    acos :: Dim n (Vector t) -> Dim n (Vector t)
acos  = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
acos
    atan :: Dim n (Vector t) -> Dim n (Vector t)
atan  = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
atan
    sinh :: Dim n (Vector t) -> Dim n (Vector t)
sinh  = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
sinh
    cosh :: Dim n (Vector t) -> Dim n (Vector t)
cosh  = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
cosh
    tanh :: Dim n (Vector t) -> Dim n (Vector t)
tanh  = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
tanh
    asinh :: Dim n (Vector t) -> Dim n (Vector t)
asinh = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
asinh
    acosh :: Dim n (Vector t) -> Dim n (Vector t)
acosh = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
acosh
    atanh :: Dim n (Vector t) -> Dim n (Vector t)
atanh = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
atanh
    exp :: Dim n (Vector t) -> Dim n (Vector t)
exp   = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
exp
    log :: Dim n (Vector t) -> Dim n (Vector t)
log   = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
log
    sqrt :: Dim n (Vector t) -> Dim n (Vector t)
sqrt  = forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall a. Floating a => a -> a
sqrt
    ** :: Dim n (Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
(**)  = forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F forall a. Floating a => a -> a -> a
(**)
    pi :: Dim n (Vector t)
pi    = forall (n :: Nat) t. t -> Dim n t
Dim forall a. Floating a => a
pi


instance (Num (Vector t), Numeric t) => Num (Dim m (Dim n (Matrix t)))
  where
    + :: Dim m (Dim n (Matrix t))
-> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
(+) = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F) forall a. Num a => a -> a -> a
(+)
    * :: Dim m (Dim n (Matrix t))
-> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
(*) = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F) forall a. Num a => a -> a -> a
(*)
    (-) = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F) (-)
    abs :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
abs = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Num a => a -> a
abs
    signum :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
signum = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Num a => a -> a
signum
    negate :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
negate = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Num a => a -> a
negate
    fromInteger :: Integer -> Dim m (Dim n (Matrix t))
fromInteger Integer
x = forall (n :: Nat) t. t -> Dim n t
Dim (forall (n :: Nat) t. t -> Dim n t
Dim (forall a. Num a => Integer -> a
fromInteger Integer
x))

instance (Num (Vector t), Fractional t, Numeric t) => Fractional (Dim m (Dim n (Matrix t)))
  where
    fromRational :: Rational -> Dim m (Dim n (Matrix t))
fromRational Rational
x = forall (n :: Nat) t. t -> Dim n t
Dim (forall (n :: Nat) t. t -> Dim n t
Dim (forall a. Fractional a => Rational -> a
fromRational Rational
x))
    / :: Dim m (Dim n (Matrix t))
-> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
(/) = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2Fforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F) forall a. Fractional a => a -> a -> a
(/)

instance (Floating (Vector t), Floating t, Numeric t) => Floating (Dim m (Dim n (Matrix t))) where
    sin :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
sin   = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
sin
    cos :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
cos   = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
cos
    tan :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
tan   = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
tan
    asin :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
asin  = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
asin
    acos :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
acos  = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
acos
    atan :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
atan  = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
atan
    sinh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
sinh  = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
sinh
    cosh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
cosh  = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
cosh
    tanh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
tanh  = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
tanh
    asinh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
asinh = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
asinh
    acosh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
acosh = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
acosh
    atanh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
atanh = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
atanh
    exp :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
exp   = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
exp
    log :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
log   = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
log
    sqrt :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
sqrt  = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t) -> Dim n (c t) -> Dim n (c t)
lift1F) forall a. Floating a => a -> a
sqrt
    ** :: Dim m (Dim n (Matrix t))
-> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
(**)  = (forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (c :: * -> *) t (n :: Nat).
(c t -> c t -> c t) -> Dim n (c t) -> Dim n (c t) -> Dim n (c t)
lift2F) forall a. Floating a => a -> a -> a
(**)
    pi :: Dim m (Dim n (Matrix t))
pi    = forall (n :: Nat) t. t -> Dim n t
Dim (forall (n :: Nat) t. t -> Dim n t
Dim forall a. Floating a => a
pi)

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


adaptDiag :: (L m n -> L m n -> t) -> L m n -> L m n -> t
adaptDiag L m n -> L m n -> t
f a :: L m n
a@(forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
isDiag -> Just (ℝ, Vector ℝ, (Int, Int))
_) L m n
b | forall {n :: Nat} {m :: Nat}.
(KnownNat n, KnownNat m) =>
L m n -> Bool
isFull L m n
b = L m n -> L m n -> t
f (forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
mkL (forall t s (d :: * -> *). Sized t s d => s -> d t
extract L m n
a)) L m n
b
adaptDiag L m n -> L m n -> t
f L m n
a b :: L m n
b@(forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
isDiag -> Just (ℝ, Vector ℝ, (Int, Int))
_) | forall {n :: Nat} {m :: Nat}.
(KnownNat n, KnownNat m) =>
L m n -> Bool
isFull L m n
a = L m n -> L m n -> t
f L m n
a (forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
mkL (forall t s (d :: * -> *). Sized t s d => s -> d t
extract L m n
b))
adaptDiag L m n -> L m n -> t
f L m n
a L m n
b = L m n -> L m n -> t
f L m n
a L m n
b

isFull :: L m n -> Bool
isFull L m n
m = forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
isDiag L m n
m forall a. Eq a => a -> a -> Bool
== forall a. Maybe a
Nothing Bool -> Bool -> Bool
&& Bool -> Bool
not (forall {t}. Matrix t -> Bool
singleM (forall t s (d :: * -> *). Sized t s d => s -> d t
unwrap L m n
m))


lift1L :: (Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ))
f (L Dim m (Dim n (Matrix ℝ))
v) = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
L (Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ))
f Dim m (Dim n (Matrix ℝ))
v)
lift2L :: (Dim m (Dim n (Matrix ℝ))
 -> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n -> L m n
lift2L Dim m (Dim n (Matrix ℝ))
-> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ))
f (L Dim m (Dim n (Matrix ℝ))
a) (L Dim m (Dim n (Matrix ℝ))
b) = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
L (Dim m (Dim n (Matrix ℝ))
-> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ))
f Dim m (Dim n (Matrix ℝ))
a Dim m (Dim n (Matrix ℝ))
b)
lift2LD :: (Dim m (Dim n (Matrix ℝ))
 -> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n -> L m n
lift2LD Dim m (Dim n (Matrix ℝ))
-> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ))
f = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {t}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(L m n -> L m n -> t) -> L m n -> L m n -> t
adaptDiag (forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat} {m :: Nat}
       {n :: Nat}.
(Dim m (Dim n (Matrix ℝ))
 -> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n -> L m n
lift2L Dim m (Dim n (Matrix ℝ))
-> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ))
f)


instance (KnownNat n, KnownNat m) =>  Num (L n m)
  where
    + :: L n m -> L n m -> L n m
(+) = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℝ))
 -> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n -> L m n
lift2LD forall a. Num a => a -> a -> a
(+)
    * :: L n m -> L n m -> L n m
(*) = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℝ))
 -> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n -> L m n
lift2LD forall a. Num a => a -> a -> a
(*)
    (-) = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℝ))
 -> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n -> L m n
lift2LD (-)
    abs :: L n m -> L n m
abs = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Num a => a -> a
abs
    signum :: L n m -> L n m
signum = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Num a => a -> a
signum
    negate :: L n m -> L n m
negate = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Num a => a -> a
negate
    fromInteger :: Integer -> L n m
fromInteger = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
L forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => Integer -> a
fromInteger

instance (KnownNat n, KnownNat m) => Fractional (L n m)
  where
    fromRational :: Rational -> L n m
fromRational = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
L forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Fractional a => Rational -> a
fromRational
    / :: L n m -> L n m -> L n m
(/) = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℝ))
 -> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n -> L m n
lift2LD forall a. Fractional a => a -> a -> a
(/)

instance (KnownNat n, KnownNat m) => Floating (L n m) where
    sin :: L n m -> L n m
sin   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
sin
    cos :: L n m -> L n m
cos   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
cos
    tan :: L n m -> L n m
tan   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
tan
    asin :: L n m -> L n m
asin  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
asin
    acos :: L n m -> L n m
acos  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
acos
    atan :: L n m -> L n m
atan  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
atan
    sinh :: L n m -> L n m
sinh  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
sinh
    cosh :: L n m -> L n m
cosh  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
cosh
    tanh :: L n m -> L n m
tanh  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
tanh
    asinh :: L n m -> L n m
asinh = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
asinh
    acosh :: L n m -> L n m
acosh = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
acosh
    atanh :: L n m -> L n m
atanh = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
atanh
    exp :: L n m -> L n m
exp   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
exp
    log :: L n m -> L n m
log   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
log
    sqrt :: L n m -> L n m
sqrt  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n
lift1L forall a. Floating a => a -> a
sqrt
    ** :: L n m -> L n m -> L n m
(**)  = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℝ))
 -> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
-> L m n -> L m n -> L m n
lift2LD forall a. Floating a => a -> a -> a
(**)
    pi :: L n m
pi    = forall t s (d :: * -> *). Sized t s d => t -> s
konst forall a. Floating a => a
pi

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

adaptDiagC :: (M m n -> M m n -> t) -> M m n -> M m n -> t
adaptDiagC M m n -> M m n -> t
f a :: M m n
a@(forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
isDiagC -> Just (ℂ, Vector ℂ, (Int, Int))
_) M m n
b | forall {n :: Nat} {m :: Nat}.
(KnownNat n, KnownNat m) =>
M m n -> Bool
isFullC M m n
b = M m n -> M m n -> t
f (forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM (forall t s (d :: * -> *). Sized t s d => s -> d t
extract M m n
a)) M m n
b
adaptDiagC M m n -> M m n -> t
f M m n
a b :: M m n
b@(forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
isDiagC -> Just (ℂ, Vector ℂ, (Int, Int))
_) | forall {n :: Nat} {m :: Nat}.
(KnownNat n, KnownNat m) =>
M m n -> Bool
isFullC M m n
a = M m n -> M m n -> t
f M m n
a (forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM (forall t s (d :: * -> *). Sized t s d => s -> d t
extract M m n
b))
adaptDiagC M m n -> M m n -> t
f M m n
a M m n
b = M m n -> M m n -> t
f M m n
a M m n
b

isFullC :: M m n -> Bool
isFullC M m n
m = forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
isDiagC M m n
m forall a. Eq a => a -> a -> Bool
== forall a. Maybe a
Nothing Bool -> Bool -> Bool
&& Bool -> Bool
not (forall {t}. Matrix t -> Bool
singleM (forall t s (d :: * -> *). Sized t s d => s -> d t
unwrap M m n
m))

lift1M :: (Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ))
f (M Dim m (Dim n (Matrix ℂ))
v) = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
M (Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ))
f Dim m (Dim n (Matrix ℂ))
v)
lift2M :: (Dim m (Dim n (Matrix ℂ))
 -> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n -> M m n
lift2M Dim m (Dim n (Matrix ℂ))
-> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ))
f (M Dim m (Dim n (Matrix ℂ))
a) (M Dim m (Dim n (Matrix ℂ))
b) = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
M (Dim m (Dim n (Matrix ℂ))
-> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ))
f Dim m (Dim n (Matrix ℂ))
a Dim m (Dim n (Matrix ℂ))
b)
lift2MD :: (Dim m (Dim n (Matrix ℂ))
 -> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n -> M m n
lift2MD Dim m (Dim n (Matrix ℂ))
-> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ))
f = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {t}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(M m n -> M m n -> t) -> M m n -> M m n -> t
adaptDiagC (forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat} {m :: Nat}
       {n :: Nat}.
(Dim m (Dim n (Matrix ℂ))
 -> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n -> M m n
lift2M Dim m (Dim n (Matrix ℂ))
-> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ))
f)

instance (KnownNat n, KnownNat m) =>  Num (M n m)
  where
    + :: M n m -> M n m -> M n m
(+) = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℂ))
 -> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n -> M m n
lift2MD forall a. Num a => a -> a -> a
(+)
    * :: M n m -> M n m -> M n m
(*) = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℂ))
 -> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n -> M m n
lift2MD forall a. Num a => a -> a -> a
(*)
    (-) = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℂ))
 -> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n -> M m n
lift2MD (-)
    abs :: M n m -> M n m
abs = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Num a => a -> a
abs
    signum :: M n m -> M n m
signum = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Num a => a -> a
signum
    negate :: M n m -> M n m
negate = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Num a => a -> a
negate
    fromInteger :: Integer -> M n m
fromInteger = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
M forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => Integer -> a
fromInteger

instance (KnownNat n, KnownNat m) => Fractional (M n m)
  where
    fromRational :: Rational -> M n m
fromRational = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
M forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (n :: Nat) t. t -> Dim n t
Dim forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Fractional a => Rational -> a
fromRational
    / :: M n m -> M n m -> M n m
(/) = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℂ))
 -> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n -> M m n
lift2MD forall a. Fractional a => a -> a -> a
(/)

instance (KnownNat n, KnownNat m) => Floating (M n m) where
    sin :: M n m -> M n m
sin   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
sin
    cos :: M n m -> M n m
cos   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
cos
    tan :: M n m -> M n m
tan   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
tan
    asin :: M n m -> M n m
asin  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
asin
    acos :: M n m -> M n m
acos  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
acos
    atan :: M n m -> M n m
atan  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
atan
    sinh :: M n m -> M n m
sinh  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
sinh
    cosh :: M n m -> M n m
cosh  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
cosh
    tanh :: M n m -> M n m
tanh  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
tanh
    asinh :: M n m -> M n m
asinh = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
asinh
    acosh :: M n m -> M n m
acosh = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
acosh
    atanh :: M n m -> M n m
atanh = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
atanh
    exp :: M n m -> M n m
exp   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
exp
    log :: M n m -> M n m
log   = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
log
    sqrt :: M n m -> M n m
sqrt  = forall {m :: Nat} {n :: Nat} {m :: Nat} {n :: Nat}.
(Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n
lift1M forall a. Floating a => a -> a
sqrt
    ** :: M n m -> M n m -> M n m
(**)  = forall {m :: Nat} {n :: Nat} {n :: Nat} {m :: Nat} {m :: Nat}
       {n :: Nat}.
(KnownNat m, KnownNat n, KnownNat n, KnownNat m) =>
(Dim m (Dim n (Matrix ℂ))
 -> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
-> M m n -> M m n -> M m n
lift2MD forall a. Floating a => a -> a -> a
(**)
    pi :: M n m
pi    = forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
M forall a. Floating a => a
pi

instance Additive (R n) where
    add :: R n -> R n -> R n
add = forall a. Num a => a -> a -> a
(+)

instance Additive (C n) where
    add :: C n -> C n -> C n
add = forall a. Num a => a -> a -> a
(+)

instance (KnownNat m, KnownNat n) => Additive (L m n) where
    add :: L m n -> L m n -> L m n
add = forall a. Num a => a -> a -> a
(+)

instance (KnownNat m, KnownNat n) => Additive (M m n) where
    add :: M m n -> M m n -> M m n
add = forall a. Num a => a -> a -> a
(+)

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


class Disp t
  where
    disp :: Int -> t -> IO ()


instance (KnownNat m, KnownNat n) => Disp (L m n)
  where
    disp :: Int -> L m n -> IO ()
disp Int
n L m n
x = do
        let a :: Matrix ℝ
a = forall t s (d :: * -> *). Sized t s d => s -> d t
extract L m n
x
        let su :: String
su = Int -> Matrix ℝ -> String
LA.dispf Int
n Matrix ℝ
a
        forall r. PrintfType r => String -> r
printf String
"L %d %d" (forall t. Matrix t -> Int
rows Matrix ℝ
a) (forall t. Matrix t -> Int
cols Matrix ℝ
a) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> IO ()
putStr (forall a. (a -> Bool) -> [a] -> [a]
dropWhile (forall a. Eq a => a -> a -> Bool
/=Char
'\n') forall a b. (a -> b) -> a -> b
$ String
su)

instance (KnownNat m, KnownNat n) => Disp (M m n)
  where
    disp :: Int -> M m n -> IO ()
disp Int
n M m n
x = do
        let a :: Matrix ℂ
a = forall t s (d :: * -> *). Sized t s d => s -> d t
extract M m n
x
        let su :: String
su = Int -> Matrix ℂ -> String
LA.dispcf Int
n Matrix ℂ
a
        forall r. PrintfType r => String -> r
printf String
"M %d %d" (forall t. Matrix t -> Int
rows Matrix ℂ
a) (forall t. Matrix t -> Int
cols Matrix ℂ
a) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> IO ()
putStr (forall a. (a -> Bool) -> [a] -> [a]
dropWhile (forall a. Eq a => a -> a -> Bool
/=Char
'\n') forall a b. (a -> b) -> a -> b
$ String
su)


instance KnownNat n => Disp (R n)
  where
    disp :: Int -> R n -> IO ()
disp Int
n R n
v = do
        let su :: String
su = Int -> Matrix ℝ -> String
LA.dispf Int
n (forall a. Storable a => Vector a -> Matrix a
asRow forall a b. (a -> b) -> a -> b
$ forall t s (d :: * -> *). Sized t s d => s -> d t
extract R n
v)
        String -> IO ()
putStr String
"R " forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> IO ()
putStr (forall a. [a] -> [a]
tail forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
dropWhile (forall a. Eq a => a -> a -> Bool
/=Char
'x') forall a b. (a -> b) -> a -> b
$ String
su)

instance KnownNat n => Disp (C n)
  where
    disp :: Int -> C n -> IO ()
disp Int
n C n
v = do
        let su :: String
su = Int -> Matrix ℂ -> String
LA.dispcf Int
n (forall a. Storable a => Vector a -> Matrix a
asRow forall a b. (a -> b) -> a -> b
$ forall t s (d :: * -> *). Sized t s d => s -> d t
extract C n
v)
        String -> IO ()
putStr String
"C " forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> IO ()
putStr (forall a. [a] -> [a]
tail forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
dropWhile (forall a. Eq a => a -> a -> Bool
/=Char
'x') forall a b. (a -> b) -> a -> b
$ String
su)

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

overMatL' :: (KnownNat m, KnownNat n)
          => (LA.Matrix ℝ -> LA.Matrix ℝ) -> L m n -> L m n
overMatL' :: forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
(Matrix ℝ -> Matrix ℝ) -> L m n -> L m n
overMatL' Matrix ℝ -> Matrix ℝ
f = forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
mkL forall b c a. (b -> c) -> (a -> b) -> a -> c
. Matrix ℝ -> Matrix ℝ
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t s (d :: * -> *). Sized t s d => s -> d t
unwrap
{-# INLINE overMatL' #-}

overMatM' :: (KnownNat m, KnownNat n)
          => (LA.Matrix ℂ -> LA.Matrix ℂ) -> M m n -> M m n
overMatM' :: forall (m :: Nat) (n :: Nat).
(KnownNat m, KnownNat n) =>
(Matrix ℂ -> Matrix ℂ) -> M m n -> M m n
overMatM' Matrix ℂ -> Matrix ℂ
f = forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
mkM forall b c a. (b -> c) -> (a -> b) -> a -> c
. Matrix ℂ -> Matrix ℂ
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t s (d :: * -> *). Sized t s d => s -> d t
unwrap
{-# INLINE overMatM' #-}


#else

module Numeric.LinearAlgebra.Static.Internal where

#endif