LMCAS::detail::anonymous_namespace{complex_quadratic.cpp} 命名空间参考

类
struct	CartesianNodes

类型定义
using	Coefficients = std::array<std::shared_ptr<SymbolicExpr>, 3>
using	Node = std::shared_ptr<const SymbolicNode>

函数
Node	add (const Node &left, const Node &right)
CartesianNodes	cartesian_add (const CartesianNodes &left, const CartesianNodes &right)
CartesianNodes	cartesian_multiply (const CartesianNodes &left, const CartesianNodes &right)
Result< CartesianQuadraticRoots >	construct_roots (const Coefficients &coefficients, const Node &delta, bool negative, ComputationContext &context)
Node	divide (const Node &numerator, const Node &denominator)
Node	integer (int value)
Node	multiply (const Node &left, const Node &right)
Node	negate (const Node &value)
Result< bool >	negative_discriminant (const SymbolicExpr &delta, const AssumptionContext &facts, ComputationContext &context)
ExpressionResult	normalize (const Node &value, ComputationContext &context)
Result< Coefficients >	normalize_coefficients (const Coefficients &input, ComputationContext &context)
Result< QuadraticCartesianRoot >	normalized_root (const Node &real, const Node &imag, ComputationContext &context)
Result< void >	prove_coefficients (const Coefficients &coefficients, const AssumptionContext &facts, ComputationContext &context)
Result< void >	prove_zero (const Node &residual, ComputationContext &context)
Result< CartesianQuadraticRoots >	solve_real_quadratic (const Coefficients &coefficients, const AssumptionContext &facts, ComputationContext &context)
Result< void >	verify_root (const Coefficients &coefficients, const QuadraticCartesianRoot &root, ComputationContext &context)

变量
constexpr const char *	kOperation = "solve_complex_quadratic"

---

类说明

LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::CartesianNodes

struct LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::CartesianNodes

在文件 complex_quadratic.cpp 第 185 行定义.

LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::CartesianNodes 的协作图:

类成员
Node	imag
Node	real

类型定义说明

Coefficients

using LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::Coefficients = std::array<std::shared_ptr<SymbolicExpr>, 3>

在文件 complex_quadratic.cpp 第 19 行定义.

Node

using LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::Node = std::shared_ptr<const SymbolicNode>

在文件 complex_quadratic.cpp 第 18 行定义.

函数说明

add()

Node LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::add	(	const Node &	left,
		const Node &	right )

在文件 complex_quadratic.cpp 第 25 行定义.

                                              {
    return SymbolicFactory::create_add({left, right});
}

引用了 add(), LMCAS::SymbolicFactory::create_add() , 以及 LMCAS::right.

被这些函数引用 add(), cartesian_add(), cartesian_multiply(), construct_roots() , 以及 solve_real_quadratic().

函数调用图:

这是这个函数的调用关系图:

cartesian_add()

CartesianNodes LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::cartesian_add	(	const CartesianNodes &	left,
		const CartesianNodes &	right )

在文件 complex_quadratic.cpp 第 190 行定义.

                                                                                      {
    return {add(left.real, right.real), add(left.imag, right.imag)};
}

