{-# LANGUAGE BangPatterns        #-}
{-# LANGUAGE DeriveAnyClass      #-}
{-# LANGUAGE DeriveGeneric       #-}
{-# LANGUAGE Strict              #-}
{-# LANGUAGE ViewPatterns        #-}
{-# OPTIONS_GHC -fno-warn-type-defaults #-}
{-# LANGUAGE FlexibleContexts    #-}
{-# LANGUAGE OverloadedStrings   #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Experimenter.Eval.Latex
    ( writeLatex
    , writeAndCompileLatex
    ) where

import           Control.Arrow                ((&&&))
import           Control.DeepSeq
import           Control.Lens                 hiding ((&))
import           Control.Monad                (forM, unless, void)
import           Control.Monad.IO.Class
import           Control.Monad.Logger
import           Data.List                    as L (find, foldl')
import qualified Data.Map.Strict              as M
import qualified Data.Serialize               as S
import qualified Data.Text                    as T
import           GHC.Generics
import           System.Directory
import           System.FilePath.Posix
import           System.Posix.User
import           System.Process
import           Text.LaTeX
import           Text.LaTeX.Packages.AMSMath
import           Text.LaTeX.Packages.Hyperref
import           Text.LaTeX.Packages.Inputenc
import           Text.LaTeX.Packages.TabularX

import           Experimenter.Availability
import           Experimenter.DB
import           Experimenter.DatabaseSetting
import           Experimenter.Eval.Table
import           Experimenter.Eval.Type
import           Experimenter.Eval.Util
import           Experimenter.Models
import           Experimenter.Parameter.Type
import           Experimenter.Result.Type
import           Experimenter.Setting         (ExperimentInfoParameter (..))
import           Experimenter.Util


import           Debug.Trace

writeAndCompileLatex :: DatabaseSetting -> Evals a -> IO ()
writeAndCompileLatex :: forall a. DatabaseSetting -> Evals a -> IO ()
writeAndCompileLatex DatabaseSetting
dbSetup Evals a
evals = forall a. DatabaseSetting -> Evals a -> IO ()
writeLatex DatabaseSetting
dbSetup Evals a
evals forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall a. Evals a -> IO ()
compileLatex Evals a
evals

compileLatex :: Evals a -> IO ()
compileLatex :: forall a. Evals a -> IO ()
compileLatex Evals a
evals = do
  let exps :: Experiments a
exps = Evals a
evals forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Evals a) (Experiments a)
evalsExperiments
      dir :: String
dir = forall a. Experiments a -> String
expsPath Experiments a
exps
      n :: String
n = forall a. Experiments a -> String
getExpsName Experiments a
exps
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ String
-> [String]
-> Maybe String
-> Maybe [(String, String)]
-> Maybe Handle
-> Maybe Handle
-> Maybe Handle
-> IO ProcessHandle
runProcess String
"pdflatex" [forall a. Experiments a -> String
mainFile Experiments a
exps] (forall a. a -> Maybe a
Just String
dir) forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall a. Maybe a
Nothing forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ProcessHandle -> IO ExitCode
waitForProcess
  String
pwd <- IO String
getCurrentDirectory
  String -> IO ()
putStrLn forall a b. (a -> b) -> a -> b
$ String
"n\nSuccessfully compiled your results! See file://" forall a. Semigroup a => a -> a -> a
<> String
pwd forall a. Semigroup a => a -> a -> a
<> String
"/results/" forall a. Semigroup a => a -> a -> a
<> String
n forall a. Semigroup a => a -> a -> a
<> String
"/" forall a. Semigroup a => a -> a -> a
<> forall a. Experiments a -> String
mainFilePdf Experiments a
exps


writeLatex :: DatabaseSetting -> Evals a -> IO ()
writeLatex :: forall a. DatabaseSetting -> Evals a -> IO ()
writeLatex DatabaseSetting
dbSetup Evals a
evals = do
  let exps :: Experiments a
exps = Evals a
evals forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Evals a) (Experiments a)
evalsExperiments
      dir :: String
dir = forall a. Experiments a -> String
expsPath Experiments a
exps
      file :: String
file = String
dir String -> String -> String
</> forall a. Experiments a -> String
mainFile Experiments a
exps
  forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Bool -> String -> IO ()
createDirectoryIfMissing Bool
True String
dir
  LaTeX
res <- forall a. DatabaseSetting -> SimpleDB a -> IO a
runDBSimple DatabaseSetting
dbSetup forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => LaTeXT m a -> m LaTeX
execLaTeXT (forall a.
Evals a -> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
root Evals a
evals)
  forall a. Render a => String -> a -> IO ()
renderFile String
file LaTeX
res


root :: Evals a -> LaTeXT SimpleDB ()
root :: forall a.
Evals a -> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
root Evals a
evals = do
  forall (m :: * -> *) a. MonadIO m => Evals a -> LaTeXT m ()
thePreamble Evals a
evals
  forall l. LaTeXC l => l -> l
document forall a b. (a -> b) -> a -> b
$ forall a.
Evals a -> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
theBody Evals a
evals


-- Preamble with some basic info.
thePreamble :: (MonadIO m) => Evals a -> LaTeXT m ()
thePreamble :: forall (m :: * -> *) a. MonadIO m => Evals a -> LaTeXT m ()
thePreamble Evals a
evals = do
  let n :: Text
n = Evals a
evals forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Evals a) (Experiments a)
evalsExperiments forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Lens' (Experiments a) Text
experimentsName
  forall l. LaTeXC l => [ClassOption] -> String -> l
documentclass [] String
article
  String
user <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO String
getLoginName
  forall l. LaTeXC l => l -> l
author (LaTeXT m ()
"Username: " forall a. Semigroup a => a -> a -> a
<> forall a. IsString a => String -> a
fromString String
user)
  forall l. LaTeXC l => l -> l
title forall a b. (a -> b) -> a -> b
$ LaTeXT m ()
"Evaluation for ``" forall a. Semigroup a => a -> a -> a
<> forall l. LaTeXC l => Text -> l
raw (Text -> Text
dereferLatex Text
n) forall a. Semigroup a => a -> a -> a
<> LaTeXT m ()
"''"
  forall l. LaTeXC l => [l] -> String -> l
usepackage [forall l. LaTeXC l => l
utf8] String
inputenc
  forall l. LaTeXC l => [l] -> String -> l
usepackage [] String
"fullpage"
  forall l. LaTeXC l => [l] -> String -> l
usepackage [] String
"array"
  forall l. LaTeXC l => [l] -> String -> l
usepackage [] String
amsmath
  forall l. LaTeXC l => [l] -> String -> l
usepackage [forall l. LaTeXC l => l
pdftex] String
hyperref
  forall l. LaTeXC l => [l] -> String -> l
usepackage [] String
tabularxp

-- Body with a section.
theBody :: Evals a -> LaTeXT SimpleDB ()
theBody :: forall a.
Evals a -> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
theBody Evals a
evals = do
  forall l. LaTeXC l => l
maketitle
  forall (m :: * -> *) a.
MonadLogger m =>
Experiments a -> LaTeXT m ()
experimentsInfo (Evals a
evals forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Evals a) (Experiments a)
evalsExperiments)
  forall a.
Evals a -> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
experimentsEvals Evals a
evals


experimentsInfo :: (MonadLogger m) => Experiments a -> LaTeXT m ()
experimentsInfo :: forall (m :: * -> *) a.
MonadLogger m =>
Experiments a -> LaTeXT m ()
experimentsInfo Experiments a
exps = do
  forall l. LaTeXC l => l -> l
part LaTeXT m ()
"General Information"
  forall (m :: * -> *). MonadLogger m => Table -> LaTeXT m ()
printTable forall a b. (a -> b) -> a -> b
$ Row -> [Row] -> Table
Table ([Cell] -> Row
Row [Cell
"Parameter", Cell
"Value"])
    [ [Cell] -> Row
Row [Cell
"Experiment Name: ",                           Text -> Cell
CellT (Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) Text
experimentsName)]
    , [Cell] -> Row
Row [Cell
"Start time:",                                 Text -> Cell
CellT (forall a. Show a => a -> Text
tshow forall a b. (a -> b) -> a -> b
$ Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) UTCTime
experimentsStartTime)]
    , [Cell] -> Row
Row [Cell
"End time:",                                   Text -> Cell
CellT (forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
"" forall a. Show a => a -> Text
tshow (Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) (Maybe UTCTime)
experimentsEndTime))]
    , [Cell] -> Row
Row [Cell
"Number of conducted Experiments: ",           Text -> Cell
CellT (forall a. Show a => a -> Text
tshow forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length (Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) [Experiment a]
experiments))]
    , [Cell] -> Row
Row [Cell
"Experiment Repetitions (complete restarts):", Text -> Cell
CellT (forall a. Show a => a -> Text
tshow forall a b. (a -> b) -> a -> b
$ Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) ExpsSetup
experimentsSetup forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *).
Functor f =>
(Int -> f Int) -> ExpsSetup -> f ExpsSetup
expsSetupRepetitions)]
    , [Cell] -> Row
