{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE FlexibleInstances #-}
module Numeric.LAPACK.Matrix.Plain.Format where

import qualified Numeric.LAPACK.Matrix.Layout.Private as Layout
import qualified Numeric.LAPACK.Matrix.Extent.Private as Extent
import qualified Numeric.LAPACK.Vector as Vector
import qualified Numeric.LAPACK.Output as Output
import qualified Numeric.LAPACK.Shape as ExtShape
import Numeric.LAPACK.Output (Output, formatRow, (<+>))
import Numeric.LAPACK.Matrix.Layout.Private
         (Order(RowMajor, ColumnMajor), UnaryProxy)
import Numeric.LAPACK.Matrix.Private (Full)
import Numeric.LAPACK.Matrix.Extent.Private (Extent)
import Numeric.LAPACK.Scalar (conjugate)
import Numeric.LAPACK.Private (caseRealComplexFunc)

import qualified Numeric.Netlib.Class as Class

import qualified Type.Data.Num.Unary.Literal as TypeNum
import qualified Type.Data.Num.Unary as Unary
import Type.Data.Num (integralFromProxy)

import qualified Data.Array.Comfort.Storable.Unchecked as Array
import qualified Data.Array.Comfort.Boxed as BoxedArray
import qualified Data.Array.Comfort.Shape as Shape
import Data.Array.Comfort.Storable (Array)
import Data.Array.Comfort.Shape ((::+))

import Text.Printf (PrintfArg, printf)

import qualified Data.List.Match as Match
import qualified Data.List.HT as ListHT
import Data.Foldable (Foldable, fold)
import Data.List (mapAccumL, transpose)
import Data.Complex (Complex((:+)))
import Data.Ix (Ix)

import Control.Applicative ((<$>))


deflt :: String
deflt :: String
deflt = String
"%.4g"


data Config =
   Config {
      Config -> String
configFormat :: String,
      Config -> String
configEmpty :: String
   }

defltConfig :: Config
defltConfig :: Config
defltConfig =
   Config :: String -> String -> Config
Config {
      configFormat :: String
configFormat = String
deflt,
      configEmpty :: String
configEmpty = String
""
   }


class (Shape.C sh) => FormatArray sh where
   {-
   We use constraint @(Class.Floating a)@ and not @(Format a)@
   because it allows us to align the components of complex numbers.
   -}
   formatArray :: (Class.Floating a, Output out) => Config -> Array sh a -> out

instance (Integral i) => FormatArray (Shape.ZeroBased i) where
   formatArray :: Config -> Array (ZeroBased i) a -> out
formatArray = Config -> Array (ZeroBased i) a -> out
forall sh a out.
(C sh, Floating a, Output out) =>
Config -> Array sh a -> out
formatVector

instance (Integral i) => FormatArray (Shape.OneBased i) where
   formatArray :: Config -> Array (OneBased i) a -> out
formatArray = Config -> Array (OneBased i) a -> out
forall sh a out.
(C sh, Floating a, Output out) =>
Config -> Array sh a -> out
formatVector

instance (Ix i) => FormatArray (Shape.Range i) where
   formatArray :: Config -> Array (Range i) a -> out
formatArray = Config -> Array (Range i) a -> out
forall sh a out.
(C sh, Floating a, Output out) =>
Config -> Array sh a -> out
formatVector

instance (Integral i) => FormatArray (Shape.Shifted i) where
   formatArray :: Config -> Array (Shifted i) a -> out
formatArray = Config -> Array (Shifted i) a -> out
forall sh a out.
(C sh, Floating a, Output out) =>
Config -> Array sh a -> out
formatVector

instance (Enum enum, Bounded enum) => FormatArray (Shape.Enumeration enum) where
   formatArray :: Config -> Array (Enumeration enum) a -> out
formatArray = Config -> Array (Enumeration enum) a -> out
forall sh a out.
(C sh, Floating a, Output out) =>
Config -> Array sh a -> out
formatVector

instance (FormatArray sh) => FormatArray (Shape.Deferred sh) where
   formatArray :: Config -> Array (Deferred sh) a -> out
formatArray Config
cfg =
      Config -> Array sh a -> out
forall sh a out.
(FormatArray sh, Floating a, Output out) =>
Config -> Array sh a -> out
formatArray Config
cfg (Array sh a -> out)
-> (Array (Deferred sh) a -> Array sh a)
-> Array (Deferred sh) a
-> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Deferred sh -> sh) -> Array (Deferred sh) a -> Array sh a
forall sh0 sh1 a. (sh0 -> sh1) -> Array sh0 a -> Array sh1 a
Array.mapShape (\(Shape.Deferred sh
sh) -> sh
sh)

instance (FormatArray sh0, FormatArray sh1) => FormatArray (sh0::+sh1) where
   formatArray :: Config -> Array (sh0 ::+ sh1) a -> out
formatArray Config
cfg Array (sh0 ::+ sh1) a
v =
      Config -> Array sh0 a -> out
forall sh a out.
(FormatArray sh, Floating a, Output out) =>
Config -> Array sh a -> out
formatArray Config
cfg (Array (sh0 ::+ sh1) a -> Array sh0 a
forall sh0 sh1 a.
(C sh0, C sh1, Storable a) =>
Array (sh0 ::+ sh1) a -> Array sh0 a
Vector.takeLeft Array (sh0 ::+ sh1) a
v)
      out -> out -> out
forall out. Output out => out -> out -> out
<+>
      Config -> Array sh1 a -> out
forall sh a out.
(FormatArray sh, Floating a, Output out) =>
Config -> Array sh a -> out
formatArray Config
cfg (Array (sh0 ::+ sh1) a -> Array sh1 a
forall sh0 sh1 a.
(C sh0, C sh1, Storable a) =>
Array (sh0 ::+ sh1) a -> Array sh1 a
Vector.takeRight Array (sh0 ::+ sh1) a
v)

instance (Shape.C sh) => FormatArray (ExtShape.IntIndexed sh) where
   formatArray :: Config -> Array (IntIndexed sh) a -> out
formatArray = Config -> Array (IntIndexed sh) a -> out
forall sh a out.
(C sh, Floating a, Output out) =>
Config -> Array sh a -> out
formatVector

formatVector ::
   (Shape.C sh, Class.Floating a, Output out) => Config -> Array sh a -> out
formatVector :: Config -> Array sh a -> out
formatVector Config
cfg =
   [out] -> out
forall out. Output out => [out] -> out
formatRow ([out] -> out) -> (Array sh a -> [out]) -> Array sh a -> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> out) -> [a] -> [out]
forall a b. (a -> b) -> [a] -> [b]
map (String -> out
forall out. Output out => String -> out
Output.text (String -> out) -> (a -> String) -> a -> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array (TupleShape a) String -> String
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold (Array (TupleShape a) String -> String)
-> (a -> Array (TupleShape a) String) -> a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Config -> a -> Array (TupleShape a) String
forall a. Floating a => Config -> a -> Tuple a String
printfFloating Config
cfg) ([a] -> [out]) -> (Array sh a -> [a]) -> Array sh a -> [out]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array sh a -> [a]
forall sh a. (C sh, Storable a) => Array sh a -> [a]
Array.toList

instance
   (Extent.Measure meas, Extent.C vert, Extent.C horiz,
    Shape.C height, Shape.C width) =>
      FormatArray (Layout.Full meas vert horiz height width) where
   formatArray :: Config -> Array (Full meas vert horiz height width) a -> out
