    {-# 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
    [Dim n t] -> ShowS
    Dim n t -> String
    (Int -> Dim n t -> ShowS)
    -> (Dim n t -> String) -> ([Dim n t] -> ShowS) -> Show (Dim n t)
    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
    $cshowsPrec :: forall (n :: Nat) t. Show t => Int -> Dim n t -> ShowS
    showsPrec :: Int -> Dim n t -> ShowS
    $cshow :: forall (n :: Nat) t. Show t => Dim n t -> String
    show :: Dim n t -> String
    $cshowList :: forall (n :: Nat) t. Show t => [Dim n t] -> ShowS
    showList :: [Dim n t] -> ShowS
    Show, (forall x. Dim n t -> Rep (Dim n t) x)
    -> (forall x. Rep (Dim n t) x -> Dim n t) -> Generic (Dim n t)
    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 x. Rep (Dim n t) x -> Dim n t
    forall 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
    $cfrom :: forall (n :: Nat) t x. Dim n t -> Rep (Dim n t) x
    from :: forall x. Dim n t -> Rep (Dim n t) x
    $cto :: forall (n :: Nat) t x. Rep (Dim n t) x -> Dim n t
    to :: forall x. Rep (Dim n t) x -> Dim n t
    Generic)

    instance (KnownNat n, Binary a) => Binary (Dim n a) where
      get :: Get (Dim n a)
    get = do
        k <- Get Integer
    forall t. Binary t => Get t
    get
        let n = Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy n
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy n)
        if n == k
          then Dim <$> get
          else fail ("Expected dimension " ++ (show n) ++ ", but found dimension " ++ (show k))

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

    newtype L m n = L (Dim m (Dim n (Matrix ℝ)))
      deriving ((forall x. L m n -> Rep (L m n) x)
    -> (forall x. Rep (L m n) x -> L m n) -> Generic (L m n)
    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 x. Rep (L m n) x -> L m n
    forall 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
    $cfrom :: forall (m :: Nat) (n :: Nat) x. L m n -> Rep (L m n) x
    from :: forall x. L m n -> Rep (L m n) x
    $cto :: forall (m :: Nat) (n :: Nat) x. Rep (L m n) x -> L m n
    to :: forall x. Rep (L m n) x -> L m n
    Generic, Get (L m n)
    [L m n] -> Put
    L m n -> Put
    (L m n -> Put) -> Get (L m n) -> ([L m n] -> Put) -> Binary (L m n)
    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
    $cput :: forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    L m n -> Put
    put :: L m n -> Put
    $cget :: forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    Get (L m n)
    get :: Get (L m n)
    $cputList :: forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    [L m n] -> Put
    putList :: [L m n] -> Put
    Binary)

    newtype M m n = M (Dim m (Dim n (Matrix ℂ)))
      deriving ((forall x. M m n -> Rep (M m n) x)
    -> (forall x. Rep (M m n) x -> M m n) -> Generic (M m n)
    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 x. Rep (M m n) x -> M m n
    forall 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
    $cfrom :: forall (m :: Nat) (n :: Nat) x. M m n -> Rep (M m n) x
    from :: forall x. M m n -> Rep (M m n) x
    $cto :: forall (m :: Nat) (n :: Nat) x. Rep (M m n) x -> M m n
    to :: forall x. Rep (M m n) x -> M m n
    Generic)

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

    mkC :: Vector ℂ -> C n
    mkC :: forall (n :: Nat). Vector ℂ -> C n
    mkC = Dim n (Vector ℂ) -> C n
    forall (n :: Nat). Dim n (Vector ℂ) -> C n
    C (Dim n (Vector ℂ) -> C n)
    -> (Vector ℂ -> Dim n (Vector ℂ)) -> Vector ℂ -> C n
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector ℂ -> Dim n (Vector ℂ)
    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 = Dim m (Dim n (Matrix ℝ)) -> L m n
    forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
    L (Dim n (Matrix ℝ) -> Dim m (Dim n (Matrix ℝ))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix ℝ -> Dim n (Matrix ℝ)
    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 = Dim m (Dim n (Matrix ℂ)) -> M m n
    forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
    M (Dim n (Matrix ℂ) -> Dim m (Dim n (Matrix ℂ))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix ℂ -> Dim n (Matrix ℂ)
    forall (n :: Nat) t. t -> Dim n t
    Dim Matrix ℂ
    x))

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

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

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

    instance NFData (M n m) where
        rnf :: M n m -> ()
    rnf (M (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    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 = t -> Dim n t
    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
    (V n t -> Vector 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` (V m t -> Vector t
    forall (n :: Nat) t. Dim n (Vector t) -> Vector t
    ud -> Vector t
    v) = Vector t -> Dim (n + m) (Vector t)
    forall (n :: Nat) t. t -> Dim n t
    mkV ([Vector t] -> Vector t
    forall t. Storable t => [Vector t] -> Vector t
    vjoin [Vector t
    u', Vector t
    v'])
      where
        du :: Int
    du = Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy n -> Integer) -> Proxy n -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy n -> Int) -> Proxy n -> Int
    forall a b. (a -> b) -> a -> b
    $ (Proxy n
    forall a. HasCallStack => a
    undefined :: Proxy n)
        dv :: Int
    dv = Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy m -> Integer) -> Proxy m -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy m -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy m -> Int) -> Proxy m -> Int
    forall a b. (a -> b) -> a -> b
    $ (Proxy m
    forall a. HasCallStack => a
    undefined :: Proxy m)
        u' :: Vector t
    u' | Int
    du Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Int
    1 Bool -> Bool -> Bool
    && Vector t -> IndexOf Vector
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Vector t
    u Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 = t -> Int -> Vector t
    forall e d (c :: * -> *). Konst e d c => e -> d -> c e
    LA.konst (Vector t
    u Vector t -> Int -> t
    forall t. Storable t => Vector t -> Int -> t
    D.@> Int
    0) Int
    du
           | Bool
    otherwise = Vector t
    u
        v' :: Vector t
    v' | Int
    dv Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Int
    1 Bool -> Bool -> Bool
    && Vector t -> IndexOf Vector
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Vector t
    v Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 = t -> Int -> Vector t
    forall e d (c :: * -> *). Konst e d c => e -> d -> c e
    LA.konst (Vector t
    v Vector t -> Int -> t
    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 = Vector t -> Dim 2 (Vector t)
    forall (n :: Nat) t. t -> Dim n t
    mkV (Vector t -> Dim 2 (Vector t)) -> Vector t -> Dim 2 (Vector t)
    forall a b. (a -> b) -> a -> b
    $ (forall s. ST s (STVector s t)) -> Vector t
    forall t. Storable t => (forall s. ST s (STVector s t)) -> Vector t
    runSTVector ((forall s. ST s (STVector s t)) -> Vector t)
    -> (forall s. ST s (STVector s t)) -> Vector t
    forall a b. (a -> b) -> a -> b
    $ do
        v <- Int -> ST s (STVector s t)
    forall t s. Storable t => Int -> ST s (STVector s t)
    newUndefinedVector Int
    2
        writeVector v 0 a
        writeVector v 1 b
        return 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 = Vector t -> Dim 3 (Vector t)
    forall (n :: Nat) t. t -> Dim n t
    mkV (Vector t -> Dim 3 (Vector t)) -> Vector t -> Dim 3 (Vector t)
    forall a b. (a -> b) -> a -> b
    $ (forall s. ST s (STVector s t)) -> Vector t
    forall t. Storable t => (forall s. ST s (STVector s t)) -> Vector t
    runSTVector ((forall s. ST s (STVector s t)) -> Vector t)
    -> (forall s. ST s (STVector s t)) -> Vector t
    forall a b. (a -> b) -> a -> b
    $ do
        v <- Int -> ST s (STVector s t)
    forall t s. Storable t => Int -> ST s (STVector s t)
    newUndefinedVector Int
    3
        writeVector v 0 a
        writeVector v 1 b
        writeVector v 2 c
        return 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 = Vector t -> Dim 4 (Vector t)
    forall (n :: Nat) t. t -> Dim n t
    mkV (Vector t -> Dim 4 (Vector t)) -> Vector t -> Dim 4 (Vector t)
    forall a b. (a -> b) -> a -> b
    $ (forall s. ST s (STVector s t)) -> Vector t
    forall t. Storable t => (forall s. ST s (STVector s t)) -> Vector t
    runSTVector ((forall s. ST s (STVector s t)) -> Vector t)
    -> (forall s. ST s (STVector s t)) -> Vector t
    forall a b. (a -> b) -> a -> b
    $ do
        v <- Int -> ST s (STVector s t)
    forall t s. Storable t => Int -> ST s (STVector s t)
    newUndefinedVector Int
    4
        writeVector v 0 a
        writeVector v 1 b
        writeVector v 2 c
        writeVector v 3 d
        return 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 = Vector t -> Dim n (Vector t)
    forall (n :: Nat) t. t -> Dim n t
    mkV Vector t
    v
        | Bool -> Bool
    not ([t] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [t]
    rest) Bool -> Bool -> Bool
    && [t] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null ([t] -> [t]
    forall a. HasCallStack => [a] -> [a]
    tail [t]
    rest) = String -> Dim n (Vector t)
    forall {a}. String -> a
    abort ([t] -> String
    forall a. Show a => a -> String
    show [t]
    xs')
        | Bool -> Bool
    not ([t] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [t]
    rest) = String -> Dim n (Vector t)
    forall {a}. String -> a
    abort (ShowS
    forall a. HasCallStack => [a] -> [a]
    init ([t] -> String
    forall a. Show a => a -> String
    show ([t]
    xs[t] -> [t] -> [t]
    forall a. [a] -> [a] -> [a]
    ++Int -> [t] -> [t]
    forall a. Int -> [a] -> [a]
    take Int
    1 [t]
    rest))String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++String
    ", ... ]")
        | Bool
    otherwise = String -> Dim n (Vector t)
    forall {a}. String -> a
    abort ([t] -> String
    forall a. Show a => a -> String
    show [t]
    xs)
      where
        ([t]
    xs,[t]
    rest) = Int -> [t] -> ([t], [t])
    forall a. Int -> [a] -> ([a], [a])
    splitAt Int
    d [t]
    xs'
        ok :: Bool
    ok = Vector t -> IndexOf Vector
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Vector t
    v Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    d Bool -> Bool -> Bool
    && [t] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [t]
    rest
        v :: Vector t
    v = [t] -> Vector t
    forall a. Storable a => [a] -> Vector a
    LA.fromList [t]
    xs
        d :: Int
    d = Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy n -> Integer) -> Proxy n -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy n -> Int) -> Proxy n -> Int
    forall a b. (a -> b) -> a -> b
    $ (Proxy n
    forall a. HasCallStack => a
    undefined :: Proxy n)
        abort :: String -> a
    abort String
    info = String -> a
    forall a. HasCallStack => String -> a
    error (String -> a) -> String -> a
    forall a b. (a -> b) -> a -> b
    $ String
    stString -> ShowS
    forall a. [a] -> [a] -> [a]
    ++String
    " "String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++Int -> String
    forall a. Show a => a -> String
    show Int
    dString -> ShowS
    forall a. [a] -> [a] -> [a]
    ++String
    " can't be created from elements "String -> ShowS
    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 = Dim n (Matrix t) -> Dim m (Dim n (Matrix t))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix t -> Dim n (Matrix t)
    forall (n :: Nat) t. t -> Dim n t
    Dim Matrix t
    x)
        | Bool -> Bool
    not ([t] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [t]
    rest) Bool -> Bool -> Bool
    && [t] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null ([t] -> [t]
    forall a. HasCallStack => [a] -> [a]
    tail [t]
    rest) = String -> Dim m (Dim n (Matrix t))
    forall {a}. String -> a
    abort ([t] -> String
    forall a. Show a => a -> String
    show [t]
    xs')
        | Bool -> Bool
    not ([t] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [t]
    rest) = String -> Dim m (Dim n (Matrix t))
    forall {a}. String -> a
    abort (ShowS
    forall a. HasCallStack => [a] -> [a]
    init ([t] -> String
    forall a. Show a => a -> String
    show ([t]
    xs[t] -> [t] -> [t]
    forall a. [a] -> [a] -> [a]
    ++Int -> [t] -> [t]
    forall a. Int -> [a] -> [a]
    take Int
    1 [t]
    rest))String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++String
    ", ... ]")
        | Bool
    otherwise = String -> Dim m (Dim n (Matrix t))
    forall {a}. String -> a
    abort ([t] -> String
    forall a. Show a => a -> String
    show [t]
    xs)
      where
        ([t]
    xs,[t]
    rest) = Int -> [t] -> ([t], [t])
    forall a. Int -> [a] -> ([a], [a])
    splitAt (Int
    m'Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *Int
    n') [t]
    xs'
        v :: Vector t
    v = [t] -> Vector t
    forall a. Storable a => [a] -> Vector a
    LA.fromList [t]
    xs
        x :: Matrix t
    x = Int -> Vector t -> Matrix t
    forall t. Storable t => Int -> Vector t -> Matrix t
    reshape Int
    n' Vector t
    v
        ok :: Bool
    ok = [t] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [t]
    rest Bool -> Bool -> Bool
    && ((Int
    n' Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    0 Bool -> Bool -> Bool
    && Vector t -> Int
    forall t. Storable t => Vector t -> Int
    dim Vector t
    v Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    0) Bool -> Bool -> Bool
    || Int
    n'Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0 Bool -> Bool -> Bool
    && (Int -> Int -> Int
    forall a. Integral a => a -> a -> a
    rem (Vector t -> IndexOf Vector
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Vector t
    v) Int
    n' Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    0) Bool -> Bool -> Bool
    && Matrix t -> IndexOf Matrix
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Matrix t
    x (Int, Int) -> (Int, Int) -> Bool
    forall a. Eq a => a -> a -> Bool
    == (Int
    m',Int
    n'))
        m' :: Int
    m' = Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy m -> Integer) -> Proxy m -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy m -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy m -> Int) -> Proxy m -> Int
    forall a b. (a -> b) -> a -> b
    $ (Proxy m
    forall a. HasCallStack => a
    undefined :: Proxy m) :: Int
        n' :: Int
    n' = Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy n -> Integer) -> Proxy n -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy n -> Int) -> Proxy n -> Int
    forall a b. (a -> b) -> a -> b
    $ (Proxy n
    forall a. HasCallStack => a
    undefined :: Proxy n) :: Int
        abort :: String -> a
    abort String
    info = String -> a
    forall a. HasCallStack => String -> a
    error (String -> a) -> String -> a
    forall a b. (a -> b) -> a -> b
    $ String
    st String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++String
    " "String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++Int -> String
    forall a. Show a => a -> String
    show Int
    m' String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    n'String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++String
    " can't be created from elements " String -> ShowS
    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 = c t -> IndexOf c
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size c t
    v IndexOf c -> IndexOf c -> Bool
    forall a. Eq a => a -> a -> Bool
    == IndexOf c
    1
    singleM :: Matrix t -> Bool
    singleM Matrix t
    m = Matrix t -> Int
    forall t. Matrix t -> Int
    rows Matrix t
    m Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 Bool -> Bool -> Bool
    && Matrix t -> Int
    forall t. Matrix t -> Int
    cols Matrix t
    m Int -> Int -> Bool
    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
    _ = Integer -> Int
    Integer -> IndexOf Vector
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> IndexOf Vector)
    -> (Proxy n -> Integer) -> Proxy n -> IndexOf Vector
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy n -> IndexOf Vector) -> Proxy n -> IndexOf Vector
    forall a b. (a -> b) -> a -> b
    $ (Proxy n
    forall a. HasCallStack => a
    undefined :: Proxy n)
        konst :: ℂ -> C n
    konst ℂ
    x = Vector ℂ -> C n
    forall (n :: Nat). Vector ℂ -> C n
    mkC (ℂ -> Vector ℂ
    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 = Dim n (Vector ℂ) -> C n
    forall (n :: Nat). Dim n (Vector ℂ) -> C n
    C (String -> [ℂ] -> Dim n (Vector ℂ)
    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@(C n -> Vector ℂ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    unwrap -> Vector ℂ
    v)
          | Vector ℂ -> Bool
    forall {c :: * -> *} {t}.
    (Eq (IndexOf c), Container c t, Num (IndexOf c)) =>
    c t -> Bool
    singleV Vector ℂ
    v = ℂ -> IndexOf Vector -> Vector ℂ
    forall e d (c :: * -> *). Konst e d c => e -> d -> c e
    LA.konst (Vector ℂ
    vVector ℂ -> Int -> ℂ
    forall c t. Indexable c t => c -> Int -> t
    !Int
    0) (C n -> IndexOf Vector
    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
            | Vector ℂ -> IndexOf Vector
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Vector ℂ
    v Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == C n -> IndexOf Vector
    forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
    size C n
    r = C n -> Maybe (C n)
    forall a. a -> Maybe a
    Just C n
    r
            | Bool
    otherwise = Maybe (C n)
    forall a. Maybe a
    Nothing
          where
            r :: C n
    r = Vector ℂ -> C n
    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
    _ = Integer -> Int
    Integer -> IndexOf Vector
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> IndexOf Vector)
    -> (Proxy n -> Integer) -> Proxy n -> IndexOf Vector
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy n -> IndexOf Vector) -> Proxy n -> IndexOf Vector
    forall a b. (a -> b) -> a -> b
    $ (Proxy n
    forall a. HasCallStack => a
    undefined :: Proxy n)
        konst :: ℝ -> R n
    konst ℝ
    x = Vector ℝ -> R n
    forall (n :: Nat). Vector ℝ -> R n
    mkR (ℝ -> Vector ℝ
    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 = Dim n (Vector ℝ) -> R n
    forall (n :: Nat). Dim n (Vector ℝ) -> R n
    R (String -> [ℝ] -> Dim n (Vector ℝ)
    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@(R n -> Vector ℝ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    unwrap -> Vector ℝ
    v)
          | Vector ℝ -> Bool
    forall {c :: * -> *} {t}.
    (Eq (IndexOf c), Container c t, Num (IndexOf c)) =>
    c t -> Bool
    singleV Vector ℝ
    v = ℝ -> IndexOf Vector -> Vector ℝ
    forall e d (c :: * -> *). Konst e d c => e -> d -> c e
    LA.konst (Vector ℝ
    vVector ℝ -> Int -> ℝ
    forall c t. Indexable c t => c -> Int -> t
    !Int
    0) (R n -> IndexOf Vector
    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
            | Vector ℝ -> IndexOf Vector
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Vector ℝ
    v Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == R n -> IndexOf Vector
    forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
    size R n
    r = R n -> Maybe (R n)
    forall a. a -> Maybe a
    Just R n
    r
            | Bool
    otherwise = Maybe (R n)
    forall a. Maybe a
    Nothing
          where
            r :: R n
    r = Vector ℝ -> R n
    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
    _ = ((Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy m -> Integer) -> Proxy m -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy m -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal) (Proxy m
    forall a. HasCallStack => a
    undefined :: Proxy m)
                 ,(Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy n -> Integer) -> Proxy n -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal) (Proxy n
    forall a. HasCallStack => a
    undefined :: Proxy n))
        konst :: ℝ -> L m n
    konst ℝ
    x = Matrix ℝ -> L m n
    forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
    mkL (ℝ -> Matrix ℝ
    forall (c :: * -> *) e. Container c e => e -> c e
    LA.scalar ℝ
    x)
        fromList :: [ℝ] -> L m n
    fromList [ℝ]
    xs = Dim m (Dim n (Matrix ℝ)) -> L m n
    forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
    L (String -> [ℝ] -> Dim m (Dim n (Matrix ℝ))
    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 (L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
    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'))) = ℝ -> Vector ℝ -> Int -> Int -> Matrix ℝ
    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@(L m n -> Matrix ℝ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    unwrap -> Matrix ℝ
    a)
            | Matrix ℝ -> Bool
    forall {t}. Matrix t -> Bool
    singleM Matrix ℝ
    a = ℝ -> IndexOf Matrix -> Matrix ℝ
    forall e d (c :: * -> *). Konst e d c => e -> d -> c e
    LA.konst (Matrix ℝ
    a Matrix ℝ -> IndexOf Matrix -> ℝ
    forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
    `atIndex` (Int
    0,Int
    0)) (L m n -> IndexOf Matrix
    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
            | Matrix ℝ -> IndexOf Matrix
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Matrix ℝ
    x (Int, Int) -> (Int, Int) -> Bool
    forall a. Eq a => a -> a -> Bool
    == L m n -> IndexOf Matrix
    forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
    size L m n
    r = L m n -> Maybe (L m n)
    forall a. a -> Maybe a
    Just L m n
    r
            | Bool
    otherwise = Maybe (L m n)
    forall a. Maybe a
    Nothing
          where
            r :: L m n
    r = Matrix ℝ -> L m n
    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
    _ = ((Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy m -> Integer) -> Proxy m -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy m -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal) (Proxy m
    forall a. HasCallStack => a
    undefined :: Proxy m)
                 ,(Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy n -> Integer) -> Proxy n -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal) (Proxy n
    forall a. HasCallStack => a
    undefined :: Proxy n))
        konst :: ℂ -> M m n
    konst ℂ
    x = Matrix ℂ -> M m n
    forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
    mkM (ℂ -> Matrix ℂ
    forall (c :: * -> *) e. Container c e => e -> c e
    LA.scalar ℂ
    x)
        fromList :: [ℂ] -> M m n
    fromList [ℂ]
    xs = Dim m (Dim n (Matrix ℂ)) -> M m n
    forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
    M (String -> [ℂ] -> Dim m (Dim n (Matrix ℂ))
    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 (M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    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'))) = ℂ -> Vector ℂ -> Int -> Int -> Matrix ℂ
    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@(M m n -> Matrix ℂ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    unwrap -> Matrix ℂ
    a)
            | Matrix ℂ -> Bool
    forall {t}. Matrix t -> Bool
    singleM Matrix ℂ
    a = ℂ -> IndexOf Matrix -> Matrix ℂ
    forall e d (c :: * -> *). Konst e d c => e -> d -> c e
    LA.konst (Matrix ℂ
    a Matrix ℂ -> IndexOf Matrix -> ℂ
    forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
    `atIndex` (Int
    0,Int
    0)) (M m n -> IndexOf Matrix
    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
            | Matrix ℂ -> IndexOf Matrix
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Matrix ℂ
    x (Int, Int) -> (Int, Int) -> Bool
    forall a. Eq a => a -> a -> Bool
    == M m n -> IndexOf Matrix
    forall t s (d :: * -> *). Sized t s d => s -> IndexOf d
    size M m n
    r = M m n -> Maybe (M m n)
    forall a. a -> Maybe a
    Just M m n
    r
            | Bool
    otherwise = Maybe (M m n)
    forall a. Maybe a
    Nothing
          where
            r :: M m n
    r = Matrix ℂ -> M m n
    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@(L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
    forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
    isDiag -> Just (ℝ, Vector ℝ, (Int, Int))
    _) = Matrix ℝ -> L n m
    forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
    mkL (L m n -> Matrix ℝ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    extract L m n
    a)
        tr (L m n -> Matrix ℝ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    extract -> Matrix ℝ
    a) = Matrix ℝ -> L n m
    forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
    mkL (Matrix ℝ -> Matrix ℝ
    forall m mt. Transposable m mt => m -> mt
    tr Matrix ℝ
    a)
        tr' :: L m n -> L n m
    tr' = L m n -> L n m
    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@(M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    isDiagC -> Just (ℂ, Vector ℂ, (Int, Int))
    _) = Matrix ℂ -> M n m
    forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
    mkM (M m n -> Matrix ℂ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    extract M m n
    a)
        tr (M m n -> Matrix ℂ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    extract -> Matrix ℂ
    a) = Matrix ℂ -> M n m
    forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
    mkM (Matrix ℂ -> Matrix ℂ
    forall m mt. Transposable m mt => m -> mt
    tr Matrix ℂ
    a)
        tr' :: M m n -> M n m
    tr' a :: M m n
    a@(M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    isDiagC -> Just (ℂ, Vector ℂ, (Int, Int))
    _) = Matrix ℂ -> M n m
    forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
    mkM (M m n -> Matrix ℂ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    extract M m n
    a)
        tr' (M m n -> Matrix ℂ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    extract -> Matrix ℂ
    a) = Matrix ℂ -> M n m
    forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
    mkM (Matrix ℂ -> Matrix ℂ
    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) = Dim m (Dim n (Matrix ℝ)) -> Maybe (ℝ, Vector ℝ, (Int, Int))
    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) = Dim m (Dim n (Matrix ℂ)) -> Maybe (ℂ, Vector ℂ, (Int, Int))
    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))
        | Matrix t -> Bool
    forall {t}. Matrix t -> Bool
    singleM Matrix t
    x = Maybe (t, Vector t, (Int, Int))
    forall a. Maybe a
    Nothing
        | Matrix t -> Int
    forall t. Matrix t -> Int
    rows Matrix t
    x Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 Bool -> Bool -> Bool
    && Int
    m' Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    1 Bool -> Bool -> Bool
    || Matrix t -> Int
    forall t. Matrix t -> Int
    cols Matrix t
    x Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 Bool -> Bool -> Bool
    && Int
    n' Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    1 = (t, Vector t, (Int, Int)) -> Maybe (t, Vector t, (Int, Int))
    forall a. a -> Maybe a
    Just (t
    z,Vector t
    yz,(Int
    m',Int
    n'))
        | Bool
    otherwise = Maybe (t, Vector t, (Int, Int))
    forall a. Maybe a
    Nothing
      where
        m' :: Int
    m' = Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy m -> Integer) -> Proxy m -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy m -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy m -> Int) -> Proxy m -> Int
    forall a b. (a -> b) -> a -> b
    $ (Proxy m
    forall a. HasCallStack => a
    undefined :: Proxy m) :: Int
        n' :: Int
    n' = Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Integer -> Int) -> (Proxy n -> Integer) -> Proxy n -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy n -> Int) -> Proxy n -> Int
    forall a b. (a -> b) -> a -> b
    $ (Proxy n
    forall a. HasCallStack => a
    undefined :: Proxy n) :: Int
        v :: Vector t
    v = Matrix t -> Vector t
    forall t. Element t => Matrix t -> Vector t
    flatten Matrix t
    x
        z :: t
    z = Vector t
    v Vector t -> IndexOf Vector -> t
    forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
    `atIndex` Int
    IndexOf Vector
    0
        y :: Vector t
    y = Int -> Int -> Vector t -> Vector t
    forall t. Storable t => Int -> Int -> Vector t -> Vector t
    subVector Int
    1 (Vector t -> IndexOf Vector
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Vector t
    vInt -> Int -> Int
    forall a. Num a => a -> a -> a
    -Int
    1) Vector t
    v
        ny :: IndexOf Vector
    ny = Vector t -> IndexOf Vector
    forall (c :: * -> *) t. Container c t => c t -> IndexOf c
    LA.size Vector t
    y
        zeros :: Vector t
    zeros = t -> Int -> Vector t
    forall e d (c :: * -> *). Konst e d c => e -> d -> c e
    LA.konst t
    0 (Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    0 (Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    min Int
    m' Int
    n' Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ny))
        yz :: Vector t
    yz = [Vector t] -> Vector t
    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))
          | Vector ℝ -> Bool
    forall {c :: * -> *} {t}.
    (Eq (IndexOf c), Container c t, Num (IndexOf c)) =>
    c t -> Bool
    singleV Vector ℝ
    v = String
    "(" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ℝ -> String
    forall a. Show a => a -> String
    show (Vector ℝ
    vVector ℝ -> Int -> ℝ
    forall c t. Indexable c t => c -> Int -> t
    !Int
    0) String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " :: R " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    d String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"
          | Bool
    otherwise = String
    "(vector " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Vector ℝ -> String
    forall a. Show a => a -> String
    show Vector ℝ
    v String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " :: R " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    d String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++String
    ")"
          where
            d :: IndexOf Vector
    d = R n -> IndexOf Vector
    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))
          | Vector ℂ -> Bool
    forall {c :: * -> *} {t}.
    (Eq (IndexOf c), Container c t, Num (IndexOf c)) =>
    c t -> Bool
    singleV Vector ℂ
    v = String
    "(" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ℂ -> String
    forall a. Show a => a -> String
    show (Vector ℂ
    vVector ℂ -> Int -> ℂ
    forall c t. Indexable c t => c -> Int -> t
    !Int
    0) String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " :: C " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    d String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"
          | Bool
    otherwise = String
    "(vector " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Vector ℂ -> String
    forall a. Show a => a -> String
    show Vector ℂ
    v String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " :: C " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    d String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++String
    ")"
          where
            d :: IndexOf Vector
    d = C n -> IndexOf Vector
    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 (L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
    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'))) = String -> String -> String -> Int -> Int -> String
    forall r. PrintfType r => String -> r
    printf String
    "(diag %s %s :: L %d %d)" (ℝ -> String
    forall a. Show a => a -> String
    show ℝ
    z) (Vector ℝ -> String
    forall a. Show a => a -> String
    show Vector ℝ
    y) Int
    m' Int
    n'
        show s :: L m n
    s@(L (Dim (Dim Matrix ℝ
    x)))
           | Matrix ℝ -> Bool
    forall {t}. Matrix t -> Bool
    singleM Matrix ℝ
    x = String -> String -> Int -> Int -> String
    forall r. PrintfType r => String -> r
    printf String
    "(%s :: L %d %d)" (ℝ -> String
    forall a. Show a => a -> String
    show (Matrix ℝ
    x Matrix ℝ -> IndexOf Matrix -> ℝ
    forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
    `atIndex` (Int
    0,Int
    0))) Int
    m' Int
    n'
           | Bool
    otherwise = String
    "(matrix" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ (Char -> Bool) -> ShowS
    forall a. (a -> Bool) -> [a] -> [a]
    dropWhile (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /=Char
    '\n') (Matrix ℝ -> String
    forall a. Show a => a -> String
    show Matrix ℝ
    x) String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " :: L " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    m' String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    n' String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"
          where
            (Int
    m',Int
    n') = L m n -> IndexOf Matrix
    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 (M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    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'))) = String -> String -> String -> Int -> Int -> String
    forall r. PrintfType r => String -> r
    printf String
    "(diag %s %s :: M %d %d)" (ℂ -> String
    forall a. Show a => a -> String
    show ℂ
    z) (Vector ℂ -> String
    forall a. Show a => a -> String
    show Vector ℂ
    y) Int
    m' Int
    n'
        show s :: M m n
    s@(M (Dim (Dim Matrix ℂ
    x)))
           | Matrix ℂ -> Bool
    forall {t}. Matrix t -> Bool
    singleM Matrix ℂ
    x = String -> String -> Int -> Int -> String
    forall r. PrintfType r => String -> r
    printf String
    "(%s :: M %d %d)" (ℂ -> String
    forall a. Show a => a -> String
    show (Matrix ℂ
    x Matrix ℂ -> IndexOf Matrix -> ℂ
    forall (c :: * -> *) e. Container c e => c e -> IndexOf c -> e
    `atIndex` (Int
    0,Int
    0))) Int
    m' Int
    n'
           | Bool
    otherwise = String
    "(matrix" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ (Char -> Bool) -> ShowS
    forall a. (a -> Bool) -> [a] -> [a]
    dropWhile (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /=Char
    '\n') (Matrix ℂ -> String
    forall a. Show a => a -> String
    show Matrix ℂ
    x) String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " :: M " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    m' String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    n' String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"
          where
            (Int
    m',Int
    n') = M m n -> IndexOf Matrix
    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)
    (+) = (Vector t -> Vector t -> Vector t)
    -> 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 Vector t -> Vector t -> Vector t
    forall a. Num a => a -> a -> a
    (+)
        * :: Dim n (Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    (*) = (Vector t -> Vector t -> Vector t)
    -> 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 Vector t -> Vector t -> Vector t
    forall a. Num a => a -> a -> a
    (*)
        (-) = (Vector t -> Vector t -> Vector t)
    -> 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 (-)
        abs :: Dim n (Vector t) -> Dim n (Vector t)
    abs = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Num a => a -> a
    abs
        signum :: Dim n (Vector t) -> Dim n (Vector t)
    signum = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Num a => a -> a
    signum
        negate :: Dim n (Vector t) -> Dim n (Vector t)
    negate = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Num a => a -> a
    negate
        fromInteger :: Integer -> Dim n (Vector t)
    fromInteger Integer
    x = Vector t -> Dim n (Vector t)
    forall (n :: Nat) t. t -> Dim n t
    Dim (Integer -> Vector t
    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 = Vector t -> Dim n (Vector t)
    forall (n :: Nat) t. t -> Dim n t
    Dim (Rational -> Vector t
    forall a. Fractional a => Rational -> a
    fromRational Rational
    x)
        / :: Dim n (Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    (/) = (Vector t -> Vector t -> Vector t)
    -> 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 Vector t -> Vector t -> Vector t
    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   = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    sin
        cos :: Dim n (Vector t) -> Dim n (Vector t)
    cos   = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    cos
        tan :: Dim n (Vector t) -> Dim n (Vector t)
    tan   = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    tan
        asin :: Dim n (Vector t) -> Dim n (Vector t)
    asin  = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    asin
        acos :: Dim n (Vector t) -> Dim n (Vector t)
    acos  = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    acos
        atan :: Dim n (Vector t) -> Dim n (Vector t)
    atan  = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    atan
        sinh :: Dim n (Vector t) -> Dim n (Vector t)
    sinh  = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    sinh
        cosh :: Dim n (Vector t) -> Dim n (Vector t)
    cosh  = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    cosh
        tanh :: Dim n (Vector t) -> Dim n (Vector t)
    tanh  = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    tanh
        asinh :: Dim n (Vector t) -> Dim n (Vector t)
    asinh = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    asinh
        acosh :: Dim n (Vector t) -> Dim n (Vector t)
    acosh = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    acosh
        atanh :: Dim n (Vector t) -> Dim n (Vector t)
    atanh = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    atanh
        exp :: Dim n (Vector t) -> Dim n (Vector t)
    exp   = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    exp
        log :: Dim n (Vector t) -> Dim n (Vector t)
    log   = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    log
        sqrt :: Dim n (Vector t) -> Dim n (Vector t)
    sqrt  = (Vector t -> Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F Vector t -> Vector t
    forall a. Floating a => a -> a
    sqrt
        ** :: Dim n (Vector t) -> Dim n (Vector t) -> Dim n (Vector t)
    (**)  = (Vector t -> Vector t -> Vector t)
    -> 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 Vector t -> Vector t -> Vector t
    forall a. Floating a => a -> a -> a
    (**)
        pi :: Dim n (Vector t)
    pi    = Vector t -> Dim n (Vector t)
    forall (n :: Nat) t. t -> Dim n t
    Dim Vector t
    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))
    (+) = ((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> 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 ((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t -> Matrix t)
        -> Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t -> Matrix t)
    -> Dim n (Matrix t) -> Dim n (Matrix t) -> 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) Matrix t -> Matrix t -> Matrix t
    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))
    (*) = ((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> 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 ((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t -> Matrix t)
        -> Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t -> Matrix t)
    -> Dim n (Matrix t) -> Dim n (Matrix t) -> 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) Matrix t -> Matrix t -> Matrix t
    forall a. Num a => a -> a -> a
    (*)
        (-) = ((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> 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 ((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t -> Matrix t)
        -> Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t -> Matrix t)
    -> Dim n (Matrix t) -> Dim n (Matrix t) -> 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) (-)
        abs :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    abs = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Num a => a -> a
    abs
        signum :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    signum = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Num a => a -> a
    signum
        negate :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    negate = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Num a => a -> a
    negate
        fromInteger :: Integer -> Dim m (Dim n (Matrix t))
    fromInteger Integer
    x = Dim n (Matrix t) -> Dim m (Dim n (Matrix t))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix t -> Dim n (Matrix t)
    forall (n :: Nat) t. t -> Dim n t
    Dim (Integer -> Matrix t
    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 = Dim n (Matrix t) -> Dim m (Dim n (Matrix t))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix t -> Dim n (Matrix t)
    forall (n :: Nat) t. t -> Dim n t
    Dim (Rational -> Matrix t
    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))
    (/) = ((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> 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((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t -> Matrix t)
        -> Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .(Matrix t -> Matrix t -> Matrix t)
    -> Dim n (Matrix t) -> Dim n (Matrix t) -> 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) Matrix t -> Matrix t -> Matrix t
    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   = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    sin
        cos :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    cos   = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    cos
        tan :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    tan   = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    tan
        asin :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    asin  = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    asin
        acos :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    acos  = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    acos
        atan :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    atan  = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    atan
        sinh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    sinh  = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    sinh
        cosh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    cosh  = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    cosh
        tanh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    tanh  = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    tanh
        asinh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    asinh = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    asinh
        acosh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    acosh = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    acosh
        atanh :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    atanh = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    atanh
        exp :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    exp   = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    exp
        log :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    log   = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    forall a. Floating a => a -> a
    log
        sqrt :: Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t))
    sqrt  = ((Dim n (Matrix t) -> 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) -> Dim n (c t) -> Dim n (c t)
    lift1F ((Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)) -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t)
    forall (c :: * -> *) t (n :: Nat).
    (c t -> c t) -> Dim n (c t) -> Dim n (c t)
    lift1F) Matrix t -> Matrix t
    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))
    (**)  = ((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> 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 ((Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t))
     -> Dim m (Dim n (Matrix t)))
    -> ((Matrix t -> Matrix t -> Matrix t)
        -> Dim n (Matrix t) -> Dim n (Matrix t) -> Dim n (Matrix t))
    -> (Matrix t -> Matrix t -> Matrix t)
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    -> Dim m (Dim n (Matrix t))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Matrix t -> Matrix t -> Matrix t)
    -> Dim n (Matrix t) -> Dim n (Matrix t) -> 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) Matrix t -> Matrix t -> Matrix t
    forall a. Floating a => a -> a -> a
    (**)
        pi :: Dim m (Dim n (Matrix t))
    pi    = Dim n (Matrix t) -> Dim m (Dim n (Matrix t))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix t -> Dim n (Matrix t)
    forall (n :: Nat) t. t -> Dim n t
    Dim Matrix t
    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@(L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
    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 | L m n -> Bool
    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 (Matrix ℝ -> L m n
    forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
    mkL (L m n -> Matrix ℝ
    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@(L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
    forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
    isDiag -> Just (ℝ, Vector ℝ, (Int, Int))
    _) | L m n -> Bool
    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 (Matrix ℝ -> L m n
    forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
    mkL (L m n -> Matrix ℝ
    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 = L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
    forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    L m n -> Maybe (ℝ, Vector ℝ, (Int, Int))
    isDiag L m n
    m Maybe (ℝ, Vector ℝ, (Int, Int))
    -> Maybe (ℝ, Vector ℝ, (Int, Int)) -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe (ℝ, Vector ℝ, (Int, Int))
    forall a. Maybe a
    Nothing Bool -> Bool -> Bool
    && Bool -> Bool
    not (Matrix ℝ -> Bool
    forall {t}. Matrix t -> Bool
    singleM (L m n -> Matrix ℝ
    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) = Dim m (Dim n (Matrix ℝ)) -> L m n
    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) = Dim m (Dim n (Matrix ℝ)) -> L m n
    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 = (L m n -> L m n -> L m n) -> L m n -> L m n -> L m n
    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 ((Dim m (Dim n (Matrix ℝ))
     -> Dim m (Dim n (Matrix ℝ)) -> Dim m (Dim n (Matrix ℝ)))
    -> L m n -> L m n -> L m n
    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
    (+) = (Dim n (Dim m (Matrix ℝ))
     -> Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> 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 Dim n (Dim m (Matrix ℝ))
    -> Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Num a => a -> a -> a
    (+)
        * :: L n m -> L n m -> L n m
    (*) = (Dim n (Dim m (Matrix ℝ))
     -> Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> 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 Dim n (Dim m (Matrix ℝ))
    -> Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Num a => a -> a -> a
    (*)
        (-) = (Dim n (Dim m (Matrix ℝ))
     -> Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> 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 (-)
        abs :: L n m -> L n m
    abs = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Num a => a -> a
    abs
        signum :: L n m -> L n m
    signum = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Num a => a -> a
    signum
        negate :: L n m -> L n m
    negate = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Num a => a -> a
    negate
        fromInteger :: Integer -> L n m
    fromInteger = Dim n (Dim m (Matrix ℝ)) -> L n m
    forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
    L (Dim n (Dim m (Matrix ℝ)) -> L n m)
    -> (Integer -> Dim n (Dim m (Matrix ℝ))) -> Integer -> L n m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Dim m (Matrix ℝ) -> Dim n (Dim m (Matrix ℝ))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Dim m (Matrix ℝ) -> Dim n (Dim m (Matrix ℝ)))
    -> (Integer -> Dim m (Matrix ℝ))
    -> Integer
    -> Dim n (Dim m (Matrix ℝ))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Matrix ℝ -> Dim m (Matrix ℝ)
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix ℝ -> Dim m (Matrix ℝ))
    -> (Integer -> Matrix ℝ) -> Integer -> Dim m (Matrix ℝ)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Matrix ℝ
    forall a. Num a => Integer -> a
    fromInteger

    instance (KnownNat n, KnownNat m) => Fractional (L n m)
      where
        fromRational :: Rational -> L n m
    fromRational = Dim n (Dim m (Matrix ℝ)) -> L n m
    forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℝ)) -> L m n
    L (Dim n (Dim m (Matrix ℝ)) -> L n m)
    -> (Rational -> Dim n (Dim m (Matrix ℝ))) -> Rational -> L n m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Dim m (Matrix ℝ) -> Dim n (Dim m (Matrix ℝ))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Dim m (Matrix ℝ) -> Dim n (Dim m (Matrix ℝ)))
    -> (Rational -> Dim m (Matrix ℝ))
    -> Rational
    -> Dim n (Dim m (Matrix ℝ))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Matrix ℝ -> Dim m (Matrix ℝ)
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix ℝ -> Dim m (Matrix ℝ))
    -> (Rational -> Matrix ℝ) -> Rational -> Dim m (Matrix ℝ)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Matrix ℝ
    forall a. Fractional a => Rational -> a
    fromRational
        / :: L n m -> L n m -> L n m
    (/) = (Dim n (Dim m (Matrix ℝ))
     -> Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> 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 Dim n (Dim m (Matrix ℝ))
    -> Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    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   = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    sin
        cos :: L n m -> L n m
    cos   = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    cos
        tan :: L n m -> L n m
    tan   = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    tan
        asin :: L n m -> L n m
    asin  = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    asin
        acos :: L n m -> L n m
    acos  = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    acos
        atan :: L n m -> L n m
    atan  = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    atan
        sinh :: L n m -> L n m
    sinh  = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    sinh
        cosh :: L n m -> L n m
    cosh  = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    cosh
        tanh :: L n m -> L n m
    tanh  = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    tanh
        asinh :: L n m -> L n m
    asinh = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    asinh
        acosh :: L n m -> L n m
    acosh = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    acosh
        atanh :: L n m -> L n m
    atanh = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    atanh
        exp :: L n m -> L n m
    exp   = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    exp
        log :: L n m -> L n m
    log   = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    log
        sqrt :: L n m -> L n m
    sqrt  = (Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> L n m -> L n m
    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 Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a
    sqrt
        ** :: L n m -> L n m -> L n m
    (**)  = (Dim n (Dim m (Matrix ℝ))
     -> Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ)))
    -> 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 Dim n (Dim m (Matrix ℝ))
    -> Dim n (Dim m (Matrix ℝ)) -> Dim n (Dim m (Matrix ℝ))
    forall a. Floating a => a -> a -> a
    (**)
        pi :: L n m
    pi    = ℝ -> L n m
    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@(M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    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 | M m n -> Bool
    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 (Matrix ℂ -> M m n
    forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
    mkM (M m n -> Matrix ℂ
    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@(M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    isDiagC -> Just (ℂ, Vector ℂ, (Int, Int))
    _) | M m n -> Bool
    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 (Matrix ℂ -> M m n
    forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
    mkM (M m n -> Matrix ℂ
    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 = M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    forall (m :: Nat) (n :: Nat).
    (KnownNat m, KnownNat n) =>
    M m n -> Maybe (ℂ, Vector ℂ, (Int, Int))
    isDiagC M m n
    m Maybe (ℂ, Vector ℂ, (Int, Int))
    -> Maybe (ℂ, Vector ℂ, (Int, Int)) -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe (ℂ, Vector ℂ, (Int, Int))
    forall a. Maybe a
    Nothing Bool -> Bool -> Bool
    && Bool -> Bool
    not (Matrix ℂ -> Bool
    forall {t}. Matrix t -> Bool
    singleM (M m n -> Matrix ℂ
    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) = Dim m (Dim n (Matrix ℂ)) -> M m n
    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) = Dim m (Dim n (Matrix ℂ)) -> M m n
    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 = (M m n -> M m n -> M m n) -> M m n -> M m n -> M m n
    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 ((Dim m (Dim n (Matrix ℂ))
     -> Dim m (Dim n (Matrix ℂ)) -> Dim m (Dim n (Matrix ℂ)))
    -> M m n -> M m n -> M m n
    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
    (+) = (Dim n (Dim m (Matrix ℂ))
     -> Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> 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 Dim n (Dim m (Matrix ℂ))
    -> Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Num a => a -> a -> a
    (+)
        * :: M n m -> M n m -> M n m
    (*) = (Dim n (Dim m (Matrix ℂ))
     -> Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> 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 Dim n (Dim m (Matrix ℂ))
    -> Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Num a => a -> a -> a
    (*)
        (-) = (Dim n (Dim m (Matrix ℂ))
     -> Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> 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 (-)
        abs :: M n m -> M n m
    abs = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Num a => a -> a
    abs
        signum :: M n m -> M n m
    signum = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Num a => a -> a
    signum
        negate :: M n m -> M n m
    negate = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Num a => a -> a
    negate
        fromInteger :: Integer -> M n m
    fromInteger = Dim n (Dim m (Matrix ℂ)) -> M n m
    forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
    M (Dim n (Dim m (Matrix ℂ)) -> M n m)
    -> (Integer -> Dim n (Dim m (Matrix ℂ))) -> Integer -> M n m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Dim m (Matrix ℂ) -> Dim n (Dim m (Matrix ℂ))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Dim m (Matrix ℂ) -> Dim n (Dim m (Matrix ℂ)))
    -> (Integer -> Dim m (Matrix ℂ))
    -> Integer
    -> Dim n (Dim m (Matrix ℂ))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Matrix ℂ -> Dim m (Matrix ℂ)
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix ℂ -> Dim m (Matrix ℂ))
    -> (Integer -> Matrix ℂ) -> Integer -> Dim m (Matrix ℂ)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Matrix ℂ
    forall a. Num a => Integer -> a
    fromInteger

    instance (KnownNat n, KnownNat m) => Fractional (M n m)
      where
        fromRational :: Rational -> M n m
    fromRational = Dim n (Dim m (Matrix ℂ)) -> M n m
    forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
    M (Dim n (Dim m (Matrix ℂ)) -> M n m)
    -> (Rational -> Dim n (Dim m (Matrix ℂ))) -> Rational -> M n m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Dim m (Matrix ℂ) -> Dim n (Dim m (Matrix ℂ))
    forall (n :: Nat) t. t -> Dim n t
    Dim (Dim m (Matrix ℂ) -> Dim n (Dim m (Matrix ℂ)))
    -> (Rational -> Dim m (Matrix ℂ))
    -> Rational
    -> Dim n (Dim m (Matrix ℂ))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Matrix ℂ -> Dim m (Matrix ℂ)
    forall (n :: Nat) t. t -> Dim n t
    Dim (Matrix ℂ -> Dim m (Matrix ℂ))
    -> (Rational -> Matrix ℂ) -> Rational -> Dim m (Matrix ℂ)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Matrix ℂ
    forall a. Fractional a => Rational -> a
    fromRational
        / :: M n m -> M n m -> M n m
    (/) = (Dim n (Dim m (Matrix ℂ))
     -> Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> 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 Dim n (Dim m (Matrix ℂ))
    -> Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    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   = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    sin
        cos :: M n m -> M n m
    cos   = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    cos
        tan :: M n m -> M n m
    tan   = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    tan
        asin :: M n m -> M n m
    asin  = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    asin
        acos :: M n m -> M n m
    acos  = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    acos
        atan :: M n m -> M n m
    atan  = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    atan
        sinh :: M n m -> M n m
    sinh  = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    sinh
        cosh :: M n m -> M n m
    cosh  = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    cosh
        tanh :: M n m -> M n m
    tanh  = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    tanh
        asinh :: M n m -> M n m
    asinh = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    asinh
        acosh :: M n m -> M n m
    acosh = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    acosh
        atanh :: M n m -> M n m
    atanh = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    atanh
        exp :: M n m -> M n m
    exp   = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    exp
        log :: M n m -> M n m
    log   = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    log
        sqrt :: M n m -> M n m
    sqrt  = (Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> M n m -> M n m
    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 Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a
    sqrt
        ** :: M n m -> M n m -> M n m
    (**)  = (Dim n (Dim m (Matrix ℂ))
     -> Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ)))
    -> 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 Dim n (Dim m (Matrix ℂ))
    -> Dim n (Dim m (Matrix ℂ)) -> Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a -> a -> a
    (**)
        pi :: M n m
    pi    = Dim n (Dim m (Matrix ℂ)) -> M n m
    forall (m :: Nat) (n :: Nat). Dim m (Dim n (Matrix ℂ)) -> M m n
    M Dim n (Dim m (Matrix ℂ))
    forall a. Floating a => a
    pi

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

    instance Additive (C n) where
        add :: C n -> C n -> C n
    add = C n -> C n -> C n
    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 = L m n -> L m n -> L m n
    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 = M m n -> M m n -> M m n
    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 = L m n -> Matrix ℝ
    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
            String -> Int -> Int -> IO ()
    forall r. PrintfType r => String -> r
    printf String
    "L %d %d" (Matrix ℝ -> Int
    forall t. Matrix t -> Int
    rows Matrix ℝ
    a) (Matrix ℝ -> Int
    forall t. Matrix t -> Int
    cols Matrix ℝ
    a) IO () -> IO () -> IO ()
    forall a b. IO a -> IO b -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> String -> IO ()
    putStr ((Char -> Bool) -> ShowS
    forall a. (a -> Bool) -> [a] -> [a]
    dropWhile (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /=Char
    '\n') ShowS -> ShowS
    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 = M m n -> Matrix ℂ
    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
            String -> Int -> Int -> IO ()
    forall r. PrintfType r => String -> r
    printf String
    "M %d %d" (Matrix ℂ -> Int
    forall t. Matrix t -> Int
    rows Matrix ℂ
    a) (Matrix ℂ -> Int
    forall t. Matrix t -> Int
    cols Matrix ℂ
    a) IO () -> IO () -> IO ()
    forall a b. IO a -> IO b -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> String -> IO ()
    putStr ((Char -> Bool) -> ShowS
    forall a. (a -> Bool) -> [a] -> [a]
    dropWhile (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /=Char
    '\n') ShowS -> ShowS
    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 (Vector ℝ -> Matrix ℝ
    forall a. Storable a => Vector a -> Matrix a
    asRow (Vector ℝ -> Matrix ℝ) -> Vector ℝ -> Matrix ℝ
    forall a b. (a -> b) -> a -> b
    $ R n -> Vector ℝ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    extract R n
    v)
            String -> IO ()
    putStr String
    "R " IO () -> IO () -> IO ()
    forall a b. IO a -> IO b -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> String -> IO ()
    putStr (ShowS
    forall a. HasCallStack => [a] -> [a]
    tail ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Char -> Bool) -> ShowS
    forall a. (a -> Bool) -> [a] -> [a]
    dropWhile (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /=Char
    'x') ShowS -> ShowS
    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 (Vector ℂ -> Matrix ℂ
    forall a. Storable a => Vector a -> Matrix a
    asRow (Vector ℂ -> Matrix ℂ) -> Vector ℂ -> Matrix ℂ
    forall a b. (a -> b) -> a -> b
    $ C n -> Vector ℂ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    extract C n
    v)
            String -> IO ()
    putStr String
    "C " IO () -> IO () -> IO ()
    forall a b. IO a -> IO b -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> String -> IO ()
    putStr (ShowS
    forall a. HasCallStack => [a] -> [a]
    tail ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Char -> Bool) -> ShowS
    forall a. (a -> Bool) -> [a] -> [a]
    dropWhile (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /=Char
    'x') ShowS -> ShowS
    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 = Matrix ℝ -> L m n
    forall (m :: Nat) (n :: Nat). Matrix ℝ -> L m n
    mkL (Matrix ℝ -> L m n) -> (L m n -> Matrix ℝ) -> L m n -> L m n
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Matrix ℝ -> Matrix ℝ
    f (Matrix ℝ -> Matrix ℝ) -> (L m n -> Matrix ℝ) -> L m n -> Matrix ℝ
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . L m n -> Matrix ℝ
    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 = Matrix ℂ -> M m n
    forall (m :: Nat) (n :: Nat). Matrix ℂ -> M m n
    mkM (Matrix ℂ -> M m n) -> (M m n -> Matrix ℂ) -> M m n -> M m n
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Matrix ℂ -> Matrix ℂ
    f (Matrix ℂ -> Matrix ℂ) -> (M m n -> Matrix ℂ) -> M m n -> Matrix ℂ
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . M m n -> Matrix ℂ
    forall t s (d :: * -> *). Sized t s d => s -> d t
    unwrap
    {-# INLINE overMatM' #-}

    #else

    module Numeric.LinearAlgebra.Static.Internal where

    #endif