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

函数
void	append_scaled_plane_edges (const std::vector< double > &p1, const std::vector< double > &p2, const std::vector< double > &p3, double point_scale, std::vector< std::shared_ptr< SymbolicExpr > > &v1, std::vector< std::shared_ptr< SymbolicExpr > > &v2)
Result< void >	append_symbolic_plane_edges (const std::vector< std::shared_ptr< SymbolicExpr > > &p1, const std::vector< std::shared_ptr< SymbolicExpr > > &p2, const std::vector< std::shared_ptr< SymbolicExpr > > &p3, std::vector< std::shared_ptr< SymbolicExpr > > &v1, std::vector< std::shared_ptr< SymbolicExpr > > &v2, const std::string &operation, ComputationContext &context)
PlaneSymbolicResult	assemble_plane (std::vector< std::shared_ptr< SymbolicExpr > > &&normal, const std::vector< std::shared_ptr< SymbolicExpr > > &point, ComputationContext &context, const std::string &operation)
Result< void >	build_plane_edges (const std::vector< std::shared_ptr< SymbolicExpr > > &p1, const std::vector< std::shared_ptr< SymbolicExpr > > &p2, const std::vector< std::shared_ptr< SymbolicExpr > > &p3, std::vector< std::shared_ptr< SymbolicExpr > > &v1, std::vector< std::shared_ptr< SymbolicExpr > > &v2, ComputationContext &context, const std::string &operation)
Result< void >	check_plane_normal_nonzero (const std::vector< std::shared_ptr< SymbolicExpr > > &normal, bool numeric_edges, ComputationContext &context, const std::string &operation)
bool	is_plane_budget_error (const Result< double > &result)
bool	plane_point_differences_overflow (const std::vector< double > &p1, const std::vector< double > &p2, const std::vector< double > &p3)
Result< bool >	scale_plane_edges_for_cross (std::vector< std::shared_ptr< SymbolicExpr > > &v1, std::vector< std::shared_ptr< SymbolicExpr > > &v2, ComputationContext &context, const std::string &operation)

函数说明

append_scaled_plane_edges()

void LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::append_scaled_plane_edges	(	const std::vector< double > &	p1,
		const std::vector< double > &	p2,
		const std::vector< double > &	p3,
		double	point_scale,
		std::vector< std::shared_ptr< SymbolicExpr > > &	v1,
		std::vector< std::shared_ptr< SymbolicExpr > > &	v2 )

在文件 symbolic_geometry_plane.cpp 第 36 行定义.

                                                {
    for (size_t i = 0; i < 3; ++i) {
        v1.push_back(SymbolicExpr::number(
            p2[i] / point_scale - p1[i] / point_scale));
        v2.push_back(SymbolicExpr::number(
            p3[i] / point_scale - p1[i] / point_scale));
    }
}

引用了 append_scaled_plane_edges() , 以及 LMCAS::p2.

被这些函数引用 append_scaled_plane_edges() , 以及 build_plane_edges().

函数调用图:

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

append_symbolic_plane_edges()

Result< void > LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::append_symbolic_plane_edges	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	p1,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p2,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p3,
		std::vector< std::shared_ptr< SymbolicExpr > > &	v1,
		std::vector< std::shared_ptr< SymbolicExpr > > &	v2,
		const std::string &	operation,
		ComputationContext &	context )

在文件 symbolic_geometry_plane.cpp 第 51 行定义.

                                                             {
    for (size_t i = 0; i < 3; ++i) {
        auto left = simplify_checked(
            SymbolicExpr::add(
                p2[i],
                SymbolicExpr::multiply(SymbolicExpr::number(-1), p1[i])),
            operation,
            "plane edge vector is outside the supported domain", context);
        if (!left) return Result<void>::failure(left.error());
        auto right = simplify_checked(
            SymbolicExpr::add(
                p3[i],
                SymbolicExpr::multiply(SymbolicExpr::number(-1), p1[i])),
            operation,
            "plane edge vector is outside the supported domain", context);
        if (!right) return Result<void>::failure(right.error());
        v1.push_back(std::move(left.value()));
        v2.push_back(std::move(right.value()));
    }
    return Result<void>::success();
}

引用了 append_symbolic_plane_edges(), LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::p2, LMCAS::right, LMCAS::geometry_detail::simplify_checked() , 以及 LMCAS::Result< T >::success().

被这些函数引用 append_symbolic_plane_edges() , 以及 build_plane_edges().

