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

函数
Result< bool >	bool_failure (CasErrc code, std::string message, const char *operation)
Result< bool >	domain_contains_complex (NumberDomain domain, const ComplexNode &node)
Result< bool >	domain_contains_fractional_power (NumberDomain domain, const PowerNode &power, const Rational &exponent)
Result< bool >	domain_contains_function (NumberDomain domain, const FunctionNode &function)
Result< bool >	domain_contains_negative_integer_power (NumberDomain domain, const std::shared_ptr< const NumberNode > &base_number, const std::optional< Rational > &exact_base)
Result< bool >	domain_contains_node (NumberDomain domain, const std::shared_ptr< const SymbolicNode > &node)
Result< bool >	domain_contains_number (NumberDomain domain, const NumberNode &number)
Result< bool >	domain_contains_operands (NumberDomain domain, const std::vector< std::shared_ptr< const SymbolicNode > > &operands)
Result< bool >	domain_contains_positive_integer_power (NumberDomain domain, const PowerNode &power)
Result< bool >	domain_contains_power (NumberDomain domain, const PowerNode &power)
Result< bool >	domain_contains_root (NumberDomain domain, const std::shared_ptr< const SymbolicNode > &node)
int	domain_rank (NumberDomain domain) noexcept
bool	exact_sqrt_contains (NumberDomain domain, const Rational &value)
bool	function_preserves_domain (FunctionNode::FuncType type)
Result< bool >	inconclusive_domain ()
bool	is_undefined_zero_power (const Rational &exponent, const std::shared_ptr< const NumberNode > &base)

变量
constexpr const char *	kNumberDomainOperation = "LMCAS.number_domain"

函数说明

bool_failure()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::bool_failure	(	CasErrc	code,
		std::string	message,
		const char *	operation )

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

                                                 {
    return Result<bool>::failure(code, std::move(message), operation);
}

引用了 bool_failure() , 以及 LMCAS::Result< T >::failure().

被这些函数引用 bool_failure(), domain_contains_fractional_power(), domain_contains_node(), domain_contains_power() , 以及 inconclusive_domain().

函数调用图:

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

domain_contains_complex()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_complex	(	NumberDomain	domain,
		const ComplexNode &	node )

在文件 expr_number_domains.cpp 第 71 行定义.

                                                                                   {
    if (domain == NumberDomain::Complexes) {
        auto real = domain_contains_node(NumberDomain::Reals, node.real());
        if (!real) {
            return real;
        }
        auto imag = domain_contains_node(NumberDomain::Reals, node.imag());
        if (!imag) {
            return imag;
        }
        return Result<bool>::success(real.value() && imag.value());
    }
    if (!node.imag()->is_zero()) {
        return Result<bool>::success(false);
    }
    return domain_contains_node(domain, node.real());
}

引用了 LMCAS::Complexes, LMCAS::domain, domain_contains_complex(), domain_contains_node(), LMCAS::imag, LMCAS::SymbolicNode::is_zero(), LMCAS::real(), LMCAS::Reals, LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 domain_contains_complex() , 以及 domain_contains_node().

函数调用图:

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

domain_contains_fractional_power()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_fractional_power	(	NumberDomain	domain,
		const PowerNode &	power,
		const Rational &	exponent )

在文件 expr_number_domains.cpp 第 121 行定义.

                                                                           {
    auto base = detail::exact_rational_value(power.base());
    if (exponent == Rational(1, 2) && base) {
        return Result<bool>::success(exact_sqrt_contains(domain, *base));
    }
    return bool_failure(
        CasErrc::Inconclusive,
        "non-integer power membership requires a branch/domain proof",
        kNumberDomainOperation);
}

引用了 LMCAS::PowerNode::base(), bool_failure(), LMCAS::domain, domain_contains_fractional_power(), LMCAS::detail::exact_rational_value(), exact_sqrt_contains(), LMCAS::exponent, LMCAS::Inconclusive, kNumberDomainOperation , 以及 LMCAS::Result< T >::success().