formatArray Config
cfg = (a -> Array (TupleShape a) String) -> [[a]] -> out
forall (f :: * -> *) out a.
(Functor f, Foldable f, Output out) =>
(a -> f String) -> [[a]] -> out
formatAligned (Config -> a -> Array (TupleShape a) String
forall a. Floating a => Config -> a -> Tuple a String
printfFloating Config
cfg) ([[a]] -> out)
-> (Array (Full meas vert horiz height width) a -> [[a]])
-> Array (Full meas vert horiz height width) a
-> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array (Full meas vert horiz height width) a -> [[a]]
forall meas vert horiz height width a.
(Measure meas, C vert, C horiz, C height, C width, Floating a) =>
Full meas vert horiz height width a -> [[a]]
layoutFull

layoutFull ::
   (Extent.Measure meas, Extent.C vert, Extent.C horiz,
    Shape.C height, Shape.C width, Class.Floating a) =>
   Full meas vert horiz height width a -> [[a]]
layoutFull :: Full meas vert horiz height width a -> [[a]]
layoutFull Full meas vert horiz height width a
m =
   let Layout.Full Order
order Extent meas vert horiz height width
extent = Full meas vert horiz height width a
-> Full meas vert horiz height width
forall sh a. Array sh a -> sh
Array.shape Full meas vert horiz height width a
m
   in  Order -> (height, width) -> [a] -> [[a]]
forall height width a.
(C height, C width) =>
Order -> (height, width) -> [a] -> [[a]]
splitRows Order
order (Extent meas vert horiz height width -> (height, width)
forall meas vert horiz height width.
(Measure meas, C vert, C horiz) =>
Extent meas vert horiz height width -> (height, width)
Extent.dimensions Extent meas vert horiz height width
extent) ([a] -> [[a]]) -> [a] -> [[a]]
forall a b. (a -> b) -> a -> b
$ Full meas vert horiz height width a -> [a]
forall sh a. (C sh, Storable a) => Array sh a -> [a]
Array.toList Full meas vert horiz height width a
m

instance
   (Eq lower, Extent.Measure meas, Extent.C vert, Extent.C horiz,
    Shape.C height, Shape.C width) =>
      FormatArray (Layout.Split lower meas vert horiz height width) where
   formatArray :: Config -> Array (Split lower meas vert horiz height width) a -> out
formatArray Config
cfg =
      (a -> Array (TupleShape a) String) -> [[a]] -> out
forall (f :: * -> *) out a.
(Functor f, Foldable f, Output out) =>
(a -> f String) -> [[a]] -> out
formatSeparateTriangle (Config -> a -> Array (TupleShape a) String
forall a. Floating a => Config -> a -> Tuple a String
printfFloating Config
cfg) ([[a]] -> out)
-> (Array (Split lower meas vert horiz height width) a -> [[a]])
-> Array (Split lower meas vert horiz height width) a
-> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array (Split lower meas vert horiz height width) a -> [[a]]
forall lower meas vert horiz height width a.
(Eq lower, Measure meas, C vert, C horiz, C height, C width,
 Floating a) =>
Array (Split lower meas vert horiz height width) a -> [[a]]
layoutSplit

layoutSplit ::
   (Eq lower, Extent.Measure meas, Extent.C vert, Extent.C horiz,
    Shape.C height, Shape.C width, Class.Floating a) =>
   Array (Layout.Split lower meas vert horiz height width) a -> [[a]]
layoutSplit :: Array (Split lower meas vert horiz height width) a -> [[a]]
layoutSplit Array (Split lower meas vert horiz height width) a
m =
   let Layout.Split lower
_ Order
order Extent meas vert horiz height width
extent = Array (Split lower meas vert horiz height width) a
-> Split lower meas vert horiz height width
forall sh a. Array sh a -> sh
Array.shape Array (Split lower meas vert horiz height width) a
m
   in Order -> (height, width) -> [a] -> [[a]]
forall height width a.
(C height, C width) =>
Order -> (height, width) -> [a] -> [[a]]
splitRows Order
order (Extent meas vert horiz height width -> (height, width)
forall meas vert horiz height width.
(Measure meas, C vert, C horiz) =>
Extent meas vert horiz height width -> (height, width)
Extent.dimensions Extent meas vert horiz height width
extent) ([a] -> [[a]]) -> [a] -> [[a]]
forall a b. (a -> b) -> a -> b
$ Array (Split lower meas vert horiz height width) a -> [a]
forall sh a. (C sh, Storable a) => Array sh a -> [a]
Array.toList Array (Split lower meas vert horiz height width) a
m

instance (Shape.C size) => FormatArray (Layout.Hermitian size) where
   formatArray :: Config -> Array (Hermitian size) a -> out
formatArray = (a -> a) -> Config -> Array (Hermitian size) a -> out
forall size a out mirror.
(C size, Floating a, Output out) =>
(a -> a)
-> Config -> Array (Mosaic Packed mirror Upper size) a -> out
formatMirrored a -> a
forall a. Floating a => a -> a
conjugate

instance (Shape.C size) => FormatArray (Layout.Symmetric size) where
   formatArray :: Config -> Array (Symmetric size) a -> out
formatArray = (a -> a) -> Config -> Array (Symmetric size) a -> out
forall size a out mirror.
(C size, Floating a, Output out) =>
(a -> a)
-> Config -> Array (Mosaic Packed mirror Upper size) a -> out
formatMirrored a -> a
forall a. a -> a
id

formatMirrored ::
   (Shape.C size, Class.Floating a, Output out) =>
   (a -> a) ->
   Config ->
   Array (Layout.Mosaic Layout.Packed mirror Shape.Upper size) a ->
   out
formatMirrored :: (a -> a)
-> Config -> Array (Mosaic Packed mirror Upper size) a -> out
formatMirrored a -> a
adapt Config
cfg Array (Mosaic Packed mirror Upper size) a
m =
   (a -> Array (TupleShape a) String) -> [[a]] -> out
forall (f :: * -> *) out a.
(Functor f, Foldable f, Output out) =>
(a -> f String) -> [[a]] -> out
formatSeparateTriangle (Config -> a -> Array (TupleShape a) String
forall a. Floating a => Config -> a -> Tuple a String
printfFloating Config
cfg) ([[a]] -> out) -> [[a]] -> out
forall a b. (a -> b) -> a -> b
$ (a -> a) -> Array (Mosaic Packed mirror Upper size) a -> [[a]]
forall size a mirror.
(C size, Floating a) =>
(a -> a) -> Array (Mosaic Packed mirror Upper size) a -> [[a]]
layoutMirrored a -> a
adapt Array (Mosaic Packed mirror Upper size) a
m

layoutMirrored ::
   (Shape.C size, Class.Floating a) =>
   (a -> a) ->
   Array (Layout.Mosaic Layout.Packed mirror Shape.Upper size) a ->
   [[a]]
layoutMirrored :: (a -> a) -> Array (Mosaic Packed mirror Upper size) a -> [[a]]
layoutMirrored a -> a
adapt Array (Mosaic Packed mirror Upper size) a
m =
   let Layout.Mosaic PackingSingleton Packed
Layout.Packed MirrorSingleton mirror
_mirror UpLoSingleton Upper
Layout.Upper Order
order size
size
         = Array (Mosaic Packed mirror Upper size) a
-> Mosaic Packed mirror Upper size
forall sh a. Array sh a -> sh
Array.shape Array (Mosaic Packed mirror Upper size) a
m
   in  (a -> a) -> Order -> Int -> [a] -> [[a]]
forall a. Floating a => (a -> a) -> Order -> Int -> [a] -> [[a]]
complementTriangle a -> a
adapt Order
order (size -> Int
forall sh. C sh => sh -> Int
Shape.size size
size) ([a] -> [[a]]) -> [a] -> [[a]]
forall a b. (a -> b) -> a -> b
$ Array (Mosaic Packed mirror Upper size) a -> [a]
forall sh a. (C sh, Storable a) => Array sh a -> [a]
Array.toList Array (Mosaic Packed mirror Upper size) a
m

