-----------------------------------------------------------------------------
-- |
-- Module      :  Internal.IO
-- Copyright   :  (c) Alberto Ruiz 2010
-- License     :  BSD3
--
-- Maintainer  :  Alberto Ruiz
-- Stability   :  provisional
--
-- Display, formatting and IO functions for numeric 'Vector' and 'Matrix'
--
-----------------------------------------------------------------------------

module Internal.IO (
    dispf, disps, dispcf, vecdisp, latexFormat, format,
    loadMatrix, loadMatrix', saveMatrix
) where

import Internal.Devel
import Internal.Vector
import Internal.Matrix
import Internal.Vectorized
import Text.Printf(printf, PrintfArg, PrintfType)
import Data.List(intersperse,transpose)
import Data.Complex


-- | Formatting tool
table :: String -> [[String]] -> String
table :: FilePath -> [[FilePath]] -> FilePath
table FilePath
sep [[FilePath]]
as = [FilePath] -> FilePath
unlines forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map [FilePath] -> FilePath
unwords' forall a b. (a -> b) -> a -> b
$ forall a. [[a]] -> [[a]]
transpose [[FilePath]]
mtp
  where
    mt :: [[FilePath]]
mt = forall a. [[a]] -> [[a]]
transpose [[FilePath]]
as
    longs :: [Int]
longs = forall a b. (a -> b) -> [a] -> [b]
map (forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall (t :: * -> *) a. Foldable t => t a -> Int
length) [[FilePath]]
mt
    mtp :: [[FilePath]]
mtp = forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\Int
a [FilePath]
b -> forall a b. (a -> b) -> [a] -> [b]
map (Int -> FilePath -> FilePath
pad Int
a) [FilePath]
b) [Int]
longs [[FilePath]]
mt
    pad :: Int -> FilePath -> FilePath
pad Int
n FilePath
str = forall a. Int -> a -> [a]
replicate (Int
n forall a. Num a => a -> a -> a
- forall (t :: * -> *) a. Foldable t => t a -> Int
length FilePath
str) Char
' ' forall a. [a] -> [a] -> [a]
++ FilePath
str
    unwords' :: [FilePath] -> FilePath
unwords' = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> [a] -> [a]
intersperse FilePath
sep