引用了 add(), cartesian_add(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::CartesianNodes::imag, LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::CartesianNodes::real , 以及 LMCAS::right.

被这些函数引用 cartesian_add() , 以及 verify_root().

函数调用图:

这是这个函数的调用关系图:

cartesian_multiply()

CartesianNodes LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::cartesian_multiply	(	const CartesianNodes &	left,
		const CartesianNodes &	right )

在文件 complex_quadratic.cpp 第 194 行定义.

                                                                                           {
    return {add(multiply(left.real, right.real), negate(multiply(left.imag, right.imag))),
            add(multiply(left.real, right.imag), multiply(left.imag, right.real))};
}

引用了 add(), cartesian_multiply(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::CartesianNodes::imag, multiply(), negate(), LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::CartesianNodes::real , 以及 LMCAS::right.

被这些函数引用 cartesian_multiply() , 以及 verify_root().

函数调用图:

这是这个函数的调用关系图:

construct_roots()

Result< CartesianQuadraticRoots > LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::construct_roots	(	const Coefficients &	coefficients,
		const Node &	delta,
		bool	negative,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 161 行定义.

                                 {
    const auto denominator = multiply(integer(2), node(coefficients[0]));
    const auto minus_b = negate(node(coefficients[1]));
    const auto radical = SymbolicFactory::create_power(
        negative ? negate(delta) : delta, SymbolicFactory::create_number(Rational(1, 2)));
    const auto real = divide(minus_b, denominator);
    const auto imag = divide(radical, denominator);
    auto first = normalized_root(
        negative ? real : add(real, imag),
        negative ? imag : integer(0), context);
    if (!first) {
        return Result<CartesianQuadraticRoots>::failure(first.error());
    }
    auto second = normalized_root(
        negative ? real : add(real, negate(imag)),
        negative ? negate(imag) : integer(0), context);
    if (!second) {
        return Result<CartesianQuadraticRoots>::failure(second.error());
    }
    return CartesianQuadraticRoots{std::move(first.value()), std::move(second.value())};
}

引用了 add(), construct_roots(), LMCAS::detail::context, LMCAS::SymbolicFactory::create_number(), LMCAS::SymbolicFactory::create_power(), LMCAS::denominator, divide(), LMCAS::Result< T >::failure(), LMCAS::imag, integer(), multiply(), negate(), LMCAS::detail::node(), normalized_root() , 以及 LMCAS::real().

被这些函数引用 construct_roots() , 以及 solve_real_quadratic().

函数调用图:

这是这个函数的调用关系图:

divide()

Node LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::divide	(	const Node &	numerator,
		const Node &	denominator )

在文件 complex_quadratic.cpp 第 37 行定义.

                                                            {
    return multiply(numerator, SymbolicFactory::create_power(denominator, integer(-1)));
}

引用了 LMCAS::SymbolicFactory::create_power(), LMCAS::denominator, divide(), integer() , 以及 multiply().

被这些函数引用 construct_roots() , 以及 divide().

函数调用图:

这是这个函数的调用关系图:

integer()

Node LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::integer

(

int

value

)

在文件 complex_quadratic.cpp 第 21 行定义.

                        {
    return SymbolicFactory::create_number(BigInt(value));
}

引用了 LMCAS::SymbolicFactory::create_number(), integer() , 以及 LMCAS::value.

被这些函数引用 construct_roots(), divide(), integer(), negate(), solve_real_quadratic() , 以及 verify_root().

函数调用图:

这是这个函数的调用关系图:

multiply()

Node LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::multiply	(	const Node &	left,
		const Node &	right )

在文件 complex_quadratic.cpp 第 29 行定义.

                                                   {
    return SymbolicFactory::create_multiply({left, right});
}

引用了 LMCAS::SymbolicFactory::create_multiply(), multiply() , 以及 LMCAS::right.

被这些函数引用 cartesian_multiply(), construct_roots(), divide(), multiply(), negate() , 以及 solve_real_quadratic().

函数调用图:

这是这个函数的调用关系图:

negate()

Node LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::negate

(

const Node &

value

)

在文件 complex_quadratic.cpp 第 33 行定义.

                               {
    return multiply(integer(-1), value);
}

引用了 integer(), multiply(), negate() , 以及 LMCAS::value.

被这些函数引用 cartesian_multiply(), construct_roots(), negate() , 以及 solve_real_quadratic().

函数调用图:

这是这个函数的调用关系图:

negative_discriminant()

Result< bool > LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::negative_discriminant	(	const SymbolicExpr &	delta,
		const AssumptionContext &	facts,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 123 行定义.

                                                                {
    auto step = context.consume_steps(2, kOperation);
    if (!step) {
        return Result<bool>::failure(step.error());
    }
    auto nonnegative = facts.is_nonnegative_checked(delta, context);
    if (!nonnegative) {
        return Result<bool>::failure(nonnegative.error());
    }
    if (nonnegative.value() == Tribool::True) {
        return false;
    }
    auto negative = facts.is_negative_checked(delta, context);
    if (!negative) {
        return Result<bool>::failure(negative.error());
    }
    if (negative.value() == Tribool::True) {
        return true;
    }
    return Result<bool>::failure(CasErrc::Inconclusive,
        "quadratic discriminant sign is unknown", kOperation);
}

引用了 LMCAS::detail::context, LMCAS::detail::facts, LMCAS::Result< T >::failure(), LMCAS::Inconclusive, kOperation, negative_discriminant() , 以及 LMCAS::True.

被这些函数引用 negative_discriminant() , 以及 solve_real_quadratic().

函数调用图:

这是这个函数的调用关系图:

normalize()

ExpressionResult LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize	(	const Node &	value,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 41 行定义.

                                                                           {
    auto step = context.consume_steps(1, kOperation);
    if (!step) {
        return ExpressionResult::failure(step.error());
    }
    RewriteBudget budget(context, context.limits().max_recursion_depth,
                         context.limits().max_ast_nodes, kOperation);
    budget.measure(value);
    std::optional<AssumptionFacts> facts;
    if (context.assumptions()) facts.emplace(*context.assumptions());
    NormalizationVisitor visitor(budget, facts ? static_cast<const FactsQuery&>(*facts)
                                       : no_facts(), Domain::Real);
    value->accept(visitor);
    auto result = visitor.get_result();
    if (!result) {
        return ExpressionResult::failure(CasErrc::InternalInvariant,
            "quadratic normalization returned null", kOperation);
    }
    budget.measure(result);
    return make_expression_ptr(std::move(result));
}

引用了 LMCAS::detail::budget, LMCAS::detail::context, LMCAS::detail::facts, LMCAS::Result< std::shared_ptr< SymbolicExpr > >::failure(), LMCAS::NormalizationVisitor::get_result(), LMCAS::InternalInvariant, kOperation, LMCAS::detail::make_expression_ptr(), LMCAS::detail::RewriteBudget::measure(), LMCAS::detail::no_facts(), normalize(), LMCAS::Real , 以及 LMCAS::value.

被这些函数引用 normalize(), normalize_coefficients(), normalized_root(), prove_zero() , 以及 solve_real_quadratic().

函数调用图:

这是这个函数的调用关系图:

normalize_coefficients()

Result< Coefficients > LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalize_coefficients	(	const Coefficients &	input,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 63 行定义.

                                                            {
    for (const auto& coefficient : input) {
        auto step = context.consume_steps(1, kOperation);
        if (!step) {
            return Result<Coefficients>::failure(step.error());
        }
        if (!coefficient || !node(coefficient)) {
            return Result<Coefficients>::failure(CasErrc::InvalidArgument,
                "quadratic coefficients must not be null", kOperation);
        }
    }
    Coefficients result;
    for (std::size_t i = 0; i < input.size(); ++i) {
        auto simplified = normalize(node(input[i]), context);
        if (!simplified) {
            return Result<Coefficients>::failure(simplified.error());
        }
        result[i] = std::move(simplified.value());
    }
    return result;
}

引用了 LMCAS::detail::context, LMCAS::Result< T >::failure(), LMCAS::InvalidArgument, kOperation, LMCAS::detail::node(), normalize() , 以及 normalize_coefficients().

被这些函数引用 normalize_coefficients().

函数调用图:

这是这个函数的调用关系图:

normalized_root()

Result< QuadraticCartesianRoot > LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::normalized_root	(	const Node &	real,
		const Node &	imag,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 148 行定义.

                                                                     {
    auto real_part = normalize(real, context);
    if (!real_part) {
        return Result<QuadraticCartesianRoot>::failure(real_part.error());
    }
    auto imag_part = normalize(imag, context);
    if (!imag_part) {
        return Result<QuadraticCartesianRoot>::failure(imag_part.error());
    }
    return QuadraticCartesianRoot{std::move(real_part.value()), std::move(imag_part.value())};
}

引用了 LMCAS::detail::context, LMCAS::Result< T >::failure(), LMCAS::imag, normalize(), normalized_root() , 以及 LMCAS::real().

被这些函数引用 construct_roots() , 以及 normalized_root().

函数调用图:

这是这个函数的调用关系图:

prove_coefficients()

Result< void > LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::prove_coefficients	(	const Coefficients &	coefficients,
		const AssumptionContext &	facts,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 86 行定义.

                                                             {
    auto step = context.consume_steps(4, kOperation);
    if (!step) {
        return step;
    }
    if (node(coefficients[0])->is_zero()) {
        return Result<void>::failure(CasErrc::DomainError,
            "quadratic leading coefficient is zero", kOperation);
    }
    AssumptionFacts adapter(facts);
    for (const auto& coefficient : coefficients) {
        auto real = query_real_value(node(coefficient), adapter, context);
        if (!real) {
            return Result<void>::failure(real.error());
        }
        if (real.value() != Tribool::True) {
            return Result<void>::failure(CasErrc::UnsupportedExpression,
                "quadratic coefficients must be provably real", kOperation);
        }
    }
    auto nonzero = facts.is_nonzero_checked(*coefficients[0], context);
    if (!nonzero) {
        return Result<void>::failure(nonzero.error());
    }
    if (nonzero.value() == Tribool::False) {
        return Result<void>::failure(CasErrc::DomainError,
            "quadratic leading coefficient is zero", kOperation);
    }
    if (nonzero.value() != Tribool::True) {
        return Result<void>::failure(CasErrc::Inconclusive,
            "quadratic leading coefficient is not provably nonzero", kOperation);
    }
    return Result<void>::success();
}

引用了 LMCAS::detail::context, LMCAS::DomainError, LMCAS::Result< T >::error(), LMCAS::detail::facts, LMCAS::Result< T >::failure(), LMCAS::False, LMCAS::Inconclusive, kOperation, LMCAS::detail::node(), prove_coefficients(), LMCAS::detail::query_real_value(), LMCAS::real(), LMCAS::Result< T >::success(), LMCAS::True, LMCAS::UnsupportedExpression , 以及 LMCAS::Result< T >::value().

被这些函数引用 prove_coefficients() , 以及 solve_real_quadratic().

函数调用图:

这是这个函数的调用关系图:

prove_zero()

Result< void > LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::prove_zero	(	const Node &	residual,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 199 行定义.

                                                                           {
    auto simplified = normalize(residual, context);
    if (!simplified) {
        return Result<void>::failure(simplified.error());
    }
    auto proof = check_zero_residual(simplified.value(), context);
    if (!proof) {
        return Result<void>::failure(proof.error());
    }
    if (!std::holds_alternative<ProvedZeroResidual>(proof.value())) {
        return Result<void>::failure(CasErrc::Inconclusive,
            "quadratic Cartesian residual could not be proved zero", kOperation);
    }
    return Result<void>::success();
}

引用了 LMCAS::check_zero_residual(), LMCAS::detail::context, LMCAS::Result< T >::failure(), LMCAS::Inconclusive, kOperation, normalize(), prove_zero() , 以及 LMCAS::Result< T >::success().

被这些函数引用 prove_zero() , 以及 verify_root().

函数调用图:

这是这个函数的调用关系图:

solve_real_quadratic()

Result< CartesianQuadraticRoots > LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::solve_real_quadratic	(	const Coefficients &	coefficients,
		const AssumptionContext &	facts,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 236 行定义.

                                 {
    auto valid = prove_coefficients(coefficients, facts, context);
    if (!valid) {
        return Result<CartesianQuadraticRoots>::failure(valid.error());
    }
    const auto b = node(coefficients[1]);
    auto delta = normalize(add(multiply(b, b), negate(multiply(integer(4),
        multiply(node(coefficients[0]), node(coefficients[2]))))), context);
    if (!delta) {
        return Result<CartesianQuadraticRoots>::failure(delta.error());
    }
    auto negative = negative_discriminant(*delta.value(), facts, context);
    if (!negative) {
        return Result<CartesianQuadraticRoots>::failure(negative.error());
    }
    auto roots = construct_roots(coefficients, node(delta.value()), negative.value(), context);
    if (!roots) {
        return roots;
    }
    for (const auto& root : roots.value()) {
        auto verified = verify_root(coefficients, root, context);
        if (!verified) {
            return Result<CartesianQuadraticRoots>::failure(verified.error());
        }
    }
    return roots;
}

引用了 add(), LMCAS::b, construct_roots(), LMCAS::detail::context, LMCAS::detail::facts, LMCAS::Result< T >::failure(), integer(), multiply(), negate(), negative_discriminant(), LMCAS::detail::node(), normalize(), prove_coefficients(), LMCAS::roots(), solve_real_quadratic(), LMCAS::Result< T >::value() , 以及 verify_root().

被这些函数引用 solve_real_quadratic().

函数调用图:

这是这个函数的调用关系图:

verify_root()

Result< void > LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::verify_root	(	const Coefficients &	coefficients,
		const QuadraticCartesianRoot &	root,
		ComputationContext &	context )

在文件 complex_quadratic.cpp 第 215 行定义.

                                                      {
    auto step = context.consume_steps(16, kOperation);
    if (!step) {
        return step;
    }
    const auto zero = integer(0);
    const CartesianNodes a{node(coefficients[0]), zero};
    const CartesianNodes b{node(coefficients[1]), zero};
    const CartesianNodes c{node(coefficients[2]), zero};
    const CartesianNodes z{node(root.real), node(root.imag)};
    const auto residual = cartesian_add(
        cartesian_multiply(cartesian_add(cartesian_multiply(a, z), b), z), c);
    auto real = prove_zero(residual.real, context);
    if (!real) {
        return real;
    }
    return prove_zero(residual.imag, context);
}

引用了 LMCAS::a, LMCAS::b, LMCAS::c, cartesian_add(), cartesian_multiply(), LMCAS::detail::context, LMCAS::detail::QuadraticCartesianRoot::imag, integer(), kOperation, LMCAS::detail::node(), prove_zero(), LMCAS::detail::QuadraticCartesianRoot::real, LMCAS::real() , 以及 verify_root().

被这些函数引用 solve_real_quadratic() , 以及 verify_root().

函数调用图:

这是这个函数的调用关系图:

变量说明

kOperation

const char* LMCAS::detail::anonymous_namespace{complex_quadratic.cpp}::kOperation = "solve_complex_quadratic"

constexpr

在文件 complex_quadratic.cpp 第 17 行定义.

被这些函数引用 negative_discriminant(), normalize(), normalize_coefficients(), prove_coefficients(), prove_zero() , 以及 verify_root().