prec_structures.h

Go to the documentation of this file.

 
 
#ifndef CHEBYSHEV_PREC_STRUCTURES_H
#define CHEBYSHEV_PREC_STRUCTURES_H
 
#include <string>
#include <vector>
#include <functional>
 
#include "../core/common.h"
#include "./interval.h"
#include "./distance.h"
 
 
namespace chebyshev {
 
    namespace prec {
 
 
        struct estimate_result {
            
            std::string name = "unknown";
 
            std::vector<interval> domain {};
 
            long double tolerance = 0;
 
            long double maxErr = get_nan<long double>();
 
            long double meanErr = get_nan<long double>();
 
            long double rmsErr = get_nan<long double>();
 
            long double relErr = get_nan<long double>();
 
            long double absErr = get_nan<long double>();
 
            std::map<std::string, long double> additionalFields {};
 
            bool failed = false;
 
            bool quiet = false;
 
            unsigned int iterations {0};
        };
 
 
        using FailFunction = std::function<bool(const estimate_result&)>;
 
 
        template<typename Type>
        using DistanceFunction = std::function<long double(Type, Type)>;
 
 
        template<typename R, typename ...Args>
        struct estimate_options {
 
            using Estimator_t = std::function<
                estimate_result(
                    std::function<R(Args...)>,
                    std::function<R(Args...)>,
                    estimate_options)>;
 
            std::vector<interval> domain {};
 
            Estimator_t estimator = [](
                std::function<R(Args...)> f1,
                std::function<R(Args...)> f2,
                estimate_options opt) {
                return estimate_result();
            };
 
            long double tolerance = CHEBYSHEV_PREC_TOLERANCE;
 
            unsigned int iterations = CHEBYSHEV_PREC_ITER;
 
            FailFunction fail = [](const estimate_result& r) {
                return (r.maxErr > r.tolerance) || (r.maxErr != r.maxErr);
            };
 
            bool quiet = false;
 
 
            estimate_options() {}
 
 
            estimate_options(interval omega, Estimator_t estimator)
            : domain({omega}), estimator(estimator) {}
 
 
            estimate_options(
                interval omega,
                Estimator_t estimator,
                long double tolerance,
                unsigned int iterations,
                bool quiet = false)
            : domain({omega}), estimator(estimator), tolerance(tolerance),
              iterations(iterations), quiet(quiet) {}
 
 
            estimate_options(std::vector<interval> omega, Estimator_t estimator)
            : domain(omega), estimator(estimator) {}
 
            estimate_options(
                std::vector<interval> omega,
                Estimator_t estimator,
                long double tolerance,
                unsigned int iterations,
                bool quiet = false)
            : domain(omega), estimator(estimator),
              tolerance(tolerance), iterations(iterations), quiet(quiet) {}
            
        };
 
 
        template<typename R, typename ...Args>
        using Estimator = typename estimate_options<R, Args...>::Estimator_t;
 
 
        struct equation_result {
 
            std::string name = "unknown";
 
            long double evaluated = get_nan<long double>();
 
            long double expected = get_nan<long double>();
            
            long double difference = get_nan<long double>();
 
            std::map<std::string, long double> additionalFields {};
 
            long double tolerance = 0;
 
            bool failed = true;
 
            bool quiet = false;
        };
 
 
        template<typename T>
        struct equation_options {
            
            long double tolerance = CHEBYSHEV_PREC_TOLERANCE;
 
            DistanceFunction<T> distance = [](T x, T y) {
                const auto diff = x - y;
                return (long double) (diff > 0 ? diff : -diff);
            };
 
            bool quiet = false;
 
 
            equation_options() {}
 
 
            equation_options(long double tolerance) : tolerance(tolerance) {}
 
 
            equation_options(long double tolerance, DistanceFunction<T> dist, bool quiet = false)
            : tolerance(tolerance), distance(dist), quiet(quiet) {}
        };
 
    }
}
 
#endif