被这些函数引用 domain_contains_fractional_power() , 以及 domain_contains_power().

函数调用图:

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

domain_contains_function()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_function	(	NumberDomain	domain,
		const FunctionNode &	function )

在文件 expr_number_domains.cpp 第 249 行定义.

                                                                                         {
    if (function.arguments().size() != 1) {
        return inconclusive_domain();
    }
    if (function.type() == FunctionNode::FuncType::Sqrt) {
        auto exact = detail::exact_rational_value(function.arguments()[0]);
        if (exact) {
            if (domain_rank(domain) >= 0) {
                return Result<bool>::success(exact_sqrt_contains(domain, *exact));
            }
            if (*exact < Rational(0)) {
                return Result<bool>::success(false);
            }
        }
    }
    if (function_preserves_domain(function.type())) {
        if (domain == NumberDomain::Integers ||
            domain == NumberDomain::Rationals) {
            return inconclusive_domain();
        }
        return domain_contains_node(
            domain == NumberDomain::Complexes ? NumberDomain::Complexes
                                               : NumberDomain::Reals,
            function.arguments()[0]);
    }
    return inconclusive_domain();
}

引用了 LMCAS::Complexes, LMCAS::domain, domain_contains_function(), domain_contains_node(), domain_rank(), LMCAS::detail::exact_rational_value(), exact_sqrt_contains(), LMCAS::function(), function_preserves_domain(), inconclusive_domain(), LMCAS::Integers, LMCAS::Rationals, LMCAS::Reals, LMCAS::FunctionNode::Sqrt , 以及 LMCAS::Result< T >::success().

被这些函数引用 domain_contains_function() , 以及 domain_contains_node().

函数调用图:

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

domain_contains_negative_integer_power()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_negative_integer_power	(	NumberDomain	domain,
		const std::shared_ptr< const NumberNode > &	base_number,
		const std::optional< Rational > &	exact_base )

在文件 expr_number_domains.cpp 第 139 行定义.

                                             {
    if (exact_base) {
        if (domain == NumberDomain::Integers) {
            return Result<bool>::success(
                exact_base->get_numerator().abs() == BigInt(1));
        }
        return Result<bool>::success(
            domain == NumberDomain::Rationals ||
            domain == NumberDomain::Reals ||
            domain == NumberDomain::Complexes);
    }
    if (base_number) {
        return domain_contains_number(domain, *base_number);
    }
    return inconclusive_domain();
}

引用了 LMCAS::Complexes, LMCAS::domain, domain_contains_negative_integer_power(), domain_contains_number(), inconclusive_domain(), LMCAS::Integers, LMCAS::Rationals, LMCAS::Reals , 以及 LMCAS::Result< T >::success().

被这些函数引用 domain_contains_negative_integer_power() , 以及 domain_contains_power().

函数调用图:

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

domain_contains_node()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_node	(	NumberDomain	domain,
		const std::shared_ptr< const SymbolicNode > &	node )

在文件 expr_number_domains.cpp 第 277 行定义.

                                                                        {
    if (!node) {
        return bool_failure(CasErrc::InvalidArgument,
                            "domain membership element must not be null",
                            kNumberDomainOperation);
    }
    if (domain == NumberDomain::Expressions) {
        return Result<bool>::success(true);
    }
    if (auto number = std::dynamic_pointer_cast<const NumberNode>(node)) {
        return domain_contains_number(domain, *number);
    }
    if (auto complex = std::dynamic_pointer_cast<const ComplexNode>(node)) {
        return domain_contains_complex(domain, *complex);
    }
    if (auto add = std::dynamic_pointer_cast<const AddNode>(node)) {
        return domain_contains_operands(domain, add->operands());
    }
    if (auto multiply = std::dynamic_pointer_cast<const MultiplyNode>(node)) {
        return domain_contains_operands(domain, multiply->operands());
    }
    if (auto power = std::dynamic_pointer_cast<const PowerNode>(node)) {
        return domain_contains_power(domain, *power);
    }
    if (std::dynamic_pointer_cast<const RootOfNode>(node)) {
        return domain_contains_root(domain, node);
    }
    if (auto function = std::dynamic_pointer_cast<const FunctionNode>(node)) {
        return domain_contains_function(domain, *function);
    }
    return inconclusive_domain();
}