函数调用图:

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

assemble_plane()

PlaneSymbolicResult LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::assemble_plane	(	std::vector< std::shared_ptr< SymbolicExpr > > &&	normal,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	point,
		ComputationContext &	context,
		const std::string &	operation )

在文件 symbolic_geometry_plane.cpp 第 188 行定义.

                                {
    auto d = vector_dot_checked(normal, point, context);
    if (!d) return PlaneSymbolicResult::failure(d.error());
    auto d_simplified = simplify_checked(
        d.value(), operation,
        "plane constant is outside the supported domain", context);
    if (!d_simplified) return PlaneSymbolicResult::failure(d_simplified.error());
 
    PlaneSymbolic plane;
    plane.normal = std::move(normal);
    for (auto& component : plane.normal) {
        auto simplified = simplify_checked(
            component, operation,
            "plane normal component is outside the supported domain", context);
        if (!simplified) return PlaneSymbolicResult::failure(simplified.error());
        component = std::move(simplified.value());
    }
    plane.d = std::move(d_simplified.value());
    return PlaneSymbolicResult::success(std::move(plane));
}

引用了 assemble_plane(), LMCAS::context, LMCAS::PlaneSymbolic::d, LMCAS::Result< PlaneSymbolic >::failure(), LMCAS::PlaneSymbolic::normal, LMCAS::plane, LMCAS::point, LMCAS::geometry_detail::simplify_checked(), LMCAS::Result< PlaneSymbolic >::success() , 以及 LMCAS::vector_dot_checked().

被这些函数引用 assemble_plane().

函数调用图:

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

build_plane_edges()

Result< void > LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::build_plane_edges	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	p1,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p2,
		const std::vector< std::shared_ptr< SymbolicExpr > > &	p3,
		std::vector< std::shared_ptr< SymbolicExpr > > &	v1,
		std::vector< std::shared_ptr< SymbolicExpr > > &	v2,
		ComputationContext &	context,
		const std::string &	operation )

在文件 symbolic_geometry_plane.cpp 第 79 行定义.

                                {
    std::vector<double> p1_values;
    std::vector<double> p2_values;
    std::vector<double> p3_values;
    auto p1_scale = numeric_vector_scale_checked(
        p1, context, operation, &p1_values);
    auto p2_scale = numeric_vector_scale_checked(
        p2, context, operation, &p2_values);
    auto p3_scale = numeric_vector_scale_checked(
        p3, context, operation, &p3_values);
    if (is_plane_budget_error(p1_scale)) {
        return Result<void>::failure(p1_scale.error());
    }
    if (is_plane_budget_error(p2_scale)) {
        return Result<void>::failure(p2_scale.error());
    }
    if (is_plane_budget_error(p3_scale)) {
        return Result<void>::failure(p3_scale.error());
    }
 
    const bool numeric_points =
        p1_scale.has_value() && p2_scale.has_value() && p3_scale.has_value();
    bool scale_differences = false;
    double point_scale = 0.0;
    if (numeric_points) {
        point_scale = std::max(
            p1_scale.value(), std::max(p2_scale.value(), p3_scale.value()));
        scale_differences = plane_point_differences_overflow(
            p1_values, p2_values, p3_values);
    }
    v1.reserve(3);
    v2.reserve(3);
    if (scale_differences) {
        append_scaled_plane_edges(
            p1_values, p2_values, p3_values, point_scale, v1, v2);
        return Result<void>::success();
    }
    return append_symbolic_plane_edges(p1, p2, p3, v1, v2, operation, context);
}

引用了 append_scaled_plane_edges(), append_symbolic_plane_edges(), build_plane_edges(), LMCAS::context, LMCAS::Result< T >::failure(), is_plane_budget_error(), LMCAS::geometry_detail::numeric_vector_scale_checked(), LMCAS::p2, plane_point_differences_overflow() , 以及 LMCAS::Result< T >::success().

被这些函数引用 build_plane_edges().

函数调用图:

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

check_plane_normal_nonzero()

Result< void > LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::check_plane_normal_nonzero	(	const std::vector< std::shared_ptr< SymbolicExpr > > &	normal,
		bool	numeric_edges,
		ComputationContext &	context,
		const std::string &	operation )

