函数
std::string	boundedness_to_string (Boundedness b)
std::string	definiteness_to_string (Definiteness d)
std::string	endpoint_to_string (const Endpoint &ep)
std::string	finiteness_to_string (Finiteness f)
std::string	interval_to_string (const Interval &iv)
std::string	monotonicity_to_string (Monotonicity m)
std::string	parity_to_string (Parity p)
std::string	relop_to_string (RelationalNode::Op op)
void	serialize_symbol_intervals (std::ostream &out, const PropertyStore &props, const std::string &sym)
void	serialize_symbol_properties (std::ostream &out, const PropertyStore &props, const std::string &sym)
std::string	sign_to_string (Sign s)

函数说明

◆ boundedness_to_string()

std::string LMCAS::anonymous_namespace{assumption_serialization.cpp}::boundedness_to_string ( Boundedness b )

在文件 assumption_serialization.cpp 第 31 行定义.

                                               {
    switch (b) {
        case Boundedness::Bounded:   return "Bounded";
        case Boundedness::Unbounded: return "Unbounded";
        case Boundedness::Unknown:   return "Unknown";
    }
    return "Unknown";
}

引用了 LMCAS::b, LMCAS::Bounded, boundedness_to_string(), LMCAS::Unbounded , 以及 LMCAS::Unknown.

被这些函数引用 boundedness_to_string() , 以及 serialize_symbol_properties().

函数调用图:

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

◆ definiteness_to_string()

std::string LMCAS::anonymous_namespace{assumption_serialization.cpp}::definiteness_to_string ( Definiteness d )

在文件 assumption_serialization.cpp 第 49 行定义.

                                                 {
    switch (d) {
        case Definiteness::PositiveDefinite:     return "PositiveDefinite";
        case Definiteness::PositiveSemiDefinite: return "PositiveSemiDefinite";
        case Definiteness::NegativeDefinite:     return "NegativeDefinite";
        case Definiteness::NegativeSemiDefinite: return "NegativeSemiDefinite";
        case Definiteness::Indefinite:           return "Indefinite";
        case Definiteness::Unknown:              return "Unknown";
    }
    return "Unknown";
}

引用了 definiteness_to_string(), LMCAS::Indefinite, LMCAS::NegativeDefinite, LMCAS::NegativeSemiDefinite, LMCAS::PositiveDefinite, LMCAS::PositiveSemiDefinite , 以及 LMCAS::Unknown.

被这些函数引用 definiteness_to_string() , 以及 serialize_symbol_properties().

函数调用图:

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

◆ endpoint_to_string()

std::string LMCAS::anonymous_namespace{assumption_serialization.cpp}::endpoint_to_string ( const Endpoint & ep )

在文件 assumption_serialization.cpp 第 83 行定义.

                                                 {
    if (ep.is_neg_infinity) return "-inf";
    if (ep.is_pos_infinity) return "+inf";
    if (ep.value) return ep.value->to_string();
    return "0";
}

引用了 endpoint_to_string().

被这些函数引用 endpoint_to_string() , 以及 interval_to_string().

函数调用图:

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

◆ finiteness_to_string()

std::string LMCAS::anonymous_namespace{assumption_serialization.cpp}::finiteness_to_string ( Finiteness f )

在文件 assumption_serialization.cpp 第 40 行定义.

                                             {
    switch (f) {
        case Finiteness::Finite:    return "Finite";
        case Finiteness::Divergent: return "Divergent";
        case Finiteness::Unknown:   return "Unknown";
    }
    return "Unknown";
}

引用了 LMCAS::Divergent, LMCAS::Finite, finiteness_to_string() , 以及 LMCAS::Unknown.

被这些函数引用 finiteness_to_string() , 以及 serialize_symbol_properties().

函数调用图:

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

◆ interval_to_string()

std::string LMCAS::anonymous_namespace{assumption_serialization.cpp}::interval_to_string ( const Interval & iv )

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

                                                 {
    std::string result;
    result += iv.lower.is_open ? "(" : "[";
    result += endpoint_to_string(iv.lower);
    result += ", ";
    result += endpoint_to_string(iv.upper);
    result += iv.upper.is_open ? ")" : "]";
    return result;
}

引用了 endpoint_to_string() , 以及 interval_to_string().

被这些函数引用 interval_to_string(), serialize_symbol_intervals() , 以及 serialize_symbol_properties().

函数调用图:

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

◆ monotonicity_to_string()

std::string LMCAS::anonymous_namespace{assumption_serialization.cpp}::monotonicity_to_string ( Monotonicity m )

在文件 assumption_serialization.cpp 第 61 行定义.

                                                 {
    switch (m) {
        case Monotonicity::Increasing:    return "Increasing";
        case Monotonicity::Decreasing:    return "Decreasing";
        case Monotonicity::NonDecreasing: return "NonDecreasing";
        case Monotonicity::NonIncreasing: return "NonIncreasing";
        case Monotonicity::Unknown:       return "Unknown";
    }
    return "Unknown";
}

引用了 LMCAS::Decreasing, LMCAS::Increasing, monotonicity_to_string(), LMCAS::NonDecreasing, LMCAS::NonIncreasing , 以及 LMCAS::Unknown.

被这些函数引用 monotonicity_to_string() , 以及 serialize_symbol_intervals().

函数调用图:

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

◆ parity_to_string()

std::string LMCAS::anonymous_namespace{assumption_serialization.cpp}::parity_to_string ( Parity p )

