{-# 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.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.Process
import           Text.LaTeX
import           Text.LaTeX.Packages.AMSMath
import           Text.LaTeX.Packages.Hyperref
import           Text.LaTeX.Packages.Inputenc

import           Experimenter.Availability
import           Experimenter.DatabaseSetting
import           Experimenter.DB
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


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

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


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


root :: Evals a -> LaTeXT SimpleDB ()
root :: Evals a -> LaTeXT SimpleDB ()
root Evals a
evals = do
  Evals a -> LaTeXT SimpleDB ()
forall (m :: * -> *) a. MonadLogger m => Evals a -> LaTeXT m ()
thePreamble Evals a
evals
  LaTeXT SimpleDB () -> LaTeXT SimpleDB ()
forall l. LaTeXC l => l -> l
document (LaTeXT SimpleDB () -> LaTeXT SimpleDB ())
-> LaTeXT SimpleDB () -> LaTeXT SimpleDB ()
forall a b. (a -> b) -> a -> b
$ Evals a -> LaTeXT SimpleDB ()
forall a. Evals a -> LaTeXT SimpleDB ()
theBody Evals a
evals


-- Preamble with some basic info.
thePreamble :: (MonadLogger m) => Evals a -> LaTeXT m ()
thePreamble :: Evals a -> LaTeXT m ()
thePreamble Evals a
evals = do
  let n :: Text
n = Evals a
evals Evals a -> Getting Text (Evals a) Text -> Text
forall s a. s -> Getting a s a -> a
^. (Experiments a -> Const Text (Experiments a))
-> Evals a -> Const Text (Evals a)
forall a. Lens' (Evals a) (Experiments a)
evalsExperiments ((Experiments a -> Const Text (Experiments a))
 -> Evals a -> Const Text (Evals a))
-> ((Text -> Const Text Text)
    -> Experiments a -> Const Text (Experiments a))
-> Getting Text (Evals a) Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Const Text Text)
-> Experiments a -> Const Text (Experiments a)
forall a. Lens' (Experiments a) Text
experimentsName
  [ClassOption] -> FilePath -> LaTeXT m ()
forall l. LaTeXC l => [ClassOption] -> FilePath -> l
documentclass [] FilePath
article
  LaTeXT m () -> LaTeXT m ()
forall l. LaTeXC l => l -> l
author LaTeXT m ()
"Manuel Schneckenreither"
  LaTeXT m () -> LaTeXT m ()
forall l. LaTeXC l => l -> l
title (LaTeXT m () -> LaTeXT m ()) -> LaTeXT m () -> LaTeXT m ()
forall a b. (a -> b) -> a -> b
$ LaTeXT m ()
"Evaluation for ``" LaTeXT m () -> LaTeXT m () -> LaTeXT m ()
forall a. Semigroup a => a -> a -> a
<> Text -> LaTeXT m ()
forall l. LaTeXC l => Text -> l
raw Text
n LaTeXT m () -> LaTeXT m () -> LaTeXT m ()
forall a. Semigroup a => a -> a -> a
<> LaTeXT m ()
"''"
  [LaTeXT m ()] -> FilePath -> LaTeXT m ()
forall l. LaTeXC l => [l] -> FilePath -> l
usepackage [LaTeXT m ()
forall l. LaTeXC l => l
utf8] FilePath
inputenc
  [LaTeXT m ()] -> FilePath -> LaTeXT m ()
forall l. LaTeXC l => [l] -> FilePath -> l
usepackage [] FilePath
"fullpage"
  [LaTeXT m ()] -> FilePath -> LaTeXT m ()
forall l. LaTeXC l => [l] -> FilePath -> l
usepackage [] FilePath
"array"
  [LaTeXT m ()] -> FilePath -> LaTeXT m ()
forall l. LaTeXC l => [l] -> FilePath -> l
usepackage [] FilePath
amsmath
  [LaTeXT m ()] -> FilePath -> LaTeXT m ()
forall l. LaTeXC l => [l] -> FilePath -> l
usepackage [LaTeXT m ()
forall l. LaTeXC l => l
pdftex] FilePath
hyperref

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


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

  let infoParams :: [ExperimentInfoParameter]
infoParams = Experiments a
exps Experiments a
-> Getting
     [ExperimentInfoParameter] (Experiments a) [ExperimentInfoParameter]
-> [ExperimentInfoParameter]
forall s a. s -> Getting a s a -> a
^. Getting
  [ExperimentInfoParameter] (Experiments a) [ExperimentInfoParameter]