引用了 LMCAS::add(), bool_failure(), LMCAS::complex(), LMCAS::domain, domain_contains_complex(), domain_contains_function(), domain_contains_node(), domain_contains_number(), domain_contains_operands(), domain_contains_power(), domain_contains_root(), LMCAS::Expressions, LMCAS::function(), inconclusive_domain(), LMCAS::InvalidArgument, kNumberDomainOperation , 以及 LMCAS::Result< T >::success().

被这些函数引用 domain_contains_complex(), domain_contains_function(), domain_contains_node(), domain_contains_operands() , 以及 domain_contains_positive_integer_power().

函数调用图:

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

domain_contains_number()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_number	(	NumberDomain	domain,
		const NumberNode &	number )

在文件 expr_number_domains.cpp 第 54 行定义.

                                                                                   {
    const auto& value = number.value();
    if (std::holds_alternative<BigInt>(value)) {
        return Result<bool>::success(true);
    }
    if (std::holds_alternative<Rational>(value)) {
        const auto& rational = std::get<Rational>(value);
        if (domain == NumberDomain::Integers) {
            return Result<bool>::success(rational.is_integer());
        }
        if (domain_rank(domain) >= 0) {
            return Result<bool>::success(true);
        }
    }
    return inconclusive_domain();
}

引用了 LMCAS::domain, domain_contains_number(), domain_rank(), inconclusive_domain(), LMCAS::Integers, LMCAS::rational(), LMCAS::Result< T >::success(), LMCAS::NumberNode::value() , 以及 LMCAS::value.

被这些函数引用 domain_contains_negative_integer_power(), domain_contains_node() , 以及 domain_contains_number().

函数调用图:

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

domain_contains_operands()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_operands	(	NumberDomain	domain,
		const std::vector< std::shared_ptr< const SymbolicNode > > &	operands )

在文件 expr_number_domains.cpp 第 89 行定义.

                                                                  {
    bool all_members = true;
    for (const auto& operand : operands) {
        auto member = domain_contains_node(domain, operand);
        if (!member) {
            if (member.error().code != CasErrc::Inconclusive) {
                return member;
            }
            all_members = false;
            continue;
        }
        all_members = all_members && member.value();
    }
    return all_members ? Result<bool>::success(true) : inconclusive_domain();
}

引用了 LMCAS::CasError::code, LMCAS::domain, domain_contains_node(), domain_contains_operands(), LMCAS::Result< T >::error(), LMCAS::Inconclusive, inconclusive_domain(), LMCAS::member(), LMCAS::Result< T >::success() , 以及 LMCAS::Result< T >::value().

被这些函数引用 domain_contains_node() , 以及 domain_contains_operands().

函数调用图:

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

domain_contains_positive_integer_power()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_positive_integer_power	(	NumberDomain	domain,
		const PowerNode &	power )

在文件 expr_number_domains.cpp 第 159 行定义.

                                                 {
    auto base = domain_contains_node(domain, power.base());
    if (!base) {
        return base.error().code == CasErrc::Inconclusive
            ? inconclusive_domain()
            : Result<bool>::failure(base.error());
    }
    return base.value() ? Result<bool>::success(true) : inconclusive_domain();
}

引用了 LMCAS::PowerNode::base(), LMCAS::domain, domain_contains_node(), domain_contains_positive_integer_power(), LMCAS::Result< T >::failure(), LMCAS::Inconclusive, inconclusive_domain() , 以及 LMCAS::Result< T >::success().

被这些函数引用 domain_contains_positive_integer_power() , 以及 domain_contains_power().

函数调用图:

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

domain_contains_power()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_power	(	NumberDomain	domain,
		const PowerNode &	power )

