output.h

Go to the documentation of this file.

 
 
#ifndef CHEBYSHEV_OUTPUT_H
#define CHEBYSHEV_OUTPUT_H
 
#include <vector>
#include <string>
#include <map>
#include <sstream>
#include <iomanip>
#include <fstream>
 
#include "../prec/prec_structures.h"
#include "../benchmark/benchmark_structures.h"
#include "../err/err_structures.h"
 
 
namespace chebyshev {
 
    namespace output {
 
 
        struct field_options {
 
            using FieldInterpreter = std::function<std::string(const std::string&)>;
            
            unsigned int columnWidth = CHEBYSHEV_OUTPUT_WIDTH;
 
            FieldInterpreter fieldInterpreter = [](const std::string& s) { return s; };
 
            std::map<std::string, long double> additionalFields {};
 
            // Default constructor
            field_options() {}
 
            // Construct field options from the custom column width.
            field_options(unsigned int columnWidth) : columnWidth(columnWidth) {}
        };
 
 
        struct output_settings {
 
            using OutputFormat_t = std::function<
            std::string(
                const std::vector<std::vector<std::string>>&,
                const std::vector<std::string>&,
                const output_settings&)>;
 
            std::map<std::string, std::string> fieldNames {};
 
            std::map<std::string, field_options> fieldOptions {};
 
            std::vector<std::string> outputFiles {};
 
            std::map<std::string, std::ofstream> openFiles {};
 
            unsigned int defaultColumnWidth = CHEBYSHEV_OUTPUT_WIDTH;
 
            unsigned int outputPrecision = 1;
 
            OutputFormat_t outputFormat {};
 
            OutputFormat_t defaultFileOutputFormat {};
 
            std::map<std::string, OutputFormat_t> fileOutputFormat {};
 
            bool quiet = false;
 
            bool outputToFile = true;
 