forall a. Lens' (Experiments a) [ExperimentInfoParameter]
experimentsInfoParameters
  Bool -> LaTeXT m () -> LaTeXT m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([ExperimentInfoParameter] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [ExperimentInfoParameter]
infoParams) (LaTeXT m () -> LaTeXT m ()) -> LaTeXT m () -> LaTeXT m ()
forall a b. (a -> b) -> a -> b
$ do
    LaTeXT m () -> LaTeXT m ()
forall l. LaTeXC l => l -> l
part LaTeXT m ()
"Experiment Information Parameters"
    Table -> LaTeXT m ()
forall (m :: * -> *). MonadLogger m => Table -> LaTeXT m ()
printTable (Table -> LaTeXT m ()) -> Table -> LaTeXT m ()
forall a b. (a -> b) -> a -> b
$ Row -> [Row] -> Table
Table ([Cell] -> Row
Row [Cell
"Parameter", Cell
"Value"])
      ((ExperimentInfoParameter -> Row)
-> [ExperimentInfoParameter] -> [Row]
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 (b -> Text
forall a. Show a => a -> Text
tshow b
v)]


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


data EvalTables a = EvalTables
  { EvalTables a -> [(Int, [(StatsDef a, Table)])]
periodic               :: ![(Int, [(StatsDef a, Table)])]
  , EvalTables a -> [(Int, [(StatsDef a, Table)])]
replications           :: ![(Int, [(StatsDef a, Table)])]
  , EvalTables a -> [(Int, [(StatsDef a, Table)])]
experimentReplications :: ![(Int, [(StatsDef a, Table)])]
  , EvalTables a -> [(Int, [(StatsDef a, Table)])]
numbers                :: ![(Int, [(StatsDef a, Table)])]
  } deriving (Int -> EvalTables a -> FilePath -> FilePath
[EvalTables a] -> FilePath -> FilePath
EvalTables a -> FilePath
(Int -> EvalTables a -> FilePath -> FilePath)
-> (EvalTables a -> FilePath)
-> ([EvalTables a] -> FilePath -> FilePath)
-> Show (EvalTables a)
forall a. Int -> EvalTables a -> FilePath -> FilePath
forall a. [EvalTables a] -> FilePath -> FilePath
forall a. EvalTables a -> FilePath
forall a.
(Int -> a -> FilePath -> FilePath)
-> (a -> FilePath) -> ([a] -> FilePath -> FilePath) -> Show a
showList :: [EvalTables a] -> FilePath -> FilePath
$cshowList :: forall a. [EvalTables a] -> FilePath -> FilePath
show :: EvalTables a -> FilePath
$cshow :: forall a. EvalTables a -> FilePath
showsPrec :: Int -> EvalTables a -> FilePath -> FilePath
$cshowsPrec :: forall a. Int -> EvalTables a -> FilePath -> FilePath
Show, (forall x. EvalTables a -> Rep (EvalTables a) x)
-> (forall x. Rep (EvalTables a) x -> EvalTables a)
-> Generic (EvalTables a)
forall x. Rep (EvalTables a) x -> EvalTables a
forall x. EvalTables a -> Rep (EvalTables a) x
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, EvalTables a -> ()
(EvalTables a -> ()) -> NFData (EvalTables a)
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 = [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])]
-> EvalTables a
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 [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])] -> [(Int, [(StatsDef a, Table)])]
forall a. Semigroup a => a -> a -> a
<> [(Int, [(StatsDef a, Table)])]
bp) ([(Int, [(StatsDef a, Table)])]
ar [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])] -> [(Int, [(StatsDef a, Table)])]
forall a. Semigroup a => a -> a -> a
<> [(Int, [(StatsDef a, Table)])]
br) ([(Int, [(StatsDef a, Table)])]
ae [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])] -> [(Int, [(StatsDef a, Table)])]
forall a. Semigroup a => a -> a -> a
<> [(Int, [(StatsDef a, Table)])]
be) ([(Int, [(StatsDef a, Table)])]
an [(Int, [(StatsDef a, Table)])]
-> [(Int, [(StatsDef a, Table)])] -> [(Int, [(StatsDef a, Table)])]
forall a. Semigroup a => a -> a -> a
<> [(Int, [(StatsDef a, Table)])]
bn)

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


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


