iter_result.h

Go to the documentation of this file.

 
 
#ifndef THEORETICA_ITER_RESULT_H
#define THEORETICA_ITER_RESULT_H
 
#include <string>
#include "./constants.h"
#include "./error.h"
 
 
namespace theoretica {
 
 
    enum class ConvergenceStatus {
 
        Success,
 
        MaxIterations,
 
        Stalled,
 
        InvalidInput,   
        
        Diverged
    };
 
 
    template<typename Type = real>
    struct iter_result {
 
        Type value;
 
        ConvergenceStatus status = ConvergenceStatus::Success;
 
        unsigned int iterations = 0;
 
        real residual = inf();
 
 
        iter_result() {
            value = make_error<Type>();
        }
 
 
        iter_result(const Type& val) : value(val) {
            status = ConvergenceStatus::Success;
        }
        
        iter_result(const Type& value, unsigned int iterations)
        : value(value), iterations(iterations) {
 
            status = ConvergenceStatus::Success;
        }
 
        iter_result(const Type& value, unsigned int iterations, real residual)
        : value(value), iterations(iterations), residual(residual) {
 
            status = ConvergenceStatus::Success;
        }
 
 
        iter_result(ConvergenceStatus status, unsigned int iterations = 0)
        : status(status), iterations(iterations) {
            value = make_error<Type>();
        }
 
        iter_result(ConvergenceStatus status, unsigned int iterations, real residual)
        : status(status), iterations(iterations), residual(residual) {
            value = make_error<Type>();
        }
 
        iter_result(const Type& value, ConvergenceStatus status, unsigned int iterations, real residual)
        : value(value), status(status), iterations(iterations), residual(residual) {}
 
 
        operator Type() const {
            return value;
        }
 
        inline bool converged() const {
            return status == ConvergenceStatus::Success;
        }
 
        explicit operator bool() const {
            return converged();
        }
 
        inline Type safe() const {
 
            if(!converged()) {
                throw math_exception(
                    MathError::NoConvergence, "iter_result::safe()", __FILE__, __LINE__, false
                );
            }
 
            return value;
        }
 
 
        inline std::string status_string() const {
 
            switch(status) {
                case ConvergenceStatus::Success: 
                    return "Converged successfully";
                case ConvergenceStatus::MaxIterations:
                    return "Maximum iterations exceeded without converging to desired accuracy";
                case ConvergenceStatus:: Stalled:
                    return "Algorithm stalled";
                case ConvergenceStatus::InvalidInput:
                    return "Invalid input provided";
                case ConvergenceStatus::Diverged:
                    return "Algorithm diverged";
                default:
                    return "Unknown status";
            }
        }
 
        
#ifndef THEORETICA_NO_PRINT
 
        inline std::string to_string() const {
 
            std::stringstream res;
 
            res << "Value = " << value << "\n";
            res << "Status: " << status_string() << "\n";
            res << "Iterations = " << iterations << "\n";
            res << "Residual = " << residual;
 
            return res.str();
        }
 
 
        inline friend std::ostream& operator<<(std::ostream& out, const iter_result<Type>& obj) {
            return out << obj.to_string();
        }
 
#endif
 
    };
 
}
 
#endif