在文件 assumption_serialization.cpp 第 22 行定义.

                                     {
    switch (p) {
        case Parity::Even:    return "Even";
        case Parity::Odd:     return "Odd";
        case Parity::Unknown: return "Unknown";
    }
    return "Unknown";
}

引用了 LMCAS::Even, LMCAS::Odd, parity_to_string() , 以及 LMCAS::Unknown.

被这些函数引用 parity_to_string() , 以及 serialize_symbol_properties().

函数调用图:

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

◆ relop_to_string()

std::string LMCAS::anonymous_namespace{assumption_serialization.cpp}::relop_to_string ( RelationalNode::Op op )

在文件 assumption_serialization.cpp 第 72 行定义.

                                               {
    switch (op) {
        case RelationalNode::Op::GT:  return "GT";
        case RelationalNode::Op::LT:  return "LT";
        case RelationalNode::Op::GEQ: return "GEQ";
        case RelationalNode::Op::LEQ: return "LEQ";
        case RelationalNode::Op::NEQ: return "NEQ";
        case RelationalNode::Op::EQ:  return "EQ";
    }
    return "EQ";
}

引用了 LMCAS::op , 以及 relop_to_string().

被这些函数引用 relop_to_string().

函数调用图:

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

◆ serialize_symbol_intervals()

void LMCAS::anonymous_namespace{assumption_serialization.cpp}::serialize_symbol_intervals	(	std::ostream &	out,
		const PropertyStore &	props,
		const std::string &	sym )

在文件 assumption_serialization.cpp 第 141 行定义.

                                                      {
    auto cont_decls = props.get_continuity_decls(sym);
    for (const auto& decl : cont_decls) {
        if (decl.is_differentiable) {
            out << "DIFFERENTIABLE " << sym << " "
                << interval_to_string(decl.interval) << "\n";
        } else {
            out << "CONTINUOUS " << sym << " "
                << interval_to_string(decl.interval) << "\n";
        }
    }
 
    auto mono_decls = props.get_monotonicity_decls(sym);
    for (const auto& decl : mono_decls) {
        out << "MONOTONICITY " << sym << " " << decl.variable << " "
            << interval_to_string(decl.interval) << " "
            << monotonicity_to_string(decl.type) << "\n";
    }
}

引用了 interval_to_string(), monotonicity_to_string(), serialize_symbol_intervals() , 以及 LMCAS::sym().

被这些函数引用 serialize_symbol_intervals().

函数调用图:

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

◆ serialize_symbol_properties()

void LMCAS::anonymous_namespace{assumption_serialization.cpp}::serialize_symbol_properties	(	std::ostream &	out,
		const PropertyStore &	props,
		const std::string &	sym )

在文件 assumption_serialization.cpp 第 99 行定义.

                                                       {
    Domain dom = props.get_domain(sym);
    if (dom != Domain::Complex) {
        out << "DOMAIN " << sym << " " << property_detail::domain_str(dom) << "\n";
    }
    auto signs = props.get_signs(sym);
    for (Sign s : signs) {
        out << "SIGN " << sym << " " << sign_to_string(s) << "\n";
    }
    Parity par = props.get_parity(sym);
    if (par != Parity::Unknown) {
        out << "PARITY " << sym << " " << parity_to_string(par) << "\n";
    }
    Boundedness bnd = props.get_boundedness(sym);
    if (bnd != Boundedness::Unknown) {
        out << "BOUNDED " << sym << " " << boundedness_to_string(bnd);
        if (bnd == Boundedness::Bounded) {
            const auto bounds = props.get_bounds(sym);
            if (bounds) {
                out << " " << interval_to_string(*bounds);
            }
        }
        out << "\n";
    }
    if (props.is_transcendental(sym)) {
        out << "TRANSCENDENTAL " << sym << "\n";
    }
    Finiteness fin = props.get_finiteness(sym);
    if (fin != Finiteness::Unknown) {
        out << "FINITENESS " << sym << " " << finiteness_to_string(fin) << "\n";
    }
    Definiteness def = props.get_definiteness(sym);
    if (def != Definiteness::Unknown) {
        out << "DEFINITENESS " << sym << " " << definiteness_to_string(def) << "\n";
    }
    for (const auto& [variable, period] : props.get_period_decls(sym)) {
        out << "PERIODIC " << sym << " " << variable << " "
            << period.to_string() << "\n";
    }
}

引用了 LMCAS::Bounded, boundedness_to_string(), LMCAS::Complex, definiteness_to_string(), LMCAS::property_detail::domain_str(), finiteness_to_string(), interval_to_string(), parity_to_string(), serialize_symbol_properties(), sign_to_string(), LMCAS::sym(), LMCAS::Unknown , 以及 LMCAS::variable.

被这些函数引用 serialize_symbol_properties().

函数调用图:

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

◆ sign_to_string()

std::string LMCAS::anonymous_namespace{assumption_serialization.cpp}::sign_to_string ( Sign s )

在文件 assumption_serialization.cpp 第 10 行定义.

                                 {
    switch (s) {
        case Sign::Positive:    return "Positive";
        case Sign::Negative:    return "Negative";
        case Sign::NonNegative: return "NonNegative";
        case Sign::NonPositive: return "NonPositive";
        case Sign::Zero:        return "Zero";
        case Sign::NonZero:     return "NonZero";
    }
    return "Positive";
}

引用了 LMCAS::Negative, LMCAS::NonNegative, LMCAS::NonPositive, LMCAS::NonZero, LMCAS::Positive, sign_to_string() , 以及 LMCAS::Zero.

被这些函数引用 serialize_symbol_properties() , 以及 sign_to_string().

函数调用图:

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