leastUnit :: EvalResults a -> Unit
leastUnit :: 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)    = Unit -> Unit -> Unit
forall a. Ord a => a -> a -> a
min Unit
u (EvalResults a -> Unit
forall a. EvalResults a -> Unit
leastUnit ([EvalResults a] -> EvalResults a
forall a. [a] -> a
head [EvalResults a]
vals))


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

mkNamesUntil :: Unit -> EvalResults a -> [Text]
mkNamesUntil :: Unit -> EvalResults a -> [Text]
mkNamesUntil Unit
unit EvalResults a
res
  | EvalResults a
res EvalResults a -> Getting Unit (EvalResults a) Unit -> Unit
forall s a. s -> Getting a s a -> a
^. Getting Unit (EvalResults a) Unit
forall a. Lens' (EvalResults a) Unit
evalUnit Unit -> Unit -> Bool
forall a. Eq a => a -> a -> Bool
== Unit
unit = [Text
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 -> [Text
forall a. Monoid a => a
mempty]
          Unit
UnitReplications -> (Int -> Text) -> [Int] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (\Int
x -> Text
"Rpl " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall a. Show a => a -> Text
tshow Int
x Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
": ") [Int
1 .. [EvalResults a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [EvalResults a]
vals]
          Unit
_ ->
            let sub :: [Text]
sub = [[Text]] -> [Text]
forall a. [a] -> a
head ([[Text]] -> [Text]) -> [[Text]] -> [Text]
forall a b. (a -> b) -> a -> b
$ (EvalResults a -> [Text]) -> [EvalResults a] -> [[Text]]
forall a b. (a -> b) -> [a] -> [b]
map (Unit -> EvalResults a -> [Text]
forall a. Unit -> EvalResults a -> [Text]
mkNamesUntil Unit
unit) [EvalResults a]
vals
            in (Int -> [Text]) -> [Int] -> [Text]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\Int
x -> (Text -> Text) -> [Text] -> [Text]
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 " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall a. Show a => a -> Text
tshow Int
x Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
": " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
s) [Text]
sub) [Int
1 .. [EvalResults a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [EvalResults a]
vals]
      EvalResults a
_ -> FilePath -> [Text]
forall a. HasCallStack => FilePath -> a
error (FilePath -> [Text]) -> FilePath -> [Text]
forall a b. (a -> b) -> a -> b
$ FilePath
"cannot unpack res: " FilePath -> FilePath -> FilePath
forall a. Semigroup a => a -> a -> a
<> EvalResults a -> FilePath
forall a. Show a => a -> FilePath
show EvalResults a
res


mkExperimentTable :: Evals a -> (Unit, ExperimentEval a, [EvalResults a]) -> (Int, [(StatsDef a, Table)])
mkExperimentTable :: 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 = (EvalResults a -> ([[Cell]], [EvalResults a]))
-> [EvalResults a] -> [([[Cell]], [EvalResults a])]
forall a b. (a -> b) -> [a] -> [b]
map (\EvalResults a
rs -> (EvalResults a -> [[Cell]]
forall a. EvalResults a -> [[Cell]]
mkNames EvalResults a
rs, Unit -> EvalResults a -> [EvalResults a]
forall a. Unit -> EvalResults a -> [EvalResults a]
unpackUntil Unit
lowestUnit EvalResults a
rs)) [EvalResults a]
res
      tableRes :: [[TableResult]]
tableRes = (([[Cell]], [EvalResults a]) -> [TableResult])
-> [([[Cell]], [EvalResults a])] -> [[TableResult]]
forall a b. (a -> b) -> [a] -> [b]
map (([[Cell]] -> [EvalResults a] -> [TableResult])
-> ([[Cell]], [EvalResults a]) -> [TableResult]
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (([Cell] -> EvalResults a -> TableResult)
-> [[Cell]] -> [EvalResults a] -> [TableResult]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (Unit -> [Cell] -> EvalResults a -> TableResult
forall a. Unit -> [Cell] -> EvalResults a -> TableResult
mkEvalResult Unit
lowestUnit))) [([[Cell]], [EvalResults a])]
resUnit
      tbls :: [Table]
tbls = ([TableResult] -> Table) -> [[TableResult]] -> [Table]
forall a b. (a -> b) -> [a] -> [b]
map [TableResult] -> Table
toTables [[TableResult]]
tableRes
      mkNames :: EvalResults a -> [[Cell]]
mkNames = (Text -> [Cell]) -> [Text] -> [[Cell]]
forall a b. (a -> b) -> [a] -> [b]
map ((Text -> Cell) -> [Text] -> [Cell]
forall a b. (a -> b) -> [a] -> [b]
map Text -> Cell
CellT ([Text] -> [Cell]) -> (Text -> [Text]) -> Text -> [Cell]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return) ([Text] -> [[Cell]])
-> (EvalResults a -> [Text]) -> EvalResults a -> [[Cell]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Unit -> EvalResults a -> [Text]
forall a. Unit -> EvalResults a -> [Text]
mkNamesUntil Unit
lowestUnit
      evalStatDefs :: [StatsDef a]
evalStatDefs = (EvalResults a -> StatsDef a) -> [EvalResults a] -> [StatsDef a]
forall a b. (a -> b) -> [a] -> [b]
map (EvalResults a
-> Getting (StatsDef a) (EvalResults a) (StatsDef a) -> StatsDef a
forall s a. s -> Getting a s a -> a
^. Getting (StatsDef a) (EvalResults a) (StatsDef a)
forall a. Lens' (EvalResults a) (StatsDef a)
evalType) [EvalResults a]
res
   in (ExperimentEval a
eval ExperimentEval a -> Getting Int (ExperimentEval a) Int -> Int
forall s a. s -> Getting a s a -> a
^. Getting Int (ExperimentEval a) Int
forall a. Lens' (ExperimentEval a) Int
evalExperimentNumber, [StatsDef a] -> [Table] -> [(StatsDef a, Table)]
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 -> FilePath -> FilePath
[TableResult] -> FilePath -> FilePath
TableResult -> FilePath
(Int -> TableResult -> FilePath -> FilePath)
-> (TableResult -> FilePath)
-> ([TableResult] -> FilePath -> FilePath)
-> Show TableResult
forall a.
(Int -> a -> FilePath -> FilePath)
-> (a -> FilePath) -> ([a] -> FilePath -> FilePath) -> Show a
showList :: [TableResult] -> FilePath -> FilePath
$cshowList :: [TableResult] -> FilePath -> FilePath
show :: TableResult -> FilePath
$cshow :: TableResult -> FilePath
showsPrec :: Int -> TableResult -> FilePath -> FilePath
$cshowsPrec :: Int -> TableResult -> FilePath -> FilePath
Show)

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

mkEvalResult :: Unit -> [Cell] -> EvalResults a -> TableResult
mkEvalResult :: Unit -> [Cell] -> EvalResults a -> TableResult
mkEvalResult Unit
_ [Cell]
_ (EvalVector StatsDef a
_ Unit
_ []) = FilePath -> TableResult
forall a. HasCallStack => FilePath -> a
error FilePath
"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 ([Cell] -> Row) -> [Cell] -> Row
forall a b. (a -> b) -> a -> b
$ Text -> Cell
CellT (Unit -> Text
forall p. IsString p => Unit -> p
unitName Unit
leastUnit') Cell -> [Cell] -> [Cell]
forall a. a -> [a] -> [a]
: (Int -> Cell) -> [Int] -> [Cell]
forall a b. (a -> b) -> [a] -> [b]
map (Text -> Cell
CellT (Text -> Cell) -> (Int -> Text) -> Int -> Cell
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text
forall a. Show a => a -> Text
tshow) [Int
1 .. [EvalResults a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [EvalResults a]
vals]) (([Cell] -> Row) -> [[Cell]] -> [Row]
forall a b. (a -> b) -> [a] -> [b]
map [Cell] -> Row
Row (([[Cell]] -> [Row] -> [[Cell]]) -> [[Cell]] -> [[Row]] -> [[Cell]]
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 = (EvalResults a -> TableResult) -> [EvalResults a] -> [TableResult]
forall a b. (a -> b) -> [a] -> [b]
map (Unit -> [Cell] -> EvalResults a -> TableResult
forall a. Unit -> [Cell] -> EvalResults a -> TableResult
mkEvalResult Unit
leastUnit' []) [EvalResults a]
vals
    rowVals :: [[Row]]
rowVals = (TableResult -> [Row]) -> [TableResult] -> [[Row]]
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 = ([Cell] -> [Cell] -> [Cell]) -> [[Cell]] -> [[Cell]] -> [[Cell]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith [Cell] -> [Cell] -> [Cell]
forall a. [a] -> [a] -> [a]
(++) [[Cell]]
accs ((Row -> [Cell]) -> [Row] -> [[Cell]]
forall a b. (a -> b) -> [a] -> [b]
map Row -> [Cell]
fromRow [Row]
vs)
    fromRow :: Row -> [Cell]
fromRow (Row [Cell]
xs) = [Cell]
xs
    unitName :: Unit -> p
unitName Unit
UnitPeriods              = p
"Period:"
    unitName Unit
UnitReplications         = p
"Replication:"
    unitName Unit
UnitExperimentRepetition = p
"Experiment Repetition:"
    -- unitName (UnitBestExperimentRepetitions bestNr) = "Best " <> tshow bestNr <> " Experiment Repetitions:"
    unitName Unit
UnitScalar               = p
"Value:"
mkEvalResult Unit
_ [] (EvalValue StatsDef a
_ Unit
_ ByteString
_ Either Int Double
x Double
y) = Row -> [Row] -> TableResult
TableResult ([Cell] -> Row
Row [Either Int Double -> Cell
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 (Text -> Cell) -> Text -> Cell
forall a b. (a -> b) -> a -> b
$ a -> Text
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, Either Int Double -> Cell
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 (Text -> Cell) -> Text -> Cell
forall a b. (a -> b) -> a -> b
$ a -> Text
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 (Text -> Cell) -> Text -> Cell
forall a b. (a -> b) -> a -> b
$ StatsDef a -> Text
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 (Text -> Cell) -> Text -> Cell
forall a b. (a -> b) -> a -> b
$ StatsDef a -> Text
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 :: Evals a -> ExperimentEval a -> Maybe Table
paramSettingTable Evals a
evals (ExperimentEval Int
_ [Availability IO (EvalResults a)]
_ Experiment a
exp)
  | [ParameterSetting a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Experiment a
exp Experiment a
-> Getting [ParameterSetting a] (Experiment a) [ParameterSetting a]
-> [ParameterSetting a]
forall s a. s -> Getting a s a -> a
^. Getting [ParameterSetting a] (Experiment a) [ParameterSetting a]
forall a. Lens' (Experiment a) [ParameterSetting a]
parameterSetup) = Maybe Table
forall a. Maybe a
Nothing
  | Bool
otherwise = Table -> Maybe Table
forall a. a -> Maybe a
Just (Table -> Maybe Table) -> Table -> Maybe Table
forall a b. (a -> b) -> a -> b
$ Row -> [Row] -> Table
Table ([Cell] -> Row
Row [Cell
"Parameter", Cell
"Value"]) ((ParameterSetting a -> [Row]) -> [ParameterSetting a] -> [Row]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ParameterSetting a -> [Row]
forall a. ParameterSetting a -> [Row]
mkRow (Experiment a
exp Experiment a
-> Getting [ParameterSetting a] (Experiment a) [ParameterSetting a]
-> [ParameterSetting a]
forall s a. s -> Getting a s a -> a
^. Getting [ParameterSetting a] (Experiment a) [ParameterSetting 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 (Text -> Cell) -> Text -> Cell
forall a b. (a -> b) -> a -> b
$ Text
"True (No further variations needed as specified by parameter " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
n Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"!)"]
    mkRow :: ParameterSetting a -> [Row]
    mkRow :: ParameterSetting a -> [Row]
mkRow (ParameterSetting Text
n ByteString
bsV Bool
drp ExperimentDesign
design) =
      case (ParameterSetup a -> Bool)
-> [ParameterSetup a] -> Maybe (ParameterSetup a)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
n) (Text -> Bool)
-> (ParameterSetup a -> Text) -> ParameterSetup a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParameterSetup a -> Text
forall a. ParameterSetup a -> Text
parameterName) (Evals a
evals Evals a
-> Getting [ParameterSetup a] (Evals a) [ParameterSetup a]
-> [ParameterSetup a]
forall s a. s -> Getting a s a -> a
^. (Experiments a -> Const [ParameterSetup a] (Experiments a))
-> Evals a -> Const [ParameterSetup a] (Evals a)
forall a. Lens' (Evals a) (Experiments a)
evalsExperiments ((Experiments a -> Const [ParameterSetup a] (Experiments a))
 -> Evals a -> Const [ParameterSetup a] (Evals a))
-> (([ParameterSetup a]
     -> Const [ParameterSetup a] [ParameterSetup a])
    -> Experiments a -> Const [ParameterSetup a] (Experiments a))
-> Getting [ParameterSetup a] (Evals a) [ParameterSetup a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([ParameterSetup a] -> Const [ParameterSetup a] [ParameterSetup a])
-> Experiments a -> Const [ParameterSetup a] (Experiments a)
forall a. Lens' (Experiments a) [ParameterSetup a]
experimentsParameters) of
        Maybe (ParameterSetup a)
Nothing ->
          [Cell] -> Row
Row
            [ Text -> Cell
CellT Text
n
            , Text -> Cell
CellT (Text -> Cell) -> Text -> Cell
forall a b. (a -> b) -> a -> b
$ Text
"was not modified as it is not listed in the parameter setting" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
              (if Bool
drp
                 then Text
" [SkipPrepPhase]"
                 else Text
"") Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
              (case ExperimentDesign
design of
                 ExperimentDesign
FullFactory    -> Text
""
                 ExperimentDesign
SingleInstance -> Text
"[SingleInstance]")
            ] Row -> [Row] -> [Row]
forall a. a -> [a] -> [a]
:
          [Row
dropRow | Bool
drp] [Row] -> [Row] -> [Row]
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 Get b -> ByteString -> Either FilePath b
forall a. Get a -> ByteString -> Either FilePath a
S.runGet Get b
forall t. Serialize t => Get t
S.get ByteString
bsV of
            Left FilePath
err -> [[Cell] -> Row
Row [Text -> Cell
CellT Text
n, Text -> Cell
CellT (FilePath -> Text
T.pack FilePath
err)]]
            Right b
val ->
              let a
_ = b -> a -> a
setter b
val (Evals a
evals Evals a -> Getting a (Evals a) a -> a
forall s a. s -> Getting a s a -> a
^. (Experiments a -> Const a (Experiments a))
-> Evals a -> Const a (Evals a)
forall a. Lens' (Evals a) (Experiments a)
evalsExperiments ((Experiments a -> Const a (Experiments a))
 -> Evals a -> Const a (Evals a))
-> ((a -> Const a a) -> Experiments a -> Const a (Experiments a))
-> Getting a (Evals a) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Const a a) -> Experiments a -> Const a (Experiments a)
forall a. Lens' (Experiments a) a
experimentsInitialState) -- only needed for type inference
               in [Cell] -> Row
Row
                    [ Text -> Cell
CellT Text
n
                    , LaTeX -> Cell
CellL (LaTeX -> Cell) -> LaTeX -> Cell
forall a b. (a -> b) -> a -> b
$ Text -> LaTeX
forall l. LaTeXC l => Text -> l
raw (Text -> Text
dereferLatex (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ b -> Text
forall a. Show a => a -> Text
tshow b
val) LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<>
                      (case Maybe (b, b)
mBounds of
                         Maybe (b, b)
Nothing -> LaTeX
""
                         Just (b
minVal, b
maxVal) -> LaTeX -> LaTeX
forall l. LaTeXC l => l -> l
math (LaTeX -> LaTeX
forall l. LaTeXC l => l -> l
text LaTeX
" " LaTeX -> LaTeX -> LaTeX
forall l. LaTeXC l => l -> l -> l
`in_` LaTeX -> LaTeX
forall l. LaTeXC l => l -> l
autoParens (LaTeX -> LaTeX
forall l. LaTeXC l => l -> l
text (Text -> LaTeX
forall l. LaTeXC l => Text -> l
raw (Text -> Text
dereferLatex (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ b -> Text
forall a. Show a => a -> Text
tshow b
minVal)) LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<> LaTeX
", " LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<> LaTeX -> LaTeX
forall l. LaTeXC l => l -> l
text (Text -> LaTeX
forall l. LaTeXC l => Text -> l
raw (Text -> Text
dereferLatex (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ b -> Text
forall a. Show a => a -> Text
tshow b
maxVal))))) LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<>
                      (if Bool
drp
                         then LaTeX
" [SkipPrepPhase]"
                         else LaTeX
forall a. Monoid a => a
mempty) LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<>
                      (case ExperimentDesign
design of
                         ExperimentDesign
FullFactory    -> LaTeX
""
                         ExperimentDesign
SingleInstance -> LaTeX
"[SingleInstance]")
                    ] Row -> [Row] -> [Row]
forall a. a -> [a] -> [a]
:
                  [Row
dropRow | Bool
drp] [Row] -> [Row] -> [Row]
forall a. [a] -> [a] -> [a]
++
                  [Text -> Row
singleInstanceRow Text
n | Bool
drp]