complementTriangle ::
   (Class.Floating a) => (a -> a) -> Order -> Int -> [a] -> [[a]]
complementTriangle :: (a -> a) -> Order -> Int -> [a] -> [[a]]
complementTriangle a -> a
adapt Order
order Int
n [a]
xs =
   let mergeTriangles :: [[a]] -> [[a]] -> [[a]]
mergeTriangles [[a]]
lower [[a]]
upper =
         ([a] -> [a] -> [a]) -> [[a]] -> [[a]] -> [[a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
(++) (([a] -> [a]) -> [[a]] -> [[a]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> a) -> [a] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map a -> a
adapt ([a] -> [a]) -> ([a] -> [a]) -> [a] -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. [a] -> [a]
init) [[a]]
lower) [[a]]
upper
   in case Order
order of
         Order
RowMajor ->
            let tri :: [[a]]
tri = [Int] -> [a] -> [[a]]
forall a. [Int] -> [a] -> [[a]]
slice (Int -> [Int] -> [Int]
forall a. Int -> [a] -> [a]
take Int
n ([Int] -> [Int]) -> [Int] -> [Int]
forall a b. (a -> b) -> a -> b
$ (Int -> Int) -> Int -> [Int]
forall a. (a -> a) -> a -> [a]
iterate Int -> Int
forall a. Enum a => a -> a
pred Int
n) [a]
xs
                trans :: [[a]]
trans = [[a]] -> [[a]]
forall a. [a] -> [a]
reverse ([[a]] -> [[a]]) -> [[a]] -> [[a]]
forall a b. (a -> b) -> a -> b
$ [[a]] -> [[a]]
forall a. [[a]] -> [[a]]
transpose ([[a]] -> [[a]]) -> [[a]] -> [[a]]
forall a b. (a -> b) -> a -> b
$ ([a] -> [a]) -> [[a]] -> [[a]]
forall a b. (a -> b) -> [a] -> [b]
map [a] -> [a]
forall a. [a] -> [a]
reverse [[a]]
tri
            in  [[a]] -> [[a]] -> [[a]]
mergeTriangles [[a]]
trans [[a]]
tri
         Order
ColumnMajor ->
            let tri :: [[a]]
tri = [Int] -> [a] -> [[a]]
forall a. [Int] -> [a] -> [[a]]
slice (Int -> [Int] -> [Int]
forall a. Int -> [a] -> [a]
take Int
n [Int
1..]) [a]
xs
            in  [[a]] -> [[a]] -> [[a]]
mergeTriangles [[a]]
tri ([[a]] -> [[a]]
forall a. [[a]] -> [[a]]
transpose [[a]]
tri)


formatDiagonal ::
   (Shape.C size, Class.Floating a, Output out) =>
   Config -> Order -> size -> [a] -> out
formatDiagonal :: Config -> Order -> size -> [a] -> out
formatDiagonal Config
cfg Order
order size
size [a]
xs =
   let n0 :: Proxy (Un U0)
n0 = Proxy U0 -> Proxy (Un U0)
forall n. Proxy n -> Proxy (Un n)
Unary.unary Proxy U0
TypeNum.u0
   in (Maybe a -> Array (TupleShape a) String) -> [[Maybe a]] -> out
forall (f :: * -> *) out a.
(Functor f, Foldable f, Output out) =>
(a -> f String) -> [[a]] -> out
formatAligned (Config -> Maybe a -> Array (TupleShape a) String
forall a. Floating a => Config -> Maybe a -> Tuple a String
printfFloatingMaybe Config
cfg) ([[Maybe a]] -> out) -> [[Maybe a]] -> out
forall a b. (a -> b) -> a -> b
$
      (Proxy (Un U0), Proxy (Un U0))
-> Order -> (size, size) -> [a] -> [[Maybe a]]
forall height width sub super a.
(C height, C width, Natural sub, Natural super) =>
(UnaryProxy sub, UnaryProxy super)
-> Order -> (height, width) -> [a] -> [[Maybe a]]
padBanded (Proxy (Un U0)
n0,Proxy (Un U0)
n0) Order
order (size
size,size
size) [a]
xs


instance
   (Layout.UpLo uplo, Shape.C size) =>
      FormatArray (Layout.Triangular uplo size) where
   formatArray :: Config -> Array (Triangular uplo size) a -> out
formatArray Config
cfg = (Maybe a -> Array (TupleShape a) String) -> [[Maybe a]] -> out
forall (f :: * -> *) out a.
(Functor f, Foldable f, Output out) =>
(a -> f String) -> [[a]] -> out
formatAligned (Config -> Maybe a -> Array (TupleShape a) String
forall a. Floating a => Config -> Maybe a -> Tuple a String
printfFloatingMaybe Config
cfg) ([[Maybe a]] -> out)
-> (Array (Triangular uplo size) a -> [[Maybe a]])
-> Array (Triangular uplo size) a
-> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array (Triangular uplo size) a -> [[Maybe a]]
forall uplo size a.
(UpLo uplo, C size, Floating a) =>
Array (Triangular uplo size) a -> [[Maybe a]]
layoutTriangular

layoutTriangular ::
   (Layout.UpLo uplo, Shape.C size, Class.Floating a) =>
   Array (Layout.Triangular uplo size) a -> [[Maybe a]]
layoutTriangular :: Array (Triangular uplo size) a -> [[Maybe a]]
layoutTriangular Array (Triangular uplo size) a
m =
   let Layout.Mosaic PackingSingleton Packed
Layout.Packed MirrorSingleton NoMirror
Layout.NoMirror UpLoSingleton uplo
uplo Order
order size
size
         = Array (Triangular uplo size) a -> Triangular uplo size
forall sh a. Array sh a -> sh
Array.shape Array (Triangular uplo size) a
m
   in UpLoSingleton uplo -> Order -> Int -> [a] -> [[Maybe a]]
forall uplo a.
UpLoSingleton uplo -> Order -> Int -> [a] -> [[Maybe a]]
padTriangle UpLoSingleton uplo
uplo Order
order (size -> Int
forall sh. C sh => sh -> Int
Shape.size size
size) ([a] -> [[Maybe a]]) -> [a] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$ Array (Triangular uplo size) a -> [a]
forall sh a. (C sh, Storable a) => Array sh a -> [a]
Array.toList Array (Triangular uplo size) a
m

padTriangle ::
   Layout.UpLoSingleton uplo -> Order -> Int -> [a] -> [[Maybe a]]
padTriangle :: UpLoSingleton uplo -> Order -> Int -> [a] -> [[Maybe a]]
padTriangle UpLoSingleton uplo
uplo =
   case UpLoSingleton uplo
uplo of
      UpLoSingleton uplo
Layout.Lower -> Order -> Int -> [a] -> [[Maybe a]]
forall a. Order -> Int -> [a] -> [[Maybe a]]
padLowerTriangle
      UpLoSingleton uplo
Layout.Upper -> Order -> Int -> [a] -> [[Maybe a]]
forall a. Order -> Int -> [a] -> [[Maybe a]]
padUpperTriangle

padUpperTriangle :: Order -> Int -> [a] -> [[Maybe a]]
padUpperTriangle :: Order -> Int -> [a] -> [[Maybe a]]
padUpperTriangle Order
order Int
n [a]
xs =
   let mxs :: [Maybe a]
mxs = (a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Maybe a
forall a. a -> Maybe a
Just [a]
xs
       nothings :: [[Maybe a]]
nothings = ([Maybe a] -> [Maybe a]) -> [Maybe a] -> [[Maybe a]]
forall a. (a -> a) -> a -> [a]
iterate (Maybe a
forall a. Maybe a
NothingMaybe a -> [Maybe a] -> [Maybe a]
forall a. a -> [a] -> [a]
:) []
   in case Order
order of
         Order
RowMajor ->
            ([Maybe a] -> [Maybe a] -> [Maybe a])
-> [[Maybe a]] -> [[Maybe a]] -> [[Maybe a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith [Maybe a] -> [Maybe a] -> [Maybe a]
forall a. [a] -> [a] -> [a]
(++) [[Maybe a]]
forall a. [[Maybe a]]
nothings ([Int] -> [Maybe a] -> [[Maybe a]]
forall a. [Int] -> [a] -> [[a]]
slice (Int -> [Int] -> [Int]
forall a. Int -> [a] -> [a]
take Int
n ([Int] -> [Int]) -> [Int] -> [Int]
forall a b. (a -> b) -> a -> b
$ (Int -> Int) -> Int -> [Int]
forall a. (a -> a) -> a -> [a]
iterate Int -> Int
forall a. Enum a => a -> a
pred Int
n) [Maybe a]
mxs)
         Order
ColumnMajor ->
            [[Maybe a]] -> [[Maybe a]]
forall a. [[a]] -> [[a]]
transpose ([[Maybe a]] -> [[Maybe a]]) -> [[Maybe a]] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$
            ([Maybe a] -> [Maybe a] -> [Maybe a])
-> [[Maybe a]] -> [[Maybe a]] -> [[Maybe a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith [Maybe a] -> [Maybe a] -> [Maybe a]
forall a. [a] -> [a] -> [a]
(++)
               ([Int] -> [Maybe a] -> [[Maybe a]]
forall a. [Int] -> [a] -> [[a]]
slice (Int -> [Int] -> [Int]
forall a. Int -> [a] -> [a]
take Int
n [Int
1..]) [Maybe a]
mxs)
               ([[Maybe a]] -> [[Maybe a]]
forall a. [a] -> [a]
reverse ([[Maybe a]] -> [[Maybe a]]) -> [[Maybe a]] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$ Int -> [[Maybe a]] -> [[Maybe a]]
forall a. Int -> [a] -> [a]
take Int
n [[Maybe a]]
forall a. [[Maybe a]]
nothings)

padLowerTriangle :: Order -> Int -> [a] -> [[Maybe a]]
padLowerTriangle :: Order -> Int -> [a] -> [[Maybe a]]
padLowerTriangle Order
order Int
n [a]
xs =
   ([a] -> [Maybe a]) -> [[a]] -> [[Maybe a]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Maybe a
forall a. a -> Maybe a
Just) ([[a]] -> [[Maybe a]]) -> [[a]] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$
   case Order
order of
      Order
RowMajor -> [Int] -> [a] -> [[a]]
forall a. [Int] -> [a] -> [[a]]
slice (Int -> [Int] -> [Int]
forall a. Int -> [a] -> [a]
take Int
n [Int
1..]) [a]
xs
      Order
ColumnMajor ->
         ([a] -> [[a]] -> [[a]]) -> [[a]] -> [[a]] -> [[a]]
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(a
y:[a]
ys) [[a]]
zs -> [a
y] [a] -> [[a]] -> [[a]]
forall a. a -> [a] -> [a]
: (a -> [a] -> [a]) -> [a] -> [[a]] -> [[a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (:) [a]
ys [[a]]
zs) []
            ([Int] -> [a] -> [[a]]
forall a. [Int] -> [a] -> [[a]]
slice (Int -> [Int] -> [Int]
forall a. Int -> [a] -> [a]
take Int
n ([Int] -> [Int]) -> [Int] -> [Int]
forall a b. (a -> b) -> a -> b
$ (Int -> Int) -> Int -> [Int]
forall a. (a -> a) -> a -> [a]
iterate Int -> Int
forall a. Enum a => a -> a
pred Int
n) [a]
xs)

slice :: [Int] -> [a] -> [[a]]
slice :: [Int] -> [a] -> [[a]]
slice [Int]
ns [a]
xs =
   ([a], [[a]]) -> [[a]]
forall a b. (a, b) -> b
snd (([a], [[a]]) -> [[a]]) -> ([a], [[a]]) -> [[a]]
forall a b. (a -> b) -> a -> b
$ ([a] -> Int -> ([a], [a])) -> [a] -> [Int] -> ([a], [[a]])
forall (t :: * -> *) a b c.
Traversable t =>
(a -> b -> (a, c)) -> a -> t b -> (a, t c)
mapAccumL (\[a]
ys Int
n -> let ([a]
vs,[a]
ws) = Int -> [a] -> ([a], [a])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
n [a]
ys in ([a]
ws,[a]
vs)) [a]
xs [Int]
ns


instance
   (Unary.Natural sub, Unary.Natural super,
    Extent.Measure meas, Extent.C vert, Extent.C horiz,
    Shape.C height, Shape.C width) =>
      FormatArray (Layout.Banded sub super meas vert horiz height width) where
   formatArray :: Config
-> Array (Banded sub super meas vert horiz height width) a -> out
formatArray Config
cfg = (Maybe a -> Array (TupleShape a) String) -> [[Maybe a]] -> out
forall (f :: * -> *) out a.
(Functor f, Foldable f, Output out) =>
(a -> f String) -> [[a]] -> out
formatAligned (Config -> Maybe a -> Array (TupleShape a) String
forall a. Floating a => Config -> Maybe a -> Tuple a String
printfFloatingMaybe Config
cfg) ([[Maybe a]] -> out)
-> (Array (Banded sub super meas vert horiz height width) a
    -> [[Maybe a]])
-> Array (Banded sub super meas vert horiz height width) a
-> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array (Banded sub super meas vert horiz height width) a
-> [[Maybe a]]
forall sub super meas vert horiz height width a.
(Natural sub, Natural super, Measure meas, C vert, C horiz,
 C height, C width, Floating a) =>
Array (Banded sub super meas vert horiz height width) a
-> [[Maybe a]]
layoutBanded

layoutBanded ::
   (Unary.Natural sub, Unary.Natural super,
    Extent.Measure meas, Extent.C vert, Extent.C horiz,
    Shape.C height, Shape.C width, Class.Floating a) =>
   Array (Layout.Banded sub super meas vert horiz height width) a -> [[Maybe a]]
layoutBanded :: Array (Banded sub super meas vert horiz height width) a
-> [[Maybe a]]
layoutBanded Array (Banded sub super meas vert horiz height width) a
m =
   let Layout.Banded (UnaryProxy sub, UnaryProxy super)
offDiag Order
order Extent meas vert horiz height width
extent = Array (Banded sub super meas vert horiz height width) a
-> Banded sub super meas vert horiz height width
forall sh a. Array sh a -> sh
Array.shape Array (Banded sub super meas vert horiz height width) a
m
   in  (UnaryProxy sub, UnaryProxy super)
-> Order -> (height, width) -> [a] -> [[Maybe a]]
forall height width sub super a.
(C height, C width, Natural sub, Natural super) =>
(UnaryProxy sub, UnaryProxy super)
-> Order -> (height, width) -> [a] -> [[Maybe a]]
padBanded (UnaryProxy sub, UnaryProxy super)
offDiag Order
order (Extent meas vert horiz height width -> (height, width)
forall meas vert horiz height width.
(Measure meas, C vert, C horiz) =>
Extent meas vert horiz height width -> (height, width)
Extent.dimensions Extent meas vert horiz height width
extent) ([a] -> [[Maybe a]]) -> [a] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$ Array (Banded sub super meas vert horiz height width) a -> [a]
forall sh a. (C sh, Storable a) => Array sh a -> [a]
Array.toList Array (Banded sub super meas vert horiz height width) a
m

padBanded ::
   (Shape.C height, Shape.C width, Unary.Natural sub, Unary.Natural super) =>
   (UnaryProxy sub, UnaryProxy super) -> Order ->
   (height, width) -> [a] -> [[Maybe a]]
padBanded :: (UnaryProxy sub, UnaryProxy super)
-> Order -> (height, width) -> [a] -> [[Maybe a]]
padBanded (UnaryProxy sub
sub,UnaryProxy super
super) Order
order (height
height,width
width) [a]
xs =
   let slices :: [[a]]
slices =
         Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceVertical ((UnaryProxy sub, UnaryProxy super) -> Int
forall sub super.
(Natural sub, Natural super) =>
(UnaryProxy sub, UnaryProxy super) -> Int
Layout.bandedBreadth (UnaryProxy sub
sub,UnaryProxy super
super)) [a]
xs
       m :: Int
m = height -> Int
forall sh. C sh => sh -> Int
Shape.size height
height
       n :: Int
n = width -> Int
forall sh. C sh => sh -> Int
Shape.size width
width
   in case Order
order of
         Order
RowMajor ->
            ([Maybe a] -> [Maybe a]) -> [[Maybe a]] -> [[Maybe a]]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> [Maybe a] -> [Maybe a]
forall a. Int -> [a] -> [a]
take Int
n) ([[Maybe a]] -> [[Maybe a]]) -> [[Maybe a]] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$
            (Int -> [Maybe a] -> [Maybe a])
-> [Int] -> [[Maybe a]] -> [[Maybe a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (Maybe a -> Int -> [Maybe a] -> [Maybe a]
forall a. a -> Int -> [a] -> [a]
shiftRow Maybe a
forall a. Maybe a
Nothing)
               ((Int -> Int) -> Int -> [Int]
forall a. (a -> a) -> a -> [a]
iterate (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+) (- UnaryProxy sub -> Int
forall x y. (Integer x, Num y) => Proxy x -> y
integralFromProxy UnaryProxy sub
sub))
               (([a] -> [Maybe a]) -> [[a]] -> [[Maybe a]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Maybe a
forall a. a -> Maybe a
Just) [[a]]
slices)
         Order
ColumnMajor ->
            let ku :: Int
ku = UnaryProxy super -> Int
forall x y. (Integer x, Num y) => Proxy x -> y
integralFromProxy UnaryProxy super
super
            in Int -> [[Maybe a]] -> [[Maybe a]]
forall a. Int -> [a] -> [a]
take Int
m ([[Maybe a]] -> [[Maybe a]]) -> [[Maybe a]] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$ Int -> [[Maybe a]] -> [[Maybe a]]
forall a. Int -> [a] -> [a]
drop Int
ku ([[Maybe a]] -> [[Maybe a]]) -> [[Maybe a]] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$
               ([a] -> [[Maybe a]] -> [[Maybe a]])
-> [[Maybe a]] -> [[a]] -> [[Maybe a]]
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
                  (\[a]
col [[Maybe a]]
mat ->
                     (Maybe a -> [Maybe a] -> [Maybe a])
-> [Maybe a] -> [[Maybe a]] -> [[Maybe a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (:) ((a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Maybe a
forall a. a -> Maybe a
Just [a]
col [Maybe a] -> [Maybe a] -> [Maybe a]
forall a. [a] -> [a] -> [a]
++ Maybe a -> [Maybe a]
forall a. a -> [a]
repeat Maybe a
forall a. Maybe a
Nothing) ([][Maybe a] -> [[Maybe a]] -> [[Maybe a]]
forall a. a -> [a] -> [a]
:[[Maybe a]]
mat))
                  (Int -> [Maybe a] -> [[Maybe a]]
forall a. Int -> a -> [a]
replicate (Int
ku Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
n) [])
                  [[a]]
slices


instance
   (Unary.Natural offDiag, Shape.C size) =>
      FormatArray (Layout.BandedHermitian offDiag size) where
   formatArray :: Config -> Array (BandedHermitian offDiag size) a -> out
formatArray Config
cfg =
      (Maybe a -> Array (TupleShape a) String) -> [[Maybe a]] -> out
forall (f :: * -> *) out a.
(Functor f, Foldable f, Output out) =>
(a -> f String) -> [[a]] -> out
formatSeparateTriangle (Config -> Maybe a -> Array (TupleShape a) String
forall a. Floating a => Config -> Maybe a -> Tuple a String
printfFloatingMaybe Config
cfg) ([[Maybe a]] -> out)
-> (Array (BandedHermitian offDiag size) a -> [[Maybe a]])
-> Array (BandedHermitian offDiag size) a
-> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Array (BandedHermitian offDiag size) a -> [[Maybe a]]
forall offDiag sh a.
(Natural offDiag, C sh, Floating a) =>
Array (BandedHermitian offDiag sh) a -> [[Maybe a]]
layoutBandedHermitian

layoutBandedHermitian ::
   (Unary.Natural offDiag, Shape.C sh, Class.Floating a) =>
   Array (Layout.BandedHermitian offDiag sh) a -> [[Maybe a]]
layoutBandedHermitian :: Array (BandedHermitian offDiag sh) a -> [[Maybe a]]
layoutBandedHermitian Array (BandedHermitian offDiag sh) a
m =
   let Layout.BandedHermitian UnaryProxy offDiag
offDiag Order
order sh
size = Array (BandedHermitian offDiag sh) a -> BandedHermitian offDiag sh
forall sh a. Array sh a -> sh
Array.shape Array (BandedHermitian offDiag sh) a
m
   in UnaryProxy offDiag -> Order -> sh -> [a] -> [[Maybe a]]
forall offDiag size a.
(Natural offDiag, C size, Floating a) =>
UnaryProxy offDiag -> Order -> size -> [a] -> [[Maybe a]]
padBandedHermitian UnaryProxy offDiag
offDiag Order
order sh
size ([a] -> [[Maybe a]]) -> [a] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$ Array (BandedHermitian offDiag sh) a -> [a]
forall sh a. (C sh, Storable a) => Array sh a -> [a]
Array.toList Array (BandedHermitian offDiag sh) a
m

padBandedHermitian ::
   (Unary.Natural offDiag, Shape.C size, Class.Floating a) =>
   UnaryProxy offDiag -> Order -> size -> [a] -> [[Maybe a]]
padBandedHermitian :: UnaryProxy offDiag -> Order -> size -> [a] -> [[Maybe a]]
padBandedHermitian UnaryProxy offDiag
offDiag Order
order size
_size [a]
xs =
   let k :: Int
k = UnaryProxy offDiag -> Int
forall x y. (Integer x, Num y) => Proxy x -> y
integralFromProxy UnaryProxy offDiag
offDiag
       slices :: [[a]]
slices = Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceVertical (Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) [a]
xs
   in case Order
order of
         Order
RowMajor ->
            ([a] -> [[Maybe a]] -> [[Maybe a]])
-> [[Maybe a]] -> [[a]] -> [[Maybe a]]
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
               (\[a]
row [[Maybe a]]
square ->
                  [[Maybe a]] -> [Maybe a] -> [Maybe a]
forall b a. [b] -> [a] -> [a]
Match.take ([][Maybe a] -> [[Maybe a]] -> [[Maybe a]]
forall a. a -> [a] -> [a]
:[[Maybe a]]
square) ((a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Maybe a
forall a. a -> Maybe a
Just [a]
row)
                  [Maybe a] -> [[Maybe a]] -> [[Maybe a]]
forall a. a -> [a] -> [a]
:
                  (Maybe a -> [Maybe a] -> [Maybe a])
-> [Maybe a] -> [[Maybe a]] -> [[Maybe a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (:)
                     ([Maybe a] -> [Maybe a]
forall a. [a] -> [a]
tail ([Maybe a] -> [Maybe a]) -> [Maybe a] -> [Maybe a]
forall a b. (a -> b) -> a -> b
$ (a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
map (a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> (a -> a) -> a -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
forall a. Floating a => a -> a
conjugate) [a]
row [Maybe a] -> [Maybe a] -> [Maybe a]
forall a. [a] -> [a] -> [a]
++ Maybe a -> [Maybe a]
forall a. a -> [a]
repeat Maybe a
forall a. Maybe a
Nothing)
                     [[Maybe a]]
square)
               [] [[a]]
slices
         Order
ColumnMajor ->
            (Int -> [Maybe a] -> [Maybe a])
-> [Int] -> [[Maybe a]] -> [[Maybe a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (Maybe a -> Int -> [Maybe a] -> [Maybe a]
forall a. a -> Int -> [a] -> [a]
shiftRow Maybe a
forall a. Maybe a
Nothing) ((Int -> Int) -> Int -> [Int]
forall a. (a -> a) -> a -> [a]
iterate (Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+) (-Int
k)) ([[Maybe a]] -> [[Maybe a]]) -> [[Maybe a]] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$ ([a] -> [Maybe a]) -> [[a]] -> [[Maybe a]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Maybe a
forall a. a -> Maybe a
Just) ([[a]] -> [[Maybe a]]) -> [[a]] -> [[Maybe a]]
forall a b. (a -> b) -> a -> b
$
            ([a] -> [a] -> [a]) -> [[a]] -> [[a]] -> [[a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
(++)
               (([a] -> [a]) -> [[a]] -> [[a]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> a) -> [a] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map a -> a
forall a. Floating a => a -> a
conjugate ([a] -> [a]) -> ([a] -> [a]) -> [a] -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [a]
forall a. [a] -> [a]
init) [[a]]
slices)
               (Int -> [[a]] -> [[a]]
forall a. Int -> [a] -> [a]
drop Int
k ([[a]] -> [[a]]) -> [[a]] -> [[a]]
forall a b. (a -> b) -> a -> b
$
                ([a] -> [[a]] -> [[a]]) -> [[a]] -> [[a]] -> [[a]]
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
                  (\[a]
column [[a]]
band ->
                     ([a] -> [a] -> [a]) -> [[a]] -> [[a]] -> [[a]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
(++) ((a -> [a]) -> [a] -> [[a]]
forall a b. (a -> b) -> [a] -> [b]
map (a -> [a] -> [a]
forall a. a -> [a] -> [a]
:[]) [a]
column [[a]] -> [[a]] -> [[a]]
forall a. [a] -> [a] -> [a]
++ [a] -> [[a]]
forall a. a -> [a]
repeat []) ([][a] -> [[a]] -> [[a]]
forall a. a -> [a] -> [a]
:[[a]]
band))
                  (Int -> [a] -> [[a]]
forall a. Int -> a -> [a]
replicate Int
k [])
                  [[a]]
slices)

shiftRow :: a -> Int -> [a] -> [a]
shiftRow :: a -> Int -> [a] -> [a]
shiftRow a
pad Int
k = if Int
kInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<=Int
0 then Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
drop (-Int
k) else (Int -> a -> [a]
forall a. Int -> a -> [a]
replicate Int
k a
pad [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++)

splitRows ::
   (Shape.C height, Shape.C width) =>
   Order -> (height, width) -> [a] -> [[a]]
splitRows :: Order -> (height, width) -> [a] -> [[a]]
splitRows Order
order (height
height,width
width) =
   case Order
order of
      Order
RowMajor -> Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceVertical (width -> Int
forall sh. C sh => sh -> Int
Shape.size width
width)
      Order
ColumnMajor -> Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceHorizontal (height -> Int
forall sh. C sh => sh -> Int
Shape.size height
height)


formatAligned ::
   (Functor f, Foldable f, Output out) =>
   (a -> f String) -> [[a]] -> out
formatAligned :: (a -> f String) -> [[a]] -> out
formatAligned a -> f String
printFmt =
   [[f out]] -> out
forall (f :: * -> *) out.
(Foldable f, Output out) =>
[[f out]] -> out
Output.formatAligned ([[f out]] -> out) -> ([[a]] -> [[f out]]) -> [[a]] -> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([a] -> [f out]) -> [[a]] -> [[f out]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> f out) -> [a] -> [f out]
forall a b. (a -> b) -> [a] -> [b]
map ((String -> out) -> f String -> f out
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> out
forall out. Output out => String -> out
Output.text (f String -> f out) -> (a -> f String) -> a -> f out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f String
printFmt))

formatSeparateTriangle ::
   (Functor f, Foldable f, Output out) =>
   (a -> f String) -> [[a]] -> out
formatSeparateTriangle :: (a -> f String) -> [[a]] -> out
formatSeparateTriangle a -> f String
printFmt =
   [[f out]] -> out
forall (f :: * -> *) out.
(Foldable f, Output out) =>
[[f out]] -> out
Output.formatSeparateTriangle ([[f out]] -> out) -> ([[a]] -> [[f out]]) -> [[a]] -> out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([a] -> [f out]) -> [[a]] -> [[f out]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> f out) -> [a] -> [f out]
forall a b. (a -> b) -> [a] -> [b]
map ((String -> out) -> f String -> f out
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> out
forall out. Output out => String -> out
Output.text (f String -> f out) -> (a -> f String) -> a -> f out
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f String
printFmt))


arrayFromList2 ::
   (Extent.Measure meas, Extent.C vert, Extent.C horiz) =>
   (Shape.C height, Shape.C width) =>
   Extent meas vert horiz height width -> [[a]] ->
   BoxedArray.Array (height, width) (Output.Separator, Maybe (Output.Style, a))
arrayFromList2 :: Extent meas vert horiz height width
-> [[a]] -> Array (height, width) (Separator, Maybe (Style, a))
arrayFromList2 Extent meas vert horiz height width
extent =
   Extent meas vert horiz height width
-> [[Maybe a]]
-> Array (height, width) (Separator, Maybe (Style, a))
forall meas vert horiz height width a.
(Measure meas, C vert, C horiz, C height, C width) =>
Extent meas vert horiz height width
-> [[Maybe a]]
-> Array (height, width) (Separator, Maybe (Style, a))
incompleteArrayFromList2 Extent meas vert horiz height width
extent ([[Maybe a]]
 -> Array (height, width) (Separator, Maybe (Style, a)))
-> ([[a]] -> [[Maybe a]])
-> [[a]]
-> Array (height, width) (Separator, Maybe (Style, a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([a] -> [Maybe a]) -> [[a]] -> [[Maybe a]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Maybe a
forall a. a -> Maybe a
Just)

incompleteArrayFromList2 ::
   (Extent.Measure meas, Extent.C vert, Extent.C horiz) =>
   (Shape.C height, Shape.C width) =>
   Extent meas vert horiz height width -> [[Maybe a]] ->
   BoxedArray.Array (height, width) (Output.Separator, Maybe (Output.Style, a))
incompleteArrayFromList2 :: Extent meas vert horiz height width
-> [[Maybe a]]
-> Array (height, width) (Separator, Maybe (Style, a))
incompleteArrayFromList2 Extent meas vert horiz height width
extent =
   let (height
height, width
width) = Extent meas vert horiz height width -> (height, width)
forall meas vert horiz height width.
(Measure meas, C vert, C horiz) =>
Extent meas vert horiz height width -> (height, width)
Extent.dimensions Extent meas vert horiz height width
extent in
   let n :: Int
n = width -> Int
forall sh. C sh => sh -> Int
Shape.size width
width in
   (height, width)
-> [(Separator, Maybe (Style, a))]
-> Array (height, width) (Separator, Maybe (Style, a))
forall sh a. C sh => sh -> [a] -> Array sh a
BoxedArray.fromList (height
height, width
width) ([(Separator, Maybe (Style, a))]
 -> Array (height, width) (Separator, Maybe (Style, a)))
-> ([[Maybe a]] -> [(Separator, Maybe (Style, a))])
-> [[Maybe a]]
-> Array (height, width) (Separator, Maybe (Style, a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[(Separator, Maybe (Style, a))]]
-> [(Separator, Maybe (Style, a))]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(Separator, Maybe (Style, a))]]
 -> [(Separator, Maybe (Style, a))])
-> ([[Maybe a]] -> [[(Separator, Maybe (Style, a))]])
-> [[Maybe a]]
-> [(Separator, Maybe (Style, a))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   ([Maybe a] -> [(Separator, Maybe (Style, a))])
-> [[Maybe a]] -> [[(Separator, Maybe (Style, a))]]
forall a b. (a -> b) -> [a] -> [b]
map ((Maybe (Style, a) -> (Separator, Maybe (Style, a)))
-> [Maybe (Style, a)] -> [(Separator, Maybe (Style, a))]
forall a b. (a -> b) -> [a] -> [b]
map ((,) Separator
Output.Space) ([Maybe (Style, a)] -> [(Separator, Maybe (Style, a))])
-> ([Maybe a] -> [Maybe (Style, a)])
-> [Maybe a]
-> [(Separator, Maybe (Style, a))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
        Maybe (Style, a) -> Int -> [Maybe (Style, a)] -> [Maybe (Style, a)]
forall a. a -> Int -> [a] -> [a]
ListHT.padRight Maybe (Style, a)
forall a. Maybe a
Nothing Int
n ([Maybe (Style, a)] -> [Maybe (Style, a)])
-> ([Maybe a] -> [Maybe (Style, a)])
-> [Maybe a]
-> [Maybe (Style, a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe a -> Maybe (Style, a)) -> [Maybe a] -> [Maybe (Style, a)]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> (Style, a)) -> Maybe a -> Maybe (Style, a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((,) Style
Output.Stored)))

splitArrayFromList2 ::
   (Extent.Measure meas, Extent.C vert, Extent.C horiz) =>
   (Shape.C height, Shape.C width) =>
   Extent meas vert horiz height width -> [[a]] ->
   BoxedArray.Array (height, width) (Output.Separator, Maybe (Output.Style, a))
splitArrayFromList2 :: Extent meas vert horiz height width
-> [[a]] -> Array (height, width) (Separator, Maybe (Style, a))
splitArrayFromList2 Extent meas vert horiz height width
extent =
   Extent meas vert horiz height width
-> [[Maybe a]]
-> Array (height, width) (Separator, Maybe (Style, a))
forall meas vert horiz height width a.
(Measure meas, C vert, C horiz, C height, C width) =>
Extent meas vert horiz height width
-> [[Maybe a]]
-> Array (height, width) (Separator, Maybe (Style, a))
incompleteSplitArrayFromList2 Extent meas vert horiz height width
extent ([[Maybe a]]
 -> Array (height, width) (Separator, Maybe (Style, a)))
-> ([[a]] -> [[Maybe a]])
-> [[a]]
-> Array (height, width) (Separator, Maybe (Style, a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([a] -> [Maybe a]) -> [[a]] -> [[Maybe a]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> Maybe a) -> [a] -> [Maybe a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Maybe a
forall a. a -> Maybe a
Just)

incompleteSplitArrayFromList2 ::
   (Extent.Measure meas, Extent.C vert, Extent.C horiz) =>
   (Shape.C height, Shape.C width) =>
   Extent meas vert horiz height width -> [[Maybe a]] ->
   BoxedArray.Array (height, width) (Output.Separator, Maybe (Output.Style, a))
incompleteSplitArrayFromList2 :: Extent meas vert horiz height width
-> [[Maybe a]]
-> Array (height, width) (Separator, Maybe (Style, a))
incompleteSplitArrayFromList2 Extent meas vert horiz height width
extent =
   let (height
height, width
width) = Extent meas vert horiz height width -> (height, width)
forall meas vert horiz height width.
(Measure meas, C vert, C horiz) =>
Extent meas vert horiz height width -> (height, width)
Extent.dimensions Extent meas vert horiz height width
extent in
   let n :: Int
n = width -> Int
forall sh. C sh => sh -> Int
Shape.size width
width in
   (height, width)
-> [(Separator, Maybe (Style, a))]
-> Array (height, width) (Separator, Maybe (Style, a))
forall sh a. C sh => sh -> [a] -> Array sh a
BoxedArray.fromList (height
height, width
width) ([(Separator, Maybe (Style, a))]
 -> Array (height, width) (Separator, Maybe (Style, a)))
-> ([[Maybe a]] -> [(Separator, Maybe (Style, a))])
-> [[Maybe a]]
-> Array (height, width) (Separator, Maybe (Style, a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[(Separator, Maybe (Style, a))]]
-> [(Separator, Maybe (Style, a))]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(Separator, Maybe (Style, a))]]
 -> [(Separator, Maybe (Style, a))])
-> ([[Maybe a]] -> [[(Separator, Maybe (Style, a))]])
-> [[Maybe a]]
-> [(Separator, Maybe (Style, a))]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   ([Separator]
 -> [Style] -> [Maybe a] -> [(Separator, Maybe (Style, a))])
-> [[Maybe a]] -> [[(Separator, Maybe (Style, a))]]
forall (f :: * -> *) a b.
([Separator] -> [Style] -> f a -> f b) -> [f a] -> [f b]
Output.decorateTriangle
      (\[Separator]
seps [Style]
styles [Maybe a]
row ->
         [Separator]
-> [Maybe (Style, a)] -> [(Separator, Maybe (Style, a))]
forall a b. [a] -> [b] -> [(a, b)]
zip [Separator]
seps ([Maybe (Style, a)] -> [(Separator, Maybe (Style, a))])
-> [Maybe (Style, a)] -> [(Separator, Maybe (Style, a))]
forall a b. (a -> b) -> a -> b
$ Maybe (Style, a) -> Int -> [Maybe (Style, a)] -> [Maybe (Style, a)]
forall a. a -> Int -> [a] -> [a]
ListHT.padRight Maybe (Style, a)
forall a. Maybe a
Nothing Int
n ([Maybe (Style, a)] -> [Maybe (Style, a)])
-> [Maybe (Style, a)] -> [Maybe (Style, a)]
forall a b. (a -> b) -> a -> b
$
         (Style -> Maybe a -> Maybe (Style, a))
-> [Style] -> [Maybe a] -> [Maybe (Style, a)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\Style
s Maybe a
r -> (,) Style
s (a -> (Style, a)) -> Maybe a -> Maybe (Style, a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a
r) [Style]
styles [Maybe a]
row)

-- ToDo: could be in BoxedArray
toRows ::
   (Shape.C height, Shape.C width) =>
   BoxedArray.Array (height,width) a -> [[a]]
toRows :: Array (height, width) a -> [[a]]
toRows Array (height, width) a
arr =
   case Array (height, width) a -> [a]
forall sh a. C sh => Array sh a -> [a]
BoxedArray.toList Array (height, width) a
arr of
      [] -> Int -> [a] -> [[a]]
forall a. Int -> a -> [a]
replicate (height -> Int
forall sh. C sh => sh -> Int
Shape.size (height -> Int) -> height -> Int
forall a b. (a -> b) -> a -> b
$ (height, width) -> height
forall a b. (a, b) -> a
fst ((height, width) -> height) -> (height, width) -> height
forall a b. (a -> b) -> a -> b
$ Array (height, width) a -> (height, width)
forall sh a. Array sh a -> sh
BoxedArray.shape Array (height, width) a
arr) []
      [a]
xs -> Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceVertical (width -> Int
forall sh. C sh => sh -> Int
Shape.size (width -> Int) -> width -> Int
forall a b. (a -> b) -> a -> b
$ (height, width) -> width
forall a b. (a, b) -> b
snd ((height, width) -> width) -> (height, width) -> width
forall a b. (a -> b) -> a -> b
$ Array (height, width) a -> (height, width)
forall sh a. Array sh a -> sh
BoxedArray.shape Array (height, width) a
arr) [a]
xs

toColumns ::
   (Shape.C height, Shape.C width) =>
   BoxedArray.Array (height,width) a -> [[a]]
toColumns :: Array (height, width) a -> [[a]]
toColumns Array (height, width) a
arr =
   Int -> [a] -> [[a]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceHorizontal (width -> Int
forall sh. C sh => sh -> Int
Shape.size (width -> Int) -> width -> Int
forall a b. (a -> b) -> a -> b
$ (height, width) -> width
forall a b. (a, b) -> b
snd ((height, width) -> width) -> (height, width) -> width
forall a b. (a -> b) -> a -> b
$ Array (height, width) a -> (height, width)
forall sh a. Array sh a -> sh
BoxedArray.shape Array (height, width) a
arr) ([a] -> [[a]]) -> [a] -> [[a]]
forall a b. (a -> b) -> a -> b
$
   Array (height, width) a -> [a]
forall sh a. C sh => Array sh a -> [a]
BoxedArray.toList Array (height, width) a
arr



data TupleShape a = TupleShape

instance (Class.Floating a) => Shape.C (TupleShape a) where
   size :: TupleShape a -> Int
size TupleShape a
sh = TupleShape a -> Int -> Int -> Int
forall a (f :: * -> *) b. Floating a => f a -> b -> b -> b
caseRealComplexFunc TupleShape a
sh Int
1 Int
2

type Tuple a = BoxedArray.Array (TupleShape a)

fillTuple :: (Class.Floating a) => b -> Tuple a b
fillTuple :: b -> Tuple a b
fillTuple = TupleShape a -> b -> Tuple a b
forall sh a. C sh => sh -> a -> Array sh a
BoxedArray.replicate TupleShape a
forall a. TupleShape a
TupleShape


newtype ToTuple a = ToTuple {ToTuple a -> a -> Tuple a String
getToTuple :: a -> Tuple a String}

printfFloatingPlain :: (Class.Floating a) => String -> a -> Tuple a String
printfFloatingPlain :: String -> a -> Tuple a String
printfFloatingPlain String
fmt =
   ToTuple a -> a -> Tuple a String
forall a. ToTuple a -> a -> Tuple a String
getToTuple (ToTuple a -> a -> Tuple a String)
-> ToTuple a -> a -> Tuple a String
forall a b. (a -> b) -> a -> b
$
   ToTuple Float
-> ToTuple Double
-> ToTuple (Complex Float)
-> ToTuple (Complex Double)
-> ToTuple a
forall a (f :: * -> *).
Floating a =>
f Float
-> f Double -> f (Complex Float) -> f (Complex Double) -> f a
Class.switchFloating
      ((Float -> Tuple Float String) -> ToTuple Float
forall a. (a -> Tuple a String) -> ToTuple a
ToTuple ((Float -> Tuple Float String) -> ToTuple Float)
-> (Float -> Tuple Float String) -> ToTuple Float
forall a b. (a -> b) -> a -> b
$ String -> Tuple Float String
forall a b. Floating a => b -> Tuple a b
fillTuple (String -> Tuple Float String)
-> (Float -> String) -> Float -> Tuple Float String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Float -> String
forall r. PrintfType r => String -> r
printf String
fmt)
      ((Double -> Tuple Double String) -> ToTuple Double
forall a. (a -> Tuple a String) -> ToTuple a
ToTuple ((Double -> Tuple Double String) -> ToTuple Double)
-> (Double -> Tuple Double String) -> ToTuple Double
forall a b. (a -> b) -> a -> b
$ String -> Tuple Double String
forall a b. Floating a => b -> Tuple a b
fillTuple (String -> Tuple Double String)
-> (Double -> String) -> Double -> Tuple Double String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Double -> String
forall r. PrintfType r => String -> r
printf String
fmt)
      ((Complex Float -> Tuple (Complex Float) String)
-> ToTuple (Complex Float)
forall a. (a -> Tuple a String) -> ToTuple a
ToTuple ((Complex Float -> Tuple (Complex Float) String)
 -> ToTuple (Complex Float))
-> (Complex Float -> Tuple (Complex Float) String)
-> ToTuple (Complex Float)
forall a b. (a -> b) -> a -> b
$ String -> Complex Float -> Tuple (Complex Float) String
forall a.
(PrintfArg a, Real a) =>
String -> Complex a -> Tuple (Complex a) String
printfComplex String
fmt)
      ((Complex Double -> Tuple (Complex Double) String)
-> ToTuple (Complex Double)
forall a. (a -> Tuple a String) -> ToTuple a
ToTuple ((Complex Double -> Tuple (Complex Double) String)
 -> ToTuple (Complex Double))
-> (Complex Double -> Tuple (Complex Double) String)
-> ToTuple (Complex Double)
forall a b. (a -> b) -> a -> b
$ String -> Complex Double -> Tuple (Complex Double) String
forall a.
(PrintfArg a, Real a) =>
String -> Complex a -> Tuple (Complex a) String
printfComplex String
fmt)

printfFloating :: (Class.Floating a) => Config -> a -> Tuple a String
printfFloating :: Config -> a -> Tuple a String
printfFloating Config
cfg = String -> a -> Tuple a String
forall a. Floating a => String -> a -> Tuple a String
printfFloatingPlain (Config -> String
configFormat Config
cfg)

printfFloatingMaybe ::
   (Class.Floating a) => Config -> Maybe a -> Tuple a String
printfFloatingMaybe :: Config -> Maybe a -> Tuple a String
printfFloatingMaybe Config
cfg =
   Tuple a String
-> (a -> Tuple a String) -> Maybe a -> Tuple a String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Tuple a String
forall a b. Floating a => b -> Tuple a b
fillTuple (String -> Tuple a String) -> String -> Tuple a String
forall a b. (a -> b) -> a -> b
$ Config -> String
configEmpty Config
cfg) (Config -> a -> Tuple a String
forall a. Floating a => Config -> a -> Tuple a String
printfFloating Config
cfg)

printfComplex ::
   (PrintfArg a, Class.Real a) =>
   String -> Complex a -> Tuple (Complex a) String
printfComplex :: String -> Complex a -> Tuple (Complex a) String
printfComplex String
fmt (a
r:+a
i) =
   if a
ia -> a -> Bool
forall a. Ord a => a -> a -> Bool
<a
0 Bool -> Bool -> Bool
|| a -> Bool
forall a. RealFloat a => a -> Bool
isNegativeZero a
i
     then String -> String -> Tuple (Complex a) String
forall a b. Real a => b -> b -> Tuple (Complex a) b
complexTuple (String -> a -> String
forall r. PrintfType r => String -> r
printf (String
fmt String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"-") a
r) (String -> a -> String
forall r. PrintfType r => String -> r
printf (String
fmt String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"i") (-a
i))
     else String -> String -> Tuple (Complex a) String
forall a b. Real a => b -> b -> Tuple (Complex a) b
complexTuple (String -> a -> String
forall r. PrintfType r => String -> r
printf (String
fmt String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"+") a
r) (String -> a -> String
forall r. PrintfType r => String -> r
printf (String
fmt String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"i") a
i)

complexTuple :: (Class.Real a) => b -> b -> Tuple (Complex a) b
complexTuple :: b -> b -> Tuple (Complex a) b
complexTuple b
b0 b
b1 = TupleShape (Complex a) -> [b] -> Tuple (Complex a) b
forall sh a. C sh => sh -> [a] -> Array sh a
BoxedArray.fromList TupleShape (Complex a)
forall a. TupleShape a
TupleShape [b
b0,b
b1]