在文件 symbolic_geometry_plane.cpp 第 163 行定义.

                                {
    Result<void> nonzero = numeric_edges
        ? checked_nonzero_numeric_vector(
              normal, context, operation,
              "three points are collinear, so no unique plane exists",
              "plane normal nonzero condition cannot be verified")
        : Result<void>::failure(
              CasErrc::Inconclusive,
              "plane normal nonzero condition cannot be verified",
              operation);
    if (!numeric_edges) {
        auto norm_sq = vector_dot_checked(normal, normal, context);
        if (!norm_sq) return Result<void>::failure(norm_sq.error());
        nonzero = checked_nonzero_numeric_or_exact(
            norm_sq.value(), context, operation,
            "three points are collinear, so no unique plane exists",
            "plane normal nonzero condition cannot be verified");
    }
    return nonzero;
}

引用了 check_plane_normal_nonzero(), LMCAS::geometry_detail::checked_nonzero_numeric_or_exact(), LMCAS::geometry_detail::checked_nonzero_numeric_vector(), LMCAS::context, LMCAS::Result< T >::failure(), LMCAS::Inconclusive , 以及 LMCAS::vector_dot_checked().

被这些函数引用 check_plane_normal_nonzero().

函数调用图:

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

is_plane_budget_error()

bool LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::is_plane_budget_error

(

const Result< double > &

result

)

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

                                                         {
    return !result &&
        (result.error().code == CasErrc::Cancelled ||
         result.error().code == CasErrc::ResourceLimit);
}

引用了 LMCAS::Cancelled, LMCAS::CasError::code, LMCAS::Result< T >::error(), is_plane_budget_error() , 以及 LMCAS::ResourceLimit.

被这些函数引用 build_plane_edges(), is_plane_budget_error() , 以及 scale_plane_edges_for_cross().

函数调用图:

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

plane_point_differences_overflow()

bool LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::plane_point_differences_overflow	(	const std::vector< double > &	p1,
		const std::vector< double > &	p2,
		const std::vector< double > &	p3 )

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

                                 {
    for (size_t i = 0; i < 3; ++i) {
        if (!std::isfinite(p2[i] - p1[i]) ||
            !std::isfinite(p3[i] - p1[i])) {
            return true;
        }
    }
    return false;
}

引用了 LMCAS::p2 , 以及 plane_point_differences_overflow().

被这些函数引用 build_plane_edges() , 以及 plane_point_differences_overflow().

函数调用图:

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

scale_plane_edges_for_cross()

Result< bool > LMCAS::anonymous_namespace{symbolic_geometry_plane.cpp}::scale_plane_edges_for_cross	(	std::vector< std::shared_ptr< SymbolicExpr > > &	v1,
		std::vector< std::shared_ptr< SymbolicExpr > > &	v2,
		ComputationContext &	context,
		const std::string &	operation )

在文件 symbolic_geometry_plane.cpp 第 126 行定义.

                                {
    std::vector<double> v1_values;
    std::vector<double> v2_values;
    auto v1_scale = numeric_vector_scale_checked(
        v1, context, operation, &v1_values);
    auto v2_scale = numeric_vector_scale_checked(
        v2, context, operation, &v2_values);
    const bool numeric_edges = v1_scale.has_value() && v2_scale.has_value();
    if (!numeric_edges) {
        if (is_plane_budget_error(v1_scale) || is_plane_budget_error(v2_scale)) {
            return Result<bool>::failure(
                !v1_scale ? v1_scale.error() : v2_scale.error());
        }
    } else if (v1_scale.value() != 0.0 && v2_scale.value() != 0.0) {
        const double safe_high =
            std::sqrt(std::numeric_limits<double>::max() / 12.0);
        const double safe_low =
            std::sqrt(std::numeric_limits<double>::min());
        const bool scale_cross =
            v1_scale.value() > safe_high / v2_scale.value() ||
            v1_scale.value() < safe_low / v2_scale.value();
        if (scale_cross) {
            for (size_t i = 0; i < 3; ++i) {
                v1[i] = SymbolicExpr::number(
                    v1_values[i] / v1_scale.value());
                v2[i] = SymbolicExpr::number(
                    v2_values[i] / v2_scale.value());
            }
        }
    }
    return Result<bool>::success(numeric_edges);
}

引用了 LMCAS::context, LMCAS::Result< T >::failure(), is_plane_budget_error(), LMCAS::geometry_detail::numeric_vector_scale_checked(), scale_plane_edges_for_cross() , 以及 LMCAS::Result< T >::success().

被这些函数引用 scale_plane_edges_for_cross().

函数调用图:

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