Row [Cell
"Experiment Preparation Steps:",               Text -> Cell
CellT (forall a. Show a => a -> Text
tshow forall a b. (a -> b) -> a -> b
$ Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) ExpsSetup
experimentsSetup forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *).
Functor f =>
(Int -> f Int) -> ExpsSetup -> f ExpsSetup
expsSetupPreparationSteps)]
    , [Cell] -> Row
Row [Cell
"Experiment Evaluation Warm Up Steps:",        Text -> Cell
CellT (forall a. Show a => a -> Text
tshow forall a b. (a -> b) -> a -> b
$ Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) ExpsSetup
experimentsSetup forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *).
Functor f =>
(Int -> f Int) -> ExpsSetup -> f ExpsSetup
expsSetupEvaluationWarmUpSteps)]
    , [Cell] -> Row
Row [Cell
"Experiment Evaluation Steps:",                Text -> Cell
CellT (forall a. Show a => a -> Text
tshow forall a b. (a -> b) -> a -> b
$ Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) ExpsSetup
experimentsSetup forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *).
Functor f =>
(Int -> f Int) -> ExpsSetup -> f ExpsSetup
expsSetupEvaluationSteps)]
    , [Cell] -> Row
Row [Cell
"Experiment Evaluation Replications:",         Text -> Cell
CellT (forall a. Show a => a -> Text
tshow forall a b. (a -> b) -> a -> b
$ Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) ExpsSetup
experimentsSetup forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *).
Functor f =>
(Int -> f Int) -> ExpsSetup -> f ExpsSetup
expsSetupEvaluationReplications)]
    ]

  let infoParams :: [ExperimentInfoParameter]