{- | Creates a string from a matrix given a separator and a function to show each entry. Using
this function the user can easily define any desired display function:

@import Text.Printf(printf)@

@disp = putStr . format \"  \" (printf \"%.2f\")@

-}
format :: (Element t) => String -> (t -> String) -> Matrix t -> String
format :: forall t.
Element t =>
FilePath -> (t -> FilePath) -> Matrix t -> FilePath
format FilePath
sep t -> FilePath
f Matrix t
m = FilePath -> [[FilePath]] -> FilePath
table FilePath
sep forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (forall a b. (a -> b) -> [a] -> [b]
map t -> FilePath
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. Element t => Matrix t -> [[t]]
toLists forall a b. (a -> b) -> a -> b
$ Matrix t
m

{- | Show a matrix with \"autoscaling\" and a given number of decimal places.

>>> putStr . disps 2 $ 120 * (3><4) [1..]
3x4  E3
 0.12  0.24  0.36  0.48
 0.60  0.72  0.84  0.96
 1.08  1.20  1.32  1.44

-}
disps :: Int -> Matrix Double -> String
disps :: Int -> Matrix Double -> FilePath
disps Int
d Matrix Double
x = forall t. Matrix t -> FilePath
sdims Matrix Double
x forall a. [a] -> [a] -> [a]
++ FilePath
"  " forall a. [a] -> [a] -> [a]
++ forall b t.
(PrintfArg b, RealFrac b, Floating b, Num t, Element b, Show t) =>
t -> Matrix b -> FilePath
formatScaled Int
d Matrix Double
x

{- | Show a matrix with a given number of decimal places.

>>> dispf 2 (1/3 + ident 3)
"3x3\n1.33  0.33  0.33\n0.33  1.33  0.33\n0.33  0.33  1.33\n"

>>> putStr . dispf 2 $ (3><4)[1,1.5..]
3x4
1.00  1.50  2.00  2.50
3.00  3.50  4.00  4.50
5.00  5.50  6.00  6.50

>>> putStr . unlines . tail . lines . dispf 2 . asRow $ linspace 10 (0,1)
0.00  0.11  0.22  0.33  0.44  0.56  0.67  0.78  0.89  1.00

-}
dispf :: Int -> Matrix Double -> String
dispf :: Int -> Matrix Double -> FilePath
dispf Int
d Matrix Double
x = forall t. Matrix t -> FilePath
sdims Matrix Double
x forall a. [a] -> [a] -> [a]
++ FilePath
"\n" forall a. [a] -> [a] -> [a]
++ forall a t.
(Show a, PrintfArg t, Element t) =>
a -> Matrix t -> FilePath
formatFixed (if Matrix Double -> Bool
isInt Matrix Double
x then Int
0 else Int
d) Matrix Double
x

sdims :: Matrix t -> [Char]
sdims :: forall t. Matrix t -> FilePath
sdims Matrix t
x = forall a. Show a => a -> FilePath
show (forall t. Matrix t -> Int
rows Matrix t
x) forall a. [a] -> [a] -> [a]
++ FilePath
"x" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> FilePath
show (forall t. Matrix t -> Int
cols Matrix t
x)

formatFixed :: (Show a, Text.Printf.PrintfArg t, Element t)
            => a -> Matrix t -> String
formatFixed :: forall a t.
(Show a, PrintfArg t, Element t) =>
a -> Matrix t -> FilePath
formatFixed a
d Matrix t
x = forall t.
Element t =>
FilePath -> (t -> FilePath) -> Matrix t -> FilePath
format FilePath
"  " (forall r. PrintfType r => FilePath -> r
printf (FilePath
"%."forall a. [a] -> [a] -> [a]
++forall a. Show a => a -> FilePath
show a
dforall a. [a] -> [a] -> [a]
++FilePath
"f")) forall a b. (a -> b) -> a -> b
$ Matrix t
x

isInt :: Matrix Double -> Bool
isInt :: Matrix Double -> Bool
isInt = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all forall a. (Show a, RealFrac a) => a -> Bool
lookslikeInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => Vector a -> [a]
toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. Element t => Matrix t -> Vector t
flatten

formatScaled :: (Text.Printf.PrintfArg b, RealFrac b, Floating b, Num t, Element b, Show t)
             => t -> Matrix b -> [Char]
formatScaled :: forall b t.
(PrintfArg b, RealFrac b, Floating b, Num t, Element b, Show t) =>
t -> Matrix b -> FilePath
formatScaled t
dec Matrix b
t = FilePath
"E"forall a. [a] -> [a] -> [a]
++forall a. Show a => a -> FilePath
show Int
oforall a. [a] -> [a] -> [a]
++FilePath
"\n" forall a. [a] -> [a] -> [a]
++ FilePath
ss
    where ss :: FilePath
ss = forall t.
Element t =>
FilePath -> (t -> FilePath) -> Matrix t -> FilePath
format FilePath
" " (forall r. PrintfType r => FilePath -> r
printf FilePath
fmtforall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a}. Fractional a => a -> a
g) Matrix b
t
          g :: a -> a
g a
x | Int
o forall a. Ord a => a -> a -> Bool
>= Int
0    = a
xforall a. Fractional a => a -> a -> a
/a
10forall a b. (Num a, Integral b) => a -> b -> a
^(Int
o::Int)
              | Bool
otherwise = a
xforall a. Num a => a -> a -> a
*a
10forall a b. (Num a, Integral b) => a -> b -> a
^(-Int
o)
          o :: Int
o | forall t. Matrix t -> Int
rows Matrix b
t forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
|| forall t. Matrix t -> Int
cols Matrix b
t forall a. Eq a => a -> a -> Bool
== Int
0 = Int
0
            | Bool
otherwise = forall a b. (RealFrac a, Integral b) => a -> b
floor forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (forall a. Floating a => a -> a -> a
logBase b
10 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => a -> a
abs) forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Vector a -> [a]
toList forall a b. (a -> b) -> a -> b
$ forall t. Element t => Matrix t -> Vector t
flatten Matrix b
t
          fmt :: FilePath
fmt = Char
'%'forall a. a -> [a] -> [a]
:forall a. Show a => a -> FilePath
show (t
decforall a. Num a => a -> a -> a
+t
3) forall a. [a] -> [a] -> [a]
++ Char
'.'forall a. a -> [a] -> [a]
:forall a. Show a => a -> FilePath
show t
dec forall a. [a] -> [a] -> [a]
++FilePath
"f"

