expr_values.cpp

浏览该文件的文档.

#include "expr.hpp"
#include "internal/symbolic_ast.hpp"
#include "internal/expr_common.hpp"
#include "internal/expression_analysis.hpp"
#include "internal/expression_construction.hpp"
#include <cmath>
#include <exception>
#include <memory>
#include <string>
#include <utility>
 
namespace LMCAS {
 
using namespace expr_detail::expr_common;
 
std::optional<std::string_view> symbol_name(const ExprPtr& expression) noexcept {
    const auto* variable =
        dynamic_cast<const VariableNode*>(detail::node(expression).get());
    if (!variable || variable->is_constant()) return std::nullopt;
    return variable->name();
}
 
std::optional<RelationOp> relation_op(const ExprPtr& expression) noexcept {
    const auto* relation =
        dynamic_cast<const RelationalNode*>(detail::node(expression).get());
    if (!relation) return std::nullopt;
    return relation->op();
}
 
ExprResult sym(const std::string& name) {
    if (name.empty()) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "symbol name cannot be empty", kSymOperation);
    }
    if (is_reserved_symbol_name(name)) {
        if (detail::is_imaginary_unit_name(name)) {
            return expression_failure(CasErrc::InvalidArgument,
                                      "imaginary unit symbol is reserved",
                                      kSymOperation);
        }
        return expression_failure(CasErrc::InvalidArgument,
                                  "reserved mathematical constants cannot be shadowed",
                                  kSymOperation);
    }
    try {
        auto expression = SymbolicExpr::variable(name);
        if (!expression) {
            return expression_failure(CasErrc::InternalInvariant,
                                      "symbol factory returned null", kSymOperation);
        }
        return ExprResult::success(std::move(expression));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "symbol allocation failed", kSymOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kSymOperation);
    }
}
 
ExprResult integer(int value) {
    try {
        return ExprResult::success(SymbolicExpr::number(value));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "integer allocation failed", kIntegerOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kIntegerOperation);
    }
}
 
ExprResult integer(const BigInt& value) {
    try {
        return ExprResult::success(SymbolicExpr::number(value));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "integer allocation failed", kIntegerOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kIntegerOperation);
    }
}
 
ExprResult rational(const Rational& value) {
    try {
        return ExprResult::success(SymbolicExpr::number(value));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "rational allocation failed", kRationalOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kRationalOperation);
    }
}
 
ExprResult approx_real(double value) {
    if (!std::isfinite(value)) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "approximate real must be finite", kApproxOperation);
    }
    try {
        return ExprResult::success(SymbolicExpr::number(value));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "approximate real allocation failed", kApproxOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(), kApproxOperation);
    }
}
 
ExprResult pi() {
    return detail::constant_expression("pi");
}
 
ExprResult e() {
    return detail::constant_expression("e");
}
 
ExprResult phi() {
    return detail::constant_expression("phi");
}
 
ExprResult imaginary_unit() {
    auto zero = integer(0);
    if (!zero) return ExprResult::failure(zero.error());
    auto one = integer(1);
    if (!one) return ExprResult::failure(one.error());
    return complex(zero.value(), one.value());
}
 
ExprResult complex(ExprPtr real, ExprPtr imag) {
    if (!real || !imag) {
        return expression_failure(CasErrc::InvalidArgument,
                                  "complex expression parts cannot be null",
                                  kComplexOperation);
    }
    try {
        auto node = SymbolicFactory::create_complex(LMCAS::detail::node(real),
                                                    LMCAS::detail::node(imag));
        return ExprResult::success(LMCAS::detail::make_expression_ptr(std::move(node)));
    } catch (const std::bad_alloc&) {
        return expression_failure(CasErrc::ResourceLimit,
                                  "complex expression allocation failed",
                                  kComplexOperation);
    } catch (const std::exception& error) {
        return expression_failure(CasErrc::InternalInvariant, error.what(),
                                  kComplexOperation);
    }
}
 
}