infoParams = forall a. String -> a -> a
trace( String
"Info Params: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) [ExperimentInfoParameter]
experimentsInfoParameters)) forall a b. (a -> b) -> a -> b
$ Experiments a
exps forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiments a) [ExperimentInfoParameter]
experimentsInfoParameters


  forall l. LaTeXC l => l -> l
part LaTeXT m ()
"Experiment Information Parameters"
  if forall (t :: * -> *) a. Foldable t => t a -> Bool
null [ExperimentInfoParameter]
infoParams
    then forall l. LaTeXC l => l -> l
center forall a b. (a -> b) -> a -> b
$ forall l. LaTeXC l => l -> l
text LaTeXT m ()
"No Information Parameters were defined in the experiment setup"
    else forall (m :: * -> *). MonadLogger m => Table -> LaTeXT m ()
printTextwidthTable forall a b. (a -> b) -> a -> b
$ Row -> [Row] -> Table
Table ([Cell] -> Row
Row [Cell
"Parameter", Cell
"Value"]) (forall a b. (a -> b) -> [a] -> [b]
map ExperimentInfoParameter -> Row
mkInfoParam [ExperimentInfoParameter]
infoParams)

  where mkInfoParam :: ExperimentInfoParameter -> Row
mkInfoParam (ExperimentInfoParameter Text
n b
v) = [Cell] -> Row
Row [Text -> Cell
CellT Text
n, Text -> Cell
CellT (forall a. Show a => a -> Text
tshow b
v)]


experimentsEvals :: Evals a -> LaTeXT SimpleDB ()
experimentsEvals :: forall a.
Evals a -> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
experimentsEvals Evals a
evals = do
  forall l. LaTeXC l => Maybe l -> l
pagebreak (forall (f :: * -> *) a. Applicative f => a -> f a
pure LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
"4")
  forall l. LaTeXC l => l -> l
part LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
"Experiment Evaluations"
  !(forall a. NFData a => a -> a
force -> [EvalTables a]
tablesP) <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$! forall a. Unit -> Evals a -> SimpleDB [EvalTables a]
mkResultTablesFor Unit
UnitPeriods Evals a
evals
  !(forall a. NFData a => a -> a
force -> [EvalTables a]
tablesR) <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$! forall a. Unit -> Evals a -> SimpleDB [EvalTables a]
mkResultTablesFor Unit
UnitReplications Evals a
evals
  !(forall a. NFData a => a -> a
force -> [EvalTables a]
tablesE) <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$! forall a. Unit -> Evals a -> SimpleDB [EvalTables a]
mkResultTablesFor Unit
UnitExperimentRepetition Evals a
evals
  !(forall a. NFData a => a -> a
force -> [EvalTables a]
tablesS) <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$! forall a. Unit -> Evals a -> SimpleDB [EvalTables a]
mkResultTablesFor Unit
UnitScalar Evals a
evals
  let tables :: [EvalTables a]
tables = [EvalTables a]
tablesP forall a. Semigroup a => a -> a -> a
<> [EvalTables a]
tablesR forall a. Semigroup a => a -> a -> a
<> [EvalTables a]
tablesE forall a. Semigroup a => a -> a -> a
<> [EvalTables a]
tablesS
      mParams :: Map Int (Maybe Table)
mParams = forall k a. Ord k => [(k, a)] -> Map k a
M.fromList forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view forall a. Lens' (ExperimentEval a) Int
evalExperimentNumber forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& forall a. Evals a -> ExperimentEval a -> Maybe Table
paramSettingTable Evals a
evals) (Evals a
evals forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Evals a) [ExperimentEval a]
evalsResults)
  forall a.
Map Int (Maybe Table)
-> [EvalTables a]
-> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
writeTables Map Int (Maybe Table)
mParams (forall a. NFData a => a -> a
force [EvalTables a]
tables)


data EvalTables a = EvalTables
  { forall a. EvalTables a -> [(Int, [(StatsDef a, Table)])]
periodic               :: ![(Int, [(StatsDef a, Table)])]
  , forall a. EvalTables a -> [(Int, [(StatsDef a, Table)])]
replications           :: ![(Int, [(StatsDef a, Table)])]
  , forall a. EvalTables a -> [(Int, [(StatsDef a, Table)])]
experimentReplications :: ![(Int, [(StatsDef a, Table)])]
  , forall a. EvalTables a -> [(Int, [(StatsDef a, Table)])]
numbers                :: ![(Int, [(StatsDef a, Table)])]
  } deriving (Int -> EvalTables a -> String -> String
forall a. Int -> EvalTables a -> String -> String
forall a. [EvalTables a] -> String -> String
forall a. EvalTables a -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [EvalTables a] -> String -> String
$cshowList :: forall a. [EvalTables a] -> String -> String
show :: EvalTables a -> String
$cshow :: forall a. EvalTables a -> String
showsPrec :: Int -> EvalTables a -> String -> String
$cshowsPrec :: forall a. Int -> EvalTables a -> String -> String
Show, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (EvalTables a) x -> EvalTables a
forall a x. EvalTables a -> Rep (EvalTables a) x
$cto :: forall a x. Rep (EvalTables a) x -> EvalTables a
$cfrom :: forall a x. EvalTables a -> Rep (EvalTables a) x
Generic, forall a. EvalTables a -> ()
forall a. (a -> ()) -> NFData a
rnf :: EvalTables a -> ()
$crnf :: forall a. EvalTables a -> ()
NFData)