在文件 expr_number_domains.cpp 第 170 行定义.

                                                                                {
    const auto exponent = detail::exact_rational_value(power.exponent());
    if (!exponent) {
        return bool_failure(
            CasErrc::Inconclusive,
            "domain membership for powers requires an exact exponent",
            kNumberDomainOperation);
    }
    if (!exponent->is_integer()) {
        return domain_contains_fractional_power(domain, power, *exponent);
    }
 
    const auto base_number =
        std::dynamic_pointer_cast<const NumberNode>(power.base());
    const auto exact_base = detail::exact_rational_value(power.base());
    if (is_undefined_zero_power(*exponent, base_number)) {
        return bool_failure(
            CasErrc::DomainError,
            "zero to a nonpositive integer power is undefined",
            kNumberDomainOperation);
    }
    if (exponent->is_zero()) {
        return base_number ? Result<bool>::success(true)
                           : inconclusive_domain();
    }
    if (*exponent < Rational(0)) {
        return domain_contains_negative_integer_power(
            domain, base_number, exact_base);
    }
    return domain_contains_positive_integer_power(domain, power);
}

引用了 LMCAS::PowerNode::base(), bool_failure(), LMCAS::domain, domain_contains_fractional_power(), domain_contains_negative_integer_power(), domain_contains_positive_integer_power(), domain_contains_power(), LMCAS::DomainError, LMCAS::detail::exact_rational_value(), LMCAS::exponent, LMCAS::PowerNode::exponent(), LMCAS::Inconclusive, inconclusive_domain(), is_undefined_zero_power(), kNumberDomainOperation , 以及 LMCAS::Result< T >::success().

被这些函数引用 domain_contains_node() , 以及 domain_contains_power().

函数调用图:

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

domain_contains_root()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_contains_root	(	NumberDomain	domain,
		const std::shared_ptr< const SymbolicNode > &	node )

在文件 expr_number_domains.cpp 第 202 行定义.

                                                                        {
    auto expression = detail::make_expression_ptr(node);
    if (domain == NumberDomain::Complexes) {
        auto value = rootof_evaluate_complex_checked(expression);
        return value ? Result<bool>::success(true)
                     : Result<bool>::failure(value.error());
    }
    ComputationContext context;
    auto value = rootof_evaluate_checked(expression, context);
    if (value) {
        return Result<bool>::success(domain == NumberDomain::Reals);
    }
    if (value.error().code == CasErrc::DomainError) {
        return Result<bool>::success(false);
    }
    return Result<bool>::failure(value.error());
}

引用了 LMCAS::Complexes, LMCAS::context, LMCAS::domain, domain_contains_root(), LMCAS::DomainError, LMCAS::Result< T >::failure(), LMCAS::detail::make_expression_ptr(), LMCAS::Reals, LMCAS::rootof_evaluate_checked(), LMCAS::rootof_evaluate_complex_checked(), LMCAS::Result< T >::success() , 以及 LMCAS::value.

被这些函数引用 domain_contains_node() , 以及 domain_contains_root().

函数调用图:

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

domain_rank()

int LMCAS::anonymous_namespace{expr_number_domains.cpp}::domain_rank ( NumberDomain domain )

noexcept

在文件 expr_number_domains.cpp 第 30 行定义.

                                              {
    switch (domain) {
    case NumberDomain::Integers: {
        return 0;
    }
    case NumberDomain::Rationals: {
        return 1;
    }
    case NumberDomain::Reals: {
        return 2;
    }
    case NumberDomain::Complexes: {
        return 3;
    }
    case NumberDomain::Expressions: {
        return 4;
    }
    }
    return -1;
}

引用了 LMCAS::Complexes, LMCAS::domain, domain_rank(), LMCAS::Expressions, LMCAS::Integers, LMCAS::Rationals , 以及 LMCAS::Reals.

被这些函数引用 domain_contains_function(), domain_contains_number() , 以及 domain_rank().

函数调用图:

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

exact_sqrt_contains()