            bool wasSetup = false;
 
        };
 
 
        using OutputFormat = output_settings::OutputFormat_t;
 
 
        namespace format {
            
 
            inline OutputFormat barebone() {
 
                return [](
                    const std::vector<std::vector<std::string>>& table,
                    const std::vector<std::string>& fields,
                    const output_settings& settings) -> std::string {
 
                    if(!table.size())
                        return "";
 
                    std::stringstream result;
 
                    for (size_t i = 0; i < table.size(); ++i) {
 
                        if(table[i].size() != fields.size()) {
                            std::runtime_error(
                                "Number of columns and fields argument must have "
                                "the same size in output::format::barebone");
                        }
 
                        for (size_t j = 0; j < table[i].size(); ++j) {
 
                            auto it = settings.fieldOptions.find(fields[j]);
 
                            if(it != settings.fieldOptions.end() && i)
                                result << std::setw(it->second.columnWidth)
                                << std::left << it->second.fieldInterpreter(table[i][j]);
                            else if(it != settings.fieldOptions.end())
                                result << std::setw(it->second.columnWidth)
                                << std::left << table[i][j];
                            else
                                result << std::setw(settings.defaultColumnWidth)
                                << std::left << table[i][j];
                        }
 
                        result << "\n";
                    }
 
                    return result.str();
                };
            }
 
 
            inline OutputFormat simple() {
 
                return [](
                    const std::vector<std::vector<std::string>>& table,
                    const std::vector<std::string>& fields,
                    const output_settings& settings) -> std::string {
 
                    if(!table.size())
                        return "";
 
                    std::stringstream result;
                    std::stringstream header_str;
 
                    header_str << " | ";
 
                    for (size_t i = 0; i < table[0].size(); ++i) {
 
                        auto it = settings.fieldOptions.find(fields[i]);
 
                        if(it != settings.fieldOptions.end())
                            header_str << std::setw(it->second.columnWidth) << table[0][i] << " | ";
                        else
                            header_str << std::setw(settings.defaultColumnWidth) << table[0][i] << " | ";
                    }
 
                    std::string header = header_str.str();
                    std::string decoration = " +";
                    for (size_t i = 4; i < header.size(); ++i)
                        decoration += "-";
                    decoration += "+ \n";
 
                    for (size_t i = 1; i < table.size(); ++i) {
 
                        if(table[i].size() != fields.size()) {
                            std::runtime_error(
                                "Number of columns and <fields> argument must have "
                                "the same size in output::format::simple");
                        }
 
                        result << " | ";
 
                        for (size_t j = 0; j < table[i].size(); ++j) {
 
                            auto it = settings.fieldOptions.find(fields[j]);
 
                            if(it != settings.fieldOptions.end())
                                result << std::setw(it->second.columnWidth)
                                << it->second.fieldInterpreter(table[i][j]) << " | ";
                            else
                                result << std::setw(settings.defaultColumnWidth)
                                << table[i][j] << " | ";
                        }
 
                        result << "\n";
                    }
 
                    return decoration
                        + header + "\n"
                        + decoration
                        + result.str()
                        + decoration;
                };
            }
 
 
            inline OutputFormat fancy(bool adaptiveWidth = true) {
 
                return [adaptiveWidth](
                    const std::vector<std::vector<std::string>>& table,
                    const std::vector<std::string>& fields,
                    const output_settings& settings) -> std::string {
 
                    if(!table.size())
                        return "";
 
                    // Effective length of the string
                    // (needed because Unicode is used)
                    size_t eff_length = 0;
                    std::stringstream header_str;
                    
                    header_str << " │ ";
                    eff_length += 3;
 
                    // Processed table
                    auto proc_table = table;
 
                    // Field value interpretation step
                    for (size_t i = 0; i < proc_table[0].size(); ++i) {
                        
                        auto it = settings.fieldOptions.find(fields[i]);
 
                        if (it == settings.fieldOptions.end())
                            continue;
 
                        for (size_t j = 1; j < proc_table.size(); ++j)
                            proc_table[j][i] = it->second.fieldInterpreter(table[j][i]);
                    }
 
                    std::vector<size_t> computedWidth;
 
                    // Compute the ideal column width
                    if (adaptiveWidth) {
 
                        computedWidth.resize(proc_table[0].size());
 
                        for (size_t i = 0; i < proc_table[0].size(); ++i) {
                            
                            computedWidth[i] = settings.defaultColumnWidth;
 
                            for (size_t j = 0; j < proc_table.size(); ++j)
                                if (proc_table[j][i].size() > computedWidth[i])
                                    computedWidth[i] = proc_table[j][i].size();
                        }
                    }
 
                    // Print table header
                    for (size_t i = 0; i < table[0].size(); ++i) {
 
                        auto it = settings.fieldOptions.find(fields[i]);
 
                        unsigned int width = 0;
 
                        if(it != settings.fieldOptions.end() && !adaptiveWidth)
                            width = it->second.columnWidth;
                        else if (adaptiveWidth) 
                            width = computedWidth[i];
                        else
                            width = settings.defaultColumnWidth;
 
                        header_str << std::setw(width) << table[0][i] << " │ ";
                        eff_length += width + 3;
                    }
 
                    std::string header = " ┌";
 
                    // Upper outline
                    for (size_t i = 4; i < eff_length; ++i)
                        header += "─";
                    header += "┐ \n";
 
                    header += header_str.str() + "\n";
 
                    // Lower outline
                    header += " ├";
                    for (size_t i = 4; i < eff_length; ++i)
                        header += "─";
                    header += "┤ \n";
 
                    std::stringstream result;
 
                    for (size_t i = 1; i < proc_table.size(); ++i) {
 
                        if(proc_table[i].size() != fields.size()) {
                            std::runtime_error(
                                "Number of columns and <fields> argument must have "
                                "the same size in output::format::fancy");
                        }
 
                        result << " │ ";
 
                        for (size_t j = 0; j < proc_table[i].size(); ++j) {
 
                            auto it = settings.fieldOptions.find(fields[j]);
 
                            if(it != settings.fieldOptions.end() && !adaptiveWidth)
                                result << std::setw(it->second.columnWidth)
                                << proc_table[i][j] << " │ ";
                            else if (adaptiveWidth) {
                                result << std::setw(computedWidth[j])
                                << proc_table[i][j] << " │ ";
                            } else
                                result << std::setw(settings.defaultColumnWidth)
                                << proc_table[i][j] << " │ ";
                        }
 
                        result << "\n";
                    }
 
                    std::string underline = " └";
                    for (size_t i = 4; i < eff_length; ++i) {
                        underline += "─";
                    }
                    underline += "┘ \n";
 
                    return header + result.str() + underline;
                };
            }
 
 
            inline OutputFormat csv(const std::string& separator = ",") {
 
                return [separator](
                    const std::vector<std::vector<std::string>>& table,
                    const std::vector<std::string>& fields,
                    const output_settings& settings) -> std::string {
 
                    std::stringstream s;
 
                    for (size_t i = 0; i < table.size(); ++i) {
 
                        if(table[i].size() != fields.size()) {
                            throw std::runtime_error(
                                "Number of columns and <fields> argument must have "
                                "the same size in output::format::csv");
                        }
 
 
                        for (size_t j = 0; j < table[i].size(); ++j) {
 
                            auto it = settings.fieldOptions.find(fields[j]);
 
                            if(it != settings.fieldOptions.end() && i)
                                s << "\"" << it->second.fieldInterpreter(table[i][j]) << "\"";
                            else
                                s << "\"" << table[i][j] << "\"";
 
                            if(j != table[i].size() - 1)
                                s << separator;
                        }
 
                        s << "\n";
                    }
 
                    return s.str();
                };
            }
 
 
            inline OutputFormat markdown() {
 
                return [](
                    const std::vector<std::vector<std::string>>& table,
                    const std::vector<std::string>& fields,
                    const output_settings& settings) -> std::string {
 
                    if(!table.size())
                        return "";
 
                    std::stringstream result;
                    std::stringstream header_str;
 
                    header_str << "|";
 
                    for (size_t i = 0; i < table[0].size(); ++i) {
 
                        auto it = settings.fieldOptions.find(fields[i]);
 
                        if(it != settings.fieldOptions.end())
                            header_str << std::setw(it->second.columnWidth)
                            << std::left << table[0][i];
                        else
                            header_str << std::setw(settings.defaultColumnWidth)
                            << std::left << table[0][i];
 
                        header_str << "|";
                    }
 
                    std::string header = header_str.str();
                    std::string decoration = "|";
                    for (size_t i = 1; i < header.size() - 1; ++i)
                        decoration += (header[i] == '|') ? "|" : "-";
                    decoration += "|\n";
 
                    for (size_t i = 1; i < table.size(); ++i) {
 
                        if(table[i].size() != fields.size()) {
                            std::runtime_error(
                                "Number of columns and <fields> argument must have "
                                "the same size in output::format::markdown");
                        }
 
                        result << "|";
 
                        for (size_t j = 0; j < table[i].size(); ++j) {
 
                            auto it = settings.fieldOptions.find(fields[j]);
 
                            if(it != settings.fieldOptions.end())
                                result << std::setw(it->second.columnWidth)
                                << std::left << it->second.fieldInterpreter(table[i][j]);
                            else
                                result << std::setw(settings.defaultColumnWidth)
                                << std::left << table[i][j];
 
                            result << "|";
                        }
 
                        result << "\n";
                    }
 
                    return header + "\n" + decoration + result.str();
                };
            }
 
 
            inline OutputFormat latex() {
 
                return [=](
                    const std::vector<std::vector<std::string>>& table,
                    const std::vector<std::string>& fields,
                    const output_settings& settings) -> std::string {
 
                    if(!table.size())
                        return "";
 
                    std::stringstream result;
                    result << "\\begin{tabular}{";
 
                    if(fields.size())
                        result << "|";
 
                    for (unsigned int i = 0; i < fields.size(); ++i)
                        result << "c|";
 
                    result << "}\n\\hline\n";
 
                    for (size_t i = 0; i < table[0].size(); ++i) {
 
                        result << table[0][i];
 
                        if(i != table[0].size() - 1)
                            result << " & ";
                    }
                    result << " \\\\\n\\hline\n";
 
                    for (size_t i = 1; i < table.size(); ++i) {
 
                        if(table[i].size() != fields.size()) {
                            std::runtime_error(
                                "Number of columns and <fields> argument must have "
                                "the same size in output::format::latex");
                        }
 
                        for (size_t j = 0; j < table[i].size(); ++j) {
 
                            auto it = settings.fieldOptions.find(fields[j]);
 
                            if(it != settings.fieldOptions.end())
                                result << it->second.fieldInterpreter(table[i][j]);
                            else
                                result << table[i][j];
 
                            if(j != table[i].size() - 1)
                                result << " & ";
                        }
 
                        result << " \\\\\n";
                    }
 
                    result << "\\hline\n\\end{tabular}\n";
 
                    return result.str();
                };
            }
 
        }
 
 
        class output_context {
        public:
 