instance Semigroup (EvalTables a) where
  EvalTables [(Int, [(StatsDef a, Table)])]
ap [(Int, [(StatsDef a, Table)])]
ar [(Int, [(StatsDef a, Table)])]
ae [(Int, [(StatsDef a, Table)])]
an <> :: EvalTables a -> EvalTables a -> EvalTables a
<> EvalTables [(Int, [(StatsDef a, Table)])]
bp [(Int, [(StatsDef a, Table)])]
br [(Int, [(StatsDef a, Table)])]
be [(Int, [(StatsDef a, Table)])]
bn = forall a.
[(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> EvalTables a
EvalTables ([(Int, [(StatsDef a, Table)])]
ap forall a. Semigroup a => a -> a -> a
<> [(Int, [(StatsDef a, Table)])]
bp) ([(Int, [(StatsDef a, Table)])]
ar forall a. Semigroup a => a -> a -> a
<> [(Int, [(StatsDef a, Table)])]
br) ([(Int, [(StatsDef a, Table)])]
ae forall a. Semigroup a => a -> a -> a
<> [(Int, [(StatsDef a, Table)])]
be) ([(Int, [(StatsDef a, Table)])]
an forall a. Semigroup a => a -> a -> a
<> [(Int, [(StatsDef a, Table)])]
bn)

instance Monoid (EvalTables a) where
  mempty :: EvalTables a
mempty = forall a.
[(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> EvalTables a
EvalTables [] [] [] []


mkResultTablesFor :: Unit -> Evals a -> SimpleDB [EvalTables a]
mkResultTablesFor :: forall a. Unit -> Evals a -> SimpleDB [EvalTables a]
mkResultTablesFor Unit
unit Evals a
evals =
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. NFData a => a -> a
force forall a b. (a -> b) -> a -> b
$!
  forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM (Evals a
evals forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Evals a) [ExperimentEval a]
evalsResults) forall a b. (a -> b) -> a -> b
$ \eval :: ExperimentEval a
eval@(ExperimentEval Int
_ [Availability IO (EvalResults a)]
avRes Experiment a
_) ->
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. NFData a => a -> a
force forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Monoid a => [a] -> a
mconcat) forall a b. (a -> b) -> a -> b
$!
    forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Availability IO (EvalResults a)]
avRes forall a b. (a -> b) -> a -> b
$ \Availability IO (EvalResults a)
av -> do
      EvalResults a
res <- forall (m :: * -> *) b. Monad m => Availability m b -> DB m b
mkTransientlyAvailable Availability IO (EvalResults a)
av
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
        let ~(Int, [(StatsDef a, Table)])
tbl = forall a.
Evals a
-> (Unit, ExperimentEval a, [EvalResults a])
-> (Int, [(StatsDef a, Table)])
mkExperimentTable Evals a
evals (forall a. EvalResults a -> Unit
leastUnit EvalResults a
res, ExperimentEval a
eval, [EvalResults a
res])
         in case forall a. EvalResults a -> Unit
leastUnit EvalResults a
res of
              Unit
UnitPeriods              -> forall a.
[(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> EvalTables a
EvalTables [(Int, [(StatsDef a, Table)])
tbl | Unit
unit forall a. Eq a => a -> a -> Bool
== Unit
UnitPeriods] [] [] []
              Unit
UnitReplications         -> forall a.
[(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> EvalTables a
EvalTables [] [(Int, [(StatsDef a, Table)])
tbl | Unit
unit forall a. Eq a => a -> a -> Bool
== Unit
UnitReplications] [] []
              Unit
UnitExperimentRepetition -> forall a.
[(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> EvalTables a
EvalTables [] [] [(Int, [(StatsDef a, Table)])
tbl | Unit
unit forall a. Eq a => a -> a -> Bool
== Unit
UnitExperimentRepetition] []
              Unit
UnitScalar               -> forall a.
[(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> EvalTables a
EvalTables [] [] [] [(Int, [(StatsDef a, Table)])
tbl | Unit
unit forall a. Eq a => a -> a -> Bool
== Unit
UnitScalar]


writeTables :: M.Map Int (Maybe Table) -> [EvalTables a] -> LaTeXT SimpleDB ()
writeTables :: forall a.
Map Int (Maybe Table)
-> [EvalTables a]
-> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
writeTables Map Int (Maybe Table)
params !(forall a. NFData a => a -> a
force -> [EvalTables a]
tables) = do
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a.
LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
-> [(Int, [(StatsDef a, Table)])]
-> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) [()]
writeTableFor LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
"Scalar Value" (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a. EvalTables a -> [(Int, [(StatsDef a, Table)])]
numbers [EvalTables a]
tables)
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a.
LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
-> [(Int, [(StatsDef a, Table)])]
-> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) [()]
writeTableFor LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
"Repetition" (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a. EvalTables a -> [(Int, [(StatsDef a, Table)])]
experimentReplications [EvalTables a]
tables)
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a.
LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
-> [(Int, [(StatsDef a, Table)])]
-> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) [()]
writeTableFor LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
"Replications" (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a. EvalTables a -> [(Int, [(StatsDef a, Table)])]
replications [EvalTables a]
tables)
  forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall a.
LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
-> [(Int, [(StatsDef a, Table)])]
-> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) [()]
writeTableFor LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
"Periodic" (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a. EvalTables a -> [(Int, [(StatsDef a, Table)])]
periodic [EvalTables a]
tables)
  where
    writeTableFor :: LaTeXT SimpleDB () -> [(Int, [(StatsDef a, Table)])] -> LaTeXT SimpleDB [()]
    writeTableFor :: forall a.
LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
-> [(Int, [(StatsDef a, Table)])]
-> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) [()]
writeTableFor LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
name [(Int, [(StatsDef a, Table)])]
tbls = do
      forall l. LaTeXC l => l -> l
section (LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
name forall a. Semigroup a => a -> a -> a
<> LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
" Evaluations")
      forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM (forall k a. Map k a -> [k]
M.keys Map Int (Maybe Table)
params) forall a b. (a -> b) -> a -> b
$ \Int
k -> do
        let tblsFiltered :: [(Int, [(StatsDef a, Table)])]
tblsFiltered = forall a. (a -> Bool) -> [a] -> [a]
filter  (( forall a. Eq a => a -> a -> Bool
== Int
k) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) [(Int, [(StatsDef a, Table)])]
tbls
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(Int, [(StatsDef a, Table)])]
tblsFiltered) forall a b. (a -> b) -> a -> b
$ do
          forall l. LaTeXC l => l -> l
subsection forall a b. (a -> b) -> a -> b
$ LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
"Experiment No. " forall a. Semigroup a => a -> a -> a
<> forall l. LaTeXC l => Text -> l
raw (forall a. Show a => a -> Text
tshow Int
k)
          forall b a. b -> (a -> b) -> Maybe a -> b
maybe LaTeXT (ReaderT SqlBackend (LoggingT (ResourceT IO))) ()
"There are no configured parameters!" forall (m :: * -> *). MonadLogger m => Table -> LaTeXT m ()
printTextwidthTable (forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault forall a. Maybe a
Nothing Int
k Map Int (Maybe Table)
params)
          forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(Int
_, [(StatsDef a, Table)]
tbls') -> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(StatsDef a, Table)]
tbls' forall a b. (a -> b) -> a -> b
$ \(StatsDef a, Table)
statsDefTbl -> forall (m :: * -> *) a.
MonadLogger m =>
(StatsDef a, Table) -> LaTeXT m ()
printTableWithName (StatsDef a, Table)
statsDefTbl) [(Int, [(StatsDef a, Table)])]
tblsFiltered


printTableWithName :: (MonadLogger m) => (StatsDef a, Table) -> LaTeXT m ()
printTableWithName :: forall (m :: * -> *) a.
MonadLogger m =>
(StatsDef a, Table) -> LaTeXT m ()
printTableWithName (StatsDef a
nm, Table
tbl) = do
  forall l. LaTeXC l => l -> l
paragraph (forall l. LaTeXC l => Text -> l
raw forall a b. (a -> b) -> a -> b
$ Text -> Text
dereferLatex forall a b. (a -> b) -> a -> b
$ forall a. StatsDef a -> Text
prettyStatsDef StatsDef a
nm)
  forall (m :: * -> *). MonadLogger m => Table -> LaTeXT m ()
printTable Table
tbl


leastUnit :: EvalResults a -> Unit
leastUnit :: forall a. EvalResults a -> Unit
leastUnit (EvalValue StatsDef a
_ Unit
u ByteString
_ Either Int Double
_ Double
_)    = Unit
u
leastUnit (EvalReducedValue StatsDef a
_ Unit
u Double
_) = Unit
u
leastUnit (EvalVector StatsDef a
_ Unit
u [])      = Unit
u
leastUnit (EvalVector StatsDef a
_ Unit
u [EvalResults a]
vals)    = forall a. Ord a => a -> a -> a
min Unit
u (forall a. EvalResults a -> Unit
leastUnit (forall a. [a] -> a
head [EvalResults a]
vals))


unpackUntil :: Unit -> EvalResults a -> [EvalResults a]
unpackUntil :: forall a. Unit -> EvalResults a -> [EvalResults a]
unpackUntil Unit
unit EvalResults a
res | EvalResults a
res forall s a. s -> Getting a s a -> a
^. forall a. Lens' (EvalResults a) Unit
evalUnit forall a. Eq a => a -> a -> Bool
== Unit
unit = [EvalResults a
res]
                     | Bool
otherwise = case EvalResults a
res of
                         EvalVector{} -> forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (forall a. Unit -> EvalResults a -> [EvalResults a]
unpackUntil Unit
unit) (EvalResults a
res forall s a. s -> Getting a s a -> a
^. forall a. Traversal' (EvalResults a) [EvalResults a]
evalValues)
                         EvalResults a
_            -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"cannot unpack res: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show EvalResults a
res

mkNamesUntil :: Unit -> EvalResults a -> [Text]
mkNamesUntil :: forall a. Unit -> EvalResults a -> [Text]
mkNamesUntil Unit
unit EvalResults a
res
  | EvalResults a
res forall s a. s -> Getting a s a -> a
^. forall a. Lens' (EvalResults a) Unit
evalUnit forall a. Eq a => a -> a -> Bool
== Unit
unit = [forall a. Monoid a => a
mempty]
  | Bool
otherwise =
    case EvalResults a
res of
      EvalVector StatsDef a
_ Unit
u [EvalResults a]
vals ->
        case Unit
u of
          Unit
UnitPeriods -> [forall a. Monoid a => a
mempty]
          Unit
UnitReplications -> forall a b. (a -> b) -> [a] -> [b]
map (\Int
x -> Text
"Rpl " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> Text
tshow Int
x forall a. Semigroup a => a -> a -> a
<> Text
": ") [Int
1 .. forall (t :: * -> *) a. Foldable t => t a -> Int
length [EvalResults a]
vals]
          Unit
_ ->
            let sub :: [Text]
sub = forall a. [a] -> a
head forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (forall a. Unit -> EvalResults a -> [Text]
mkNamesUntil Unit
unit) [EvalResults a]
vals
            in forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\Int
x -> forall a b. (a -> b) -> [a] -> [b]
map (\Text
s -> if Text -> Text -> Bool
T.isInfixOf Text
"Rpt" Text
s then Text
s else Text
"Rpt " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> Text
tshow Int
x forall a. Semigroup a => a -> a -> a
<> Text
": " forall a. Semigroup a => a -> a -> a
<> Text
s) [Text]
sub) [Int
1 .. forall (t :: * -> *) a. Foldable t => t a -> Int
length [EvalResults a]
vals]
      EvalResults a
_ -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"cannot unpack res: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show EvalResults a
res


mkExperimentTable :: Evals a -> (Unit, ExperimentEval a, [EvalResults a]) -> (Int, [(StatsDef a, Table)])
mkExperimentTable :: forall a.
Evals a
-> (Unit, ExperimentEval a, [EvalResults a])
-> (Int, [(StatsDef a, Table)])
mkExperimentTable Evals a
_ (Unit
lowestUnit, ExperimentEval a
eval, [EvalResults a]
res) =
  let resUnit :: [([[Cell]], [EvalResults a])]
resUnit = forall a b. (a -> b) -> [a] -> [b]
map (\EvalResults a
rs -> (forall {a}. EvalResults a -> [[Cell]]
mkNames EvalResults a
rs, forall a. Unit -> EvalResults a -> [EvalResults a]
unpackUntil Unit
lowestUnit EvalResults a
rs)) [EvalResults a]
res
      tableRes :: [[TableResult]]
tableRes = forall a b. (a -> b) -> [a] -> [b]
map (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (forall a. Unit -> [Cell] -> EvalResults a -> TableResult
mkEvalResult Unit
lowestUnit))) [([[Cell]], [EvalResults a])]
resUnit
      tbls :: [Table]