bool LMCAS::anonymous_namespace{expr_number_domains.cpp}::exact_sqrt_contains	(	NumberDomain	domain,
		const Rational &	value )

在文件 expr_number_domains.cpp 第 107 行定义.

                                                                     {
    if (value < Rational(0)) {
        return domain == NumberDomain::Complexes;
    }
    if (domain == NumberDomain::Reals || domain == NumberDomain::Complexes) {
        return true;
    }
    const bool rational_root = value.get_numerator().is_perfect_square() &&
                               value.get_denominator().is_perfect_square();
    return domain == NumberDomain::Rationals
        ? rational_root
        : rational_root && value.get_denominator() == BigInt(1);
}

引用了 LMCAS::Complexes, LMCAS::domain, exact_sqrt_contains(), LMCAS::Rationals, LMCAS::Reals , 以及 LMCAS::value.

被这些函数引用 domain_contains_fractional_power(), domain_contains_function() , 以及 exact_sqrt_contains().

函数调用图:

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

function_preserves_domain()

bool LMCAS::anonymous_namespace{expr_number_domains.cpp}::function_preserves_domain

(

FunctionNode::FuncType

type

)

在文件 expr_number_domains.cpp 第 221 行定义.

                                                          {
    switch (type) {
        case FunctionNode::FuncType::Sin: {
            return true;
        }
        case FunctionNode::FuncType::Cos: {
            return true;
        }
        case FunctionNode::FuncType::Exp: {
            return true;
        }
        case FunctionNode::FuncType::Sinh: {
            return true;
        }
        case FunctionNode::FuncType::Cosh: {
            return true;
        }
        case FunctionNode::FuncType::Tanh: {
            return true;
        }
        case FunctionNode::FuncType::Abs: {
            return true;
        }
        default:
            return false;
    }
}

引用了 LMCAS::FunctionNode::Abs, LMCAS::FunctionNode::Cos, LMCAS::FunctionNode::Cosh, LMCAS::FunctionNode::Exp, function_preserves_domain(), LMCAS::FunctionNode::Sin, LMCAS::FunctionNode::Sinh , 以及 LMCAS::FunctionNode::Tanh.

被这些函数引用 domain_contains_function() , 以及 function_preserves_domain().

函数调用图:

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

inconclusive_domain()

Result< bool > LMCAS::anonymous_namespace{expr_number_domains.cpp}::inconclusive_domain

(

)

在文件 expr_number_domains.cpp 第 23 行定义.

                                   {
    return bool_failure(CasErrc::Inconclusive,
                        "domain membership is only decidable for numeric and explicit complex expressions",
                        kNumberDomainOperation);
}

引用了 bool_failure(), LMCAS::Inconclusive, inconclusive_domain() , 以及 kNumberDomainOperation.

被这些函数引用 domain_contains_function(), domain_contains_negative_integer_power(), domain_contains_node(), domain_contains_number(), domain_contains_operands(), domain_contains_positive_integer_power(), domain_contains_power() , 以及 inconclusive_domain().

函数调用图:

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

is_undefined_zero_power()

bool LMCAS::anonymous_namespace{expr_number_domains.cpp}::is_undefined_zero_power	(	const Rational &	exponent,
		const std::shared_ptr< const NumberNode > &	base )

在文件 expr_number_domains.cpp 第 133 行定义.

                                                 {
    return exponent <= Rational(0) && base && base->is_zero();
}

引用了 LMCAS::exponent , 以及 is_undefined_zero_power().

被这些函数引用 domain_contains_power() , 以及 is_undefined_zero_power().

函数调用图:

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

变量说明

kNumberDomainOperation

const char* LMCAS::anonymous_namespace{expr_number_domains.cpp}::kNumberDomainOperation = "LMCAS.number_domain"

constexpr

在文件 expr_number_domains.cpp 第 16 行定义.

被这些函数引用 domain_contains_fractional_power(), domain_contains_node(), domain_contains_power() , 以及 inconclusive_domain().