            output_settings settings;
 
            
            inline void setup() {
 
                // Skip subsequent setup calls
                if (settings.wasSetup)
                    return;
 
                // Estimate fields
                settings.fieldNames["name"] = "Function";
                settings.fieldNames["maxErr"] = "Max Err.";
                settings.fieldNames["meanErr"] = "Mean Err.";
                settings.fieldNames["rmsErr"] = "RMS Err.";
                settings.fieldNames["relErr"] = "Rel. Err.";
                settings.fieldNames["absErr"] = "Abs. Err.";
                settings.fieldNames["tolerance"] = "Tolerance";
                settings.fieldNames["failed"] = "Result";
                settings.fieldNames["iterations"] = "Iterations";
 
                // Equation fields
                settings.fieldNames["difference"] = "Difference";
                settings.fieldNames["evaluated"] = "Evaluated";
                settings.fieldNames["expected"] = "Expected";
 
                // Benchmark fields
                settings.fieldNames["totalRuntime"] = "Tot. Time (ms)";
                settings.fieldNames["averageRuntime"] = "Avg. Time (ms)";
                settings.fieldNames["stdevRuntime"] = "Stdev. Time (ms)";
                settings.fieldNames["runsPerSecond"] = "Runs per Sec.";
                settings.fieldNames["runs"] = "Runs";
                settings.fieldNames["seed"] = "Seed";
 
                // Error checking
                settings.fieldNames["correctType"] = "Correct Type";
                settings.fieldNames["description"] = "Description";
                settings.fieldNames["expectedFlags"] = "Exp. Flags";
                settings.fieldNames["thrown"] = "Has Thrown";
 
                // Set wider column width for some fields
                settings.fieldOptions["name"].columnWidth = 20;
                settings.fieldOptions["averageRuntime"].columnWidth = 14;
                settings.fieldOptions["stdevRuntime"].columnWidth = 16;
                settings.fieldOptions["runsPerSecond"].columnWidth = 14;
                settings.fieldOptions["description"].columnWidth = 20;
 
                // Set a special field interpreter for the "failed" field
                settings.fieldOptions["failed"].fieldInterpreter = [](const std::string& s) {
                    if(s == "0") return "PASS";
                    else if(s == "1") return "FAIL";
                    else return "UNKNOWN";
                };
 
                // Set the default output formats
                settings.outputFormat = format::fancy();
                settings.defaultFileOutputFormat = format::csv();
 
                settings.wasSetup = true;
            }
 
 
            inline void terminate() {
 
                // Close all open files
                for (auto& file_pair : settings.openFiles)
                    if(file_pair.second.is_open())
                        file_pair.second.close();
            }
 
 
            output_context() {
                setup();
            }
            
 
            ~output_context() {
                terminate();
            }
 
 
            inline std::string resolve_field(
                const std::string& fieldName, prec::estimate_result r) {
 
                std::stringstream value;
 
                if(fieldName == "name") {
                    value << r.name;
                } else if(fieldName == "maxErr") {
                    value << std::scientific
                        << std::setprecision(settings.outputPrecision)
                        << r.maxErr;
                } else if(fieldName == "meanErr") {
                    value << std::scientific
                        << std::setprecision(settings.outputPrecision)
                        << r.meanErr;
                } else if(fieldName == "rmsErr") {
                    value << std::scientific
                        << std::setprecision(settings.outputPrecision)
                        << r.rmsErr;
                } else if(fieldName == "relErr") {
                    value << std::scientific
                        << std::setprecision(settings.outputPrecision)
                        << r.relErr;
                } else if(fieldName == "absErr") {
                    value << std::scientific
                        << std::setprecision(settings.outputPrecision)
                        << r.absErr;
                } else if(fieldName == "tolerance") {
                    value << std::scientific
                        << std::setprecision(settings.outputPrecision)
                        << r.tolerance;
                } else if(fieldName == "failed") {
                    value << r.failed;
                } else {
                    
                    if(r.additionalFields.find(fieldName) == r.additionalFields.end())
                        return "";
 
                    value << r.additionalFields[fieldName];
                }
 
                return value.str();
            }
 
 
            inline std::string resolve_field(
                const std::string& fieldName, prec::equation_result r) {
 
                std::stringstream value;
 
                if(fieldName == "name") {
                    value << r.name;
                } else if(fieldName == "evaluated") {
                    value << r.evaluated;
                } else if(fieldName == "expected") {
                    value << r.expected;
                } else if(fieldName == "difference") {
                    value << std::scientific
                        << std::setprecision(settings.outputPrecision)
                        << r.difference;
                } else if(fieldName == "tolerance") {
                    value << std::scientific
                        << std::setprecision(settings.outputPrecision)
                        << r.tolerance;
                } else if(fieldName == "failed") {
                    value << r.failed;
                } else {
                    
                    if(r.additionalFields.find(fieldName) == r.additionalFields.end())
                        return "";
 
                    value << r.additionalFields[fieldName];
                }
 
                return value.str();
            }
 
 
            inline std::string resolve_field(
                const std::string& fieldName, benchmark::benchmark_result r) {
 
                std::stringstream value;
 
                if(fieldName == "name") {
                    value << r.name;
                } else if(fieldName == "runs") {
                    value << r.runs;
                } else if(fieldName == "iterations") {
                    value << r.iterations;
                } else if(fieldName == "totalRuntime") {
                    value << std::scientific
                          << std::setprecision(settings.outputPrecision)
                          << r.totalRuntime;
                } else if(fieldName == "averageRuntime") {
                    value << std::scientific
                          << std::setprecision(settings.outputPrecision)
                          << r.averageRuntime;
                } else if(fieldName == "stdevRuntime") {
                    value << std::scientific
                          << std::setprecision(settings.outputPrecision)
                          << r.stdevRuntime;
                } else if(fieldName == "runsPerSecond") {
                    if(r.runsPerSecond > 1000)
                        value << uint64_t(r.runsPerSecond);
                    else
                        value << r.runsPerSecond;
                } else if(fieldName == "failed") {
                    value << r.failed;
                } else if(fieldName == "seed") {
                    value << r.seed;
                } else {
                    
                    if(r.additionalFields.find(fieldName) == r.additionalFields.end())
                        return "";
 
                    value << r.additionalFields[fieldName];
                }
 
                return value.str();
            }
 
 
            inline std::string resolve_field(
                const std::string& fieldName, err::assert_result r) {
 
                std::stringstream value;
 
                if(fieldName == "name") {
                    value << r.name;
                } else if(fieldName == "evaluated") {
                    value << r.evaluated;
                } else if(fieldName == "description") {
                    value << r.description;
                } else if(fieldName == "failed") {
                    value << r.failed;
                } else {
                    return "";
                }
 
                return value.str();
            }
 
 
            inline std::string resolve_field(
                const std::string& fieldName, err::errno_result r) {
 
                std::stringstream value;
 
                if(fieldName == "name") {
                    value << r.name;
                } else if(fieldName == "evaluated") {
                    value << r.evaluated;
                } else if(fieldName == "expectedFlags") {
 
                    int res_flag = 0xFFFFFFFF;
                    for (int flag : r.expectedFlags)
                        res_flag &= flag;
 
                    value << res_flag;
 
                } else if(fieldName == "failed") {
                    value << r.failed;
                } else {
                    return "";
                }
 
                return value.str();
            }
 
 
            inline std::string resolve_field(
                const std::string& fieldName, err::exception_result r) {
 
                std::stringstream value;
 
                if(fieldName == "name") {
                    value << r.name;
                } else if(fieldName == "thrown") {
                    value << r.thrown;
                } else if(fieldName == "correctType") {
                    value << r.correctType;
                } else if(fieldName == "failed") {
                    value << r.failed;
                } else {
                    return "";
                }
 
                return value.str();
            }
 
 
            template<typename ResultType>
            inline auto generate_table(
                const std::map<std::string, std::vector<ResultType>>& results,
                const std::vector<std::string>& fields) {
 
                std::vector<std::vector<std::string>> table;
 
                // Construct header
                std::vector<std::string> header (fields.size());
                for (size_t i = 0; i < fields.size(); ++i) {
 
                    const auto it = settings.fieldNames.find(fields[i]);
 
                    // Associate string to field name
                    if(it != settings.fieldNames.end())
                        header[i] = it->second;
                    else
                        header[i] = fields[i];
                }
                table.emplace_back(header);
 
                // Construct rows
                for (const auto& p : results) {
                    for (const auto& result : p.second) {
 
                        // Skip results marked as quiet
                        if (result.quiet)
                            continue;
 
                        std::vector<std::string> row (fields.size());
 
                        for (size_t i = 0; i < fields.size(); ++i)
                            row[i] = resolve_field(fields[i], result);
 
                        table.emplace_back(row);
                    }
                }
 
                return table;
            }
 
 
            inline bool open_file(const std::string& filename) {
 
                const auto file_pair = settings.openFiles.find(filename);
 
                // If the file is not already open, try to open it and write to it 
                if (file_pair == settings.openFiles.end() || !file_pair->second.is_open()) {
 
                    settings.openFiles[filename].open(filename);
 
                    if (!settings.openFiles[filename].is_open()) {
                        settings.openFiles.erase(filename);
                        return false;
                    }
                }
 
                return true;
            }
 
 
            template<typename ResultType>
            inline void print_results(
                const std::map<std::string, std::vector<ResultType>>& results,
                const std::vector<std::string>& fields,
                const std::vector<std::string>& filenames) {
 
                // Skip output on no test case results
                if(results.empty())
                    return;
 
                // Table data as a string matrix
                std::vector<std::vector<std::string>> table = generate_table(results, fields);
 
                // Write to standard output
                if(!settings.quiet) {
                    std::cout << "\n";
                    std::cout << settings.outputFormat(table, fields, settings);
                    std::cout << "\n";
                }
 
                // Skip printing to file
                if (!settings.outputToFile)
                    return;
 
                // Write to the module specific output files
                for (const auto& filename : filenames) {
 
                    if (!open_file(filename)) {
                        std::cout << "Unable to write to output file: " << filename << std::endl;
                        continue;
                    }
 
                    auto& file = settings.openFiles[filename];
 
                    // Apply formatting according to set options
                    const auto it = settings.fileOutputFormat.find(filename);
 
                    if(it != settings.fileOutputFormat.end())
                        file << it->second(table, fields, settings);
                    else
                        file << settings.defaultFileOutputFormat(table, fields, settings);
 
                    std::cout << "Results have been saved in: " << filename << std::endl;
                }
 
                // Write to the generic output files
                for (const auto& filename : settings.outputFiles) {
 
                    if (!open_file(filename)) {
                        std::cout << "Unable to write to output file: " << filename << std::endl;
                        continue;
                    }
 
                    auto& file = settings.openFiles[filename];
                    
                    // Apply formatting according to set options
                    const auto it = settings.fileOutputFormat.find(filename);
 
                    if(it != settings.fileOutputFormat.end())
                        file << it->second(table, fields, settings);
                    else
                        file << settings.defaultFileOutputFormat(table, fields, settings);
 
                    std::cout << "Results have been saved in: " << filename << std::endl;
                }
            }
        };
    }
}
 
#endif