tbls = forall a b. (a -> b) -> [a] -> [b]
map [TableResult] -> Table
toTables [[TableResult]]
tableRes
      mkNames :: EvalResults a -> [[Cell]]
mkNames = forall a b. (a -> b) -> [a] -> [b]
map (forall a b. (a -> b) -> [a] -> [b]
map Text -> Cell
CellT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => a -> m a
return) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Unit -> EvalResults a -> [Text]
mkNamesUntil Unit
lowestUnit
      evalStatDefs :: [StatsDef a]
evalStatDefs = forall a b. (a -> b) -> [a] -> [b]
map (forall s a. s -> Getting a s a -> a
^. forall a. Lens' (EvalResults a) (StatsDef a)
evalType) [EvalResults a]
res
   in (ExperimentEval a
eval forall s a. s -> Getting a s a -> a
^. forall a. Lens' (ExperimentEval a) Int
evalExperimentNumber, forall a b. [a] -> [b] -> [(a, b)]
zip [StatsDef a]
evalStatDefs [Table]
tbls)


data TableResult = TableResult
  { TableResult -> Row
header :: !Row
  , TableResult -> [Row]
rows   :: ![Row]
  } deriving (Int -> TableResult -> String -> String
[TableResult] -> String -> String
TableResult -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [TableResult] -> String -> String
$cshowList :: [TableResult] -> String -> String
show :: TableResult -> String
$cshow :: TableResult -> String
showsPrec :: Int -> TableResult -> String -> String
$cshowsPrec :: Int -> TableResult -> String -> String
Show)

