ScalarFormat.hpp

Go to the documentation of this file.

#pragma once

 
#include <icarus/core/CoreTypes.hpp>
 
#include <iomanip>
#include <sstream>
#include <string>
 
namespace icarus::io {

template <typename Scalar> struct ScalarFormatter {
    static std::string format(const Scalar &value, int precision = 6) {
        std::ostringstream ss;
        ss << std::setprecision(precision) << value;
        return ss.str();
    }
 
    static std::string format_fixed(const Scalar &value, int precision = 6) {
        std::ostringstream ss;
        ss << std::fixed << std::setprecision(precision) << value;
        return ss.str();
    }
 
    static std::string format_scientific(const Scalar &value, int precision = 6) {
        std::ostringstream ss;
        ss << std::scientific << std::setprecision(precision) << value;
        return ss.str();
    }
};

template <> struct ScalarFormatter<double> {
    static std::string format(const double &value, int precision = 6) {
        std::ostringstream ss;
        ss << std::setprecision(precision) << value;
        return ss.str();
    }
 
    static std::string format_fixed(const double &value, int precision = 6) {
        std::ostringstream ss;
        ss << std::fixed << std::setprecision(precision) << value;
        return ss.str();
    }
 
    static std::string format_scientific(const double &value, int precision = 6) {
        std::ostringstream ss;
        ss << std::scientific << std::setprecision(precision) << value;
        return ss.str();
    }

    static constexpr bool is_numeric() { return true; }
};

template <> struct ScalarFormatter<SymbolicScalar> {
    static std::string format(const SymbolicScalar &value, int /*precision*/ = 6) {
        std::ostringstream ss;
        ss << value;
        return ss.str();
    }
 
    static std::string format_fixed(const SymbolicScalar &value, int /*precision*/ = 6) {
        return format(value); // No special formatting for symbolic
    }
 
    static std::string format_scientific(const SymbolicScalar &value, int /*precision*/ = 6) {
        return format(value); // No special formatting for symbolic
    }

    static constexpr bool is_numeric() { return false; }

    static bool is_constant(const SymbolicScalar &value) { return value.is_constant(); }

    static double get_constant(const SymbolicScalar &value) {
        return static_cast<double>(casadi::DM(value));
    }
};
 
// =============================================================================
// Convenience Functions
// =============================================================================

template <typename Scalar> inline std::string FormatScalar(const Scalar &value, int precision = 6) {
    return ScalarFormatter<Scalar>::format(value, precision);
}

template <typename Scalar>
inline std::string FormatScalarFixed(const Scalar &value, int precision = 6) {
    return ScalarFormatter<Scalar>::format_fixed(value, precision);
}

template <typename Scalar>
inline std::string FormatScalarScientific(const Scalar &value, int precision = 6) {
    return ScalarFormatter<Scalar>::format_scientific(value, precision);
}

template <typename Scalar> constexpr bool IsNumericScalar() {
    return ScalarFormatter<Scalar>::is_numeric();
}

template <typename Scalar> bool CanEvaluateToDouble(const Scalar &value) {
    if constexpr (std::is_same_v<Scalar, double>) {
        (void)value; // Unused
        return true;
    } else if constexpr (std::is_same_v<Scalar, SymbolicScalar>) {
        return value.is_constant();
    } else {
        (void)value;
        return false;
    }
}

template <typename Scalar> double EvaluateToDouble(const Scalar &value, double default_val = 0.0) {
    if constexpr (std::is_same_v<Scalar, double>) {
        return value;
    } else if constexpr (std::is_same_v<Scalar, SymbolicScalar>) {
        if (value.is_constant()) {
            return static_cast<double>(casadi::DM(value));
        }
        return default_val;
    } else {
        (void)value;
        return default_val;
    }
}
 
} // namespace icarus::io