{- | Show a vector using a function for showing matrices.

>>> putStr . vecdisp (dispf 2) $ linspace 10 (0,1)
10 |> 0.00  0.11  0.22  0.33  0.44  0.56  0.67  0.78  0.89  1.00

-}
vecdisp :: (Element t) => (Matrix t -> String) -> Vector t -> String
vecdisp :: forall t.
Element t =>
(Matrix t -> FilePath) -> Vector t -> FilePath
vecdisp Matrix t -> FilePath
f Vector t
v
    = ((forall a. Show a => a -> FilePath
show (forall t. Storable t => Vector t -> Int
dim Vector t
v) forall a. [a] -> [a] -> [a]
++ FilePath
" |> ") forall a. [a] -> [a] -> [a]
++) forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. [a] -> [a] -> [a]
++FilePath
"\n")
    forall b c a. (b -> c) -> (a -> b) -> a -> c
. [FilePath] -> FilePath
unwords forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> [FilePath]
lines forall b c a. (b -> c) -> (a -> b) -> a -> c
.  forall a. [a] -> [a]
tail forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` FilePath
" \n"))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
. Matrix t -> FilePath
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. Matrix t -> Matrix t
trans forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. Storable t => Int -> Vector t -> Matrix t
reshape Int
1
    forall a b. (a -> b) -> a -> b
$ Vector t
v

{- | Tool to display matrices with latex syntax.

>>>  latexFormat "bmatrix" (dispf 2 $ ident 2)
"\\begin{bmatrix}\n1  &  0\n\\\\\n0  &  1\n\\end{bmatrix}"

-}
latexFormat :: String -- ^ type of braces: \"matrix\", \"bmatrix\", \"pmatrix\", etc.
            -> String -- ^ Formatted matrix, with elements separated by spaces and newlines
            -> String
latexFormat :: FilePath -> FilePath -> FilePath
latexFormat FilePath
del FilePath
tab = FilePath
"\\begin{"forall a. [a] -> [a] -> [a]
++FilePath
delforall a. [a] -> [a] -> [a]
++FilePath
"}\n" forall a. [a] -> [a] -> [a]
++ FilePath -> FilePath
f FilePath
tab forall a. [a] -> [a] -> [a]
++ FilePath
"\\end{"forall a. [a] -> [a] -> [a]
++FilePath
delforall a. [a] -> [a] -> [a]
++FilePath
"}"
    where f :: FilePath -> FilePath
f = [FilePath] -> FilePath
unlines forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> [a] -> [a]
intersperse FilePath
"\\\\" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map [FilePath] -> FilePath
unwords forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (forall a. a -> [a] -> [a]
intersperse FilePath
" & " forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> [FilePath]
words) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [a]
tail forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> [FilePath]
lines

-- | Pretty print a complex number with at most n decimal digits.
showComplex :: Int -> Complex Double -> String
showComplex :: Int -> Complex Double -> FilePath
showComplex Int
d (Double
a:+Double
b)
    | forall a. Show a => a -> Bool
isZero Double
a Bool -> Bool -> Bool
&& forall a. Show a => a -> Bool
isZero Double
b = FilePath
"0"
    | forall a. Show a => a -> Bool
isZero Double
b = FilePath
sa
    | forall a. Show a => a -> Bool
isZero Double
a Bool -> Bool -> Bool
&& forall a. Show a => a -> Bool
isOne Double
b = FilePath
s2forall a. [a] -> [a] -> [a]
++FilePath
"i"
    | forall a. Show a => a -> Bool
isZero Double
a = FilePath
sbforall a. [a] -> [a] -> [a]
++FilePath
"i"
    | forall a. Show a => a -> Bool
isOne Double
b = FilePath
saforall a. [a] -> [a] -> [a]
++FilePath
s3forall a. [a] -> [a] -> [a]
++FilePath
"i"
    | Bool
otherwise = FilePath
saforall a. [a] -> [a] -> [a]
++FilePath
s1forall a. [a] -> [a] -> [a]
++FilePath
sbforall a. [a] -> [a] -> [a]
++FilePath
"i"
  where
    sa :: FilePath
sa = forall a t1 t.
(Show a, Show t1, PrintfType t, PrintfArg t1, RealFrac t1) =>
a -> t1 -> t
shcr Int
d Double
a
    sb :: FilePath
sb = forall a t1 t.
(Show a, Show t1, PrintfType t, PrintfArg t1, RealFrac t1) =>
a -> t1 -> t
shcr Int
d Double
b
    s1 :: FilePath
s1 = if Double
bforall a. Ord a => a -> a -> Bool
<Double
0 then FilePath
"" else FilePath
"+"
    s2 :: FilePath
s2 = if Double
bforall a. Ord a => a -> a -> Bool
<Double
0 then FilePath
"-" else FilePath
""
    s3 :: FilePath
s3 = if Double
bforall a. Ord a => a -> a -> Bool
<Double
0 then FilePath
"-" else FilePath
"+"

shcr :: (Show a, Show t1, Text.Printf.PrintfType t, Text.Printf.PrintfArg t1, RealFrac t1)
     => a -> t1 -> t
shcr :: forall a t1 t.
(Show a, Show t1, PrintfType t, PrintfArg t1, RealFrac t1) =>
a -> t1 -> t
shcr a
d t1
a | forall a. (Show a, RealFrac a) => a -> Bool
lookslikeInt t1
a = forall r. PrintfType r => FilePath -> r
printf FilePath
"%.0f" t1
a
         | Bool
otherwise      = forall r. PrintfType r => FilePath -> r
printf (FilePath
"%."forall a. [a] -> [a] -> [a]
++forall a. Show a => a -> FilePath
show a
dforall a. [a] -> [a] -> [a]
++FilePath
"f") t1
a

lookslikeInt :: (Show a, RealFrac a) => a -> Bool
lookslikeInt :: forall a. (Show a, RealFrac a) => a -> Bool
lookslikeInt a
x = forall a. Show a => a -> FilePath
show (forall a b. (RealFrac a, Integral b) => a -> b
round a
x :: Int) forall a. [a] -> [a] -> [a]
++FilePath
".0" forall a. Eq a => a -> a -> Bool
== FilePath
shx Bool -> Bool -> Bool
|| FilePath
"-0.0" forall a. Eq a => a -> a -> Bool
== FilePath
shx
   where shx :: FilePath
shx = forall a. Show a => a -> FilePath
show a
x

isZero :: Show a => a -> Bool
isZero :: forall a. Show a => a -> Bool
isZero a
x = forall a. Show a => a -> FilePath
show a
x forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [FilePath
"0.0",FilePath
"-0.0"]
isOne :: Show a => a -> Bool
isOne :: forall a. Show a => a -> Bool
isOne  a
x = forall a. Show a => a -> FilePath
show a
x forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [FilePath
"1.0",FilePath
"-1.0"]

-- | Pretty print a complex matrix with at most n decimal digits.
dispcf :: Int -> Matrix (Complex Double) -> String
dispcf :: Int -> Matrix (Complex Double) -> FilePath
dispcf Int
d Matrix (Complex Double)
m = forall t. Matrix t -> FilePath
sdims Matrix (Complex Double)
m forall a. [a] -> [a] -> [a]
++ FilePath
"\n" forall a. [a] -> [a] -> [a]
++ forall t.
Element t =>
FilePath -> (t -> FilePath) -> Matrix t -> FilePath
format FilePath
"  " (Int -> Complex Double -> FilePath
showComplex Int
d) Matrix (Complex Double)
m

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

apparentCols :: FilePath -> IO Int
apparentCols :: FilePath -> IO Int
apparentCols FilePath
s = forall {t :: * -> *} {a}. Foldable t => [t a] -> Int
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
dropWhile forall (t :: * -> *) a. Foldable t => t a -> Bool
null forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map FilePath -> [FilePath]
words forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> [FilePath]
lines forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> IO FilePath
readFile FilePath
s
  where
    f :: [t a] -> Int
f [] = Int
0
    f (t a
x:[t a]
_) = forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
x


-- | load a matrix from an ASCII file formatted as a 2D table.
loadMatrix :: FilePath -> IO (Matrix Double)
loadMatrix :: FilePath -> IO (Matrix Double)
loadMatrix FilePath
f = do
    Vector Double
v <- FilePath -> IO (Vector Double)
vectorScan FilePath
f
    Int
c <- FilePath -> IO Int
apparentCols FilePath
f
    if (forall t. Storable t => Vector t -> Int
dim Vector Double
v forall a. Integral a => a -> a -> a
`mod` Int
c forall a. Eq a => a -> a -> Bool
/= Int
0)
      then
        forall a. HasCallStack => FilePath -> a
error forall a b. (a -> b) -> a -> b
$ forall r. PrintfType r => FilePath -> r
printf FilePath
"loadMatrix: %d elements and %d columns in file %s"
                       (forall t. Storable t => Vector t -> Int
dim Vector Double
v) Int
c FilePath
f
      else
        forall (m :: * -> *) a. Monad m => a -> m a
return (forall t. Storable t => Int -> Vector t -> Matrix t
reshape Int
c Vector Double
v)

loadMatrix' :: FilePath -> IO (Maybe (Matrix Double))
loadMatrix' :: FilePath -> IO (Maybe (Matrix Double))
loadMatrix' FilePath
name = forall x. IO x -> IO (Maybe x)
mbCatch (FilePath -> IO (Matrix Double)
loadMatrix FilePath
name)