toTables :: [TableResult] -> Table
toTables :: [TableResult] -> Table
toTables [TableResult]
xs = Row -> [Row] -> Table
Table (TableResult -> Row
header forall a b. (a -> b) -> a -> b
$ forall a. [a] -> a
head [TableResult]
xs) (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap TableResult -> [Row]
rows [TableResult]
xs)

mkEvalResult :: Unit -> [Cell] -> EvalResults a -> TableResult
mkEvalResult :: forall a. Unit -> [Cell] -> EvalResults a -> TableResult
mkEvalResult Unit
_ [Cell]
_ (EvalVector StatsDef a
_ Unit
_ []) = forall a. HasCallStack => String -> a
error String
"Empty evaluation. Check your eval setup."
mkEvalResult Unit
leastUnit' [Cell]
name (EvalVector StatsDef a
_ Unit
_ [EvalResults a]
vals) =
  Row -> [Row] -> TableResult
TableResult ([Cell] -> Row
Row forall a b. (a -> b) -> a -> b
$ Text -> Cell
CellT (forall {a}. IsString a => Unit -> a
unitName Unit
leastUnit') forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map (Text -> Cell
CellT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> Text
tshow) [Int
1 .. forall (t :: * -> *) a. Foldable t => t a -> Int
length [EvalResults a]
vals]) (forall a b. (a -> b) -> [a] -> [b]
map [Cell] -> Row
Row (forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' [[Cell]] -> [Row] -> [[Cell]]
mkRows [[Cell]
name] [[Row]]
rowVals))
  where
    subVals :: [TableResult]
subVals = forall a b. (a -> b) -> [a] -> [b]
map (forall a. Unit -> [Cell] -> EvalResults a -> TableResult
mkEvalResult Unit
leastUnit' []) [EvalResults a]
vals
    rowVals :: [[Row]]
rowVals = forall a b. (a -> b) -> [a] -> [b]
map TableResult -> [Row]
rows [TableResult]
subVals
    mkRows :: [[Cell]] -> [Row] -> [[Cell]]
    mkRows :: [[Cell]] -> [Row] -> [[Cell]]
mkRows [[Cell]]
accs [Row]
vs = forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith forall a. [a] -> [a] -> [a]
(++) [[Cell]]
accs (forall a b. (a -> b) -> [a] -> [b]
map Row -> [Cell]
fromRow [Row]
vs)
    fromRow :: Row -> [Cell]
fromRow (Row [Cell]
xs) = [Cell]
xs
    unitName :: Unit -> a
unitName Unit
UnitPeriods              = a
"Period:"
    unitName Unit
UnitReplications         = a
"Replication:"
    unitName Unit
UnitExperimentRepetition = a
"Experiment Repetition:"
    -- unitName (UnitBestExperimentRepetitions bestNr) = "Best " <> tshow bestNr <> " Experiment Repetitions:"
    unitName Unit
UnitScalar               = a
"Value:"
mkEvalResult Unit
_ [] (EvalValue StatsDef a
_ Unit
_ ByteString
_ Either Int Double
x Double
y) = Row -> [Row] -> TableResult
TableResult ([Cell] -> Row
Row [forall {a}. Show a => Either a Double -> Cell
getXValue Either Int Double
x]) [[Cell] -> Row
Row [Double -> Cell
CellD Double
y]]
  where getXValue :: Either a Double -> Cell
getXValue (Left a
v)  = Text -> Cell
CellT forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> Text
tshow a
v
        getXValue (Right Double
d) = Double -> Cell
CellD Double
d
mkEvalResult Unit
_ (Cell
n1:[Cell]
_) (EvalValue StatsDef a
_ Unit
_ ByteString
_ Either Int Double
x Double
y) = Row -> [Row] -> TableResult
TableResult ([Cell] -> Row
Row [Cell
CellEmpty, forall {a}. Show a => Either a Double -> Cell
getXValue Either Int Double
x]) [[Cell] -> Row
Row [Cell
n1, Double -> Cell
CellD Double
y]]
  where getXValue :: Either a Double -> Cell
getXValue (Left a
v)  = Text -> Cell
CellT forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> Text
tshow a
v
        getXValue (Right Double
d) = Double -> Cell
CellD Double
d
mkEvalResult Unit
_ [] (EvalReducedValue StatsDef a
statsDef Unit
_ Double
y) = Row -> [Row] -> TableResult
TableResult ([Cell] -> Row
Row [Text -> Cell
CellT forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> Text
tshow StatsDef a
statsDef]) [[Cell] -> Row
Row [Double -> Cell
CellD Double
y]]
mkEvalResult Unit
_ (Cell
n:[Cell]
_) (EvalReducedValue StatsDef a
statsDef Unit
_ Double
y) = Row -> [Row] -> TableResult
TableResult ([Cell] -> Row
Row [Cell
CellEmpty , Text -> Cell
CellT forall a b. (a -> b) -> a -> b
$ forall a. StatsDef a -> Text
prettyStatsDef StatsDef a
statsDef]) [[Cell] -> Row
Row [Cell
n, Double -> Cell
CellD Double
y]]


paramSettingTable :: Evals a -> ExperimentEval a -> Maybe Table
paramSettingTable :: forall a. Evals a -> ExperimentEval a -> Maybe Table
paramSettingTable Evals a
evals (ExperimentEval Int
_ [Availability IO (EvalResults a)]
_ Experiment a
exp)
  | forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Experiment a
exp forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiment a) [ParameterSetting a]
parameterSetup) = forall a. Maybe a
Nothing
  | Bool
otherwise = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Row -> [Row] -> Table
Table ([Cell] -> Row
Row [Cell
"Parameter", Cell
"Value"]) (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a. ParameterSetting a -> [Row]
mkRow (Experiment a
exp forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Experiment a) [ParameterSetting a]
parameterSetup))
  where
    dropRow :: Row
    dropRow :: Row
dropRow = [Cell] -> Row
Row [Text -> Cell
CellT Text
"Skip Preparation Phase", Text -> Cell
CellT Text
"True (No preparation phase was executed!)"]
    singleInstanceRow :: Text -> Row
    singleInstanceRow :: Text -> Row
singleInstanceRow Text
n = [Cell] -> Row
Row [Text -> Cell
CellT Text
"Run a single instance", Text -> Cell
CellT forall a b. (a -> b) -> a -> b
$ Text
"True (No further variations needed as specified by parameter " forall a. Semigroup a => a -> a -> a
<> Text
n forall a. Semigroup a => a -> a -> a
<> Text
"!)"]
    mkRow :: ParameterSetting a -> [Row]
    mkRow :: forall a. ParameterSetting a -> [Row]
mkRow (ParameterSetting Text
n ByteString
bsV Bool
drp ExperimentDesign
design) =
      case forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((forall a. Eq a => a -> a -> Bool
== Text
n) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ParameterSetup a -> Text
parameterName) (Evals a
evals forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Evals a) (Experiments a)
evalsExperiments forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Lens' (Experiments a) [ParameterSetup a]
experimentsParameters) of
        Maybe (ParameterSetup a)
Nothing ->
          [Cell] -> Row
Row
            [ Text -> Cell
CellT Text
n
            , Text -> Cell
CellT forall a b. (a -> b) -> a -> b
$ Text
"was not modified as it is not listed in the parameter setting" forall a. Semigroup a => a -> a -> a
<>
              (if Bool
drp
                 then Text
" [SkipPrepPhase]"
                 else Text
"") forall a. Semigroup a => a -> a -> a
<>
              (case ExperimentDesign
design of
                 ExperimentDesign
FullFactory    -> Text
""
                 ExperimentDesign
SingleInstance -> Text
"[SingleInstance]")
            ] forall a. a -> [a] -> [a]
:
          [Row
dropRow | Bool
drp] forall a. [a] -> [a] -> [a]
++
          [Text -> Row
singleInstanceRow Text
n | Bool
drp]
        Just (ParameterSetup Text
_ b -> a -> a
setter a -> b
_ Maybe (b -> IO [b])
_ Maybe (b, b)
mBounds Maybe (b -> Bool)
_ Maybe (b -> ExperimentDesign)
_) ->
          case forall a. Get a -> ByteString -> Either String a
S.runGet forall t. Serialize t => Get t
S.get ByteString
bsV of
            Left String
err -> [[Cell] -> Row
Row [Text -> Cell
CellT Text
n, Text -> Cell
CellT (String -> Text
T.pack String
err)]]
            Right b
val ->
              let a
_ = b -> a -> a
setter b
val (Evals a
evals forall s a. s -> Getting a s a -> a
^. forall a. Lens' (Evals a) (Experiments a)
evalsExperiments forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Lens' (Experiments a) a
experimentsInitialState) -- only needed for type inference
               in [Cell] -> Row
Row
                    [ Text -> Cell
CellT Text
n
                    , LaTeX -> Cell
CellL forall a b. (a -> b) -> a -> b
$ forall l. LaTeXC l => Text -> l
raw (Text -> Text
dereferLatex forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> Text
tshow b
val) forall a. Semigroup a => a -> a -> a
<>
                      (case Maybe (b, b)
mBounds of
                         Maybe (b, b)
Nothing               -> LaTeX
""
                         Just (b
minVal, b
maxVal) -> forall l. LaTeXC l => l -> l
math (forall l. LaTeXC l => l -> l
text LaTeX
" " forall l. LaTeXC l => l -> l -> l
`in_` forall l. LaTeXC l => l -> l
autoParens (forall l. LaTeXC l => l -> l
text (forall l. LaTeXC l => Text -> l
raw (Text -> Text
dereferLatex forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> Text
tshow b
minVal)) forall a. Semigroup a => a -> a -> a
<> LaTeX
", " forall a. Semigroup a => a -> a -> a
<> forall l. LaTeXC l => l -> l
text (forall l. LaTeXC l => Text -> l
raw (Text -> Text
dereferLatex forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> Text
tshow b
maxVal))))) forall a. Semigroup a => a -> a -> a
<>
                      (if Bool
drp
                         then LaTeX
" [SkipPrepPhase]"
                         else forall a. Monoid a => a
mempty) forall a. Semigroup a => a -> a -> a
<>
                      (case ExperimentDesign
design of
                         ExperimentDesign
FullFactory    -> LaTeX
""
                         ExperimentDesign
SingleInstance -> LaTeX
"[SingleInstance]")
                    ] forall a. a -> [a] -> [a]
:
                  [Row
dropRow | Bool
drp] forall a. [a] -> [a] -> [a]
++
                  [Text -> Row
singleInstanceRow Text
n | Bool
drp]