Module frame_bound 

Certified bounds on a section frame law’s derivatives in station distance (#247, ADR 0082 amendment).

A run of sections placed at stations (the parent module) puts a section point at A(s) = O(s) + x(s) L(s) + y(s) U(s) + z(s) T(s): the basis point O and the section frame (tangent T, lateral L, up U) at the distance s, with local coordinates linear in s between two stations. A chord of A is within h^2 / 8 sup |A''| of it (crate::bound), and

|A''| <= |O''| + |x| |L''| + |y| |U''| + |z| |T''| + 2 (|x'| |L'| + |y'| |U'| + |z'| |T'|),

so a run is bounded once |O'|, |O''| and the first two derivatives of each axis are, over a span of distance. piece_frame_bounds returns them for a span inside one StationPiece that crosses no seam of its curve, or None where they are not certified.

Where the bounds come from

Everything is derived in the piece’s own station measure s from the curve’s tangent law: k1 >= sup |T'|, k2 >= sup |T''|.

• A line and a polyline’s segment: T constant, k1 = k2 = 0.
• A circle of radius r with an orthonormal frame, by arc length: |O''| = k1 = 1 / r, k2 = 1 / r^2.
• An elevated curve (plan a line or a circle, profile of closed-form pieces) and a banked curve, by plan distance, which is their parameter: with D_j >= sup |c^(j)| (crate::elevated) and sigma a lower bound of |c'| over the span (|c'(mid)| - h/2 D_2), the unit tangent has k1 = D_2 / sigma and k2 = 2 D_3 / sigma + 6 D_2^2 / sigma^2, the bounds a swept disk’s wall rests on (#252).

The axes follow from T through one rule: a unit vector w / |w| with |w| >= rho has |u'| <= |w'| / rho and |u''| <= 2 |w''| / rho + 6 |w'|^2 / rho^2 (super::certify). rho is the horizontal length of T at the middle of the span less h/2 k1, a lower bound over it.

• A 2D curve’s planar frame: L is T turned a quarter, U = +Z.
• The reference-up frame: R = (T x Z) / |T x Z| with |T x Z| = |T_xy| >= rho gives m1 = k1 / rho, m2 = 2 k2 / rho + 6 k1^2 / rho^2; L = -R, and U = R x T has |U'| <= m1 + k1, |U''| <= m2 + 2 m1 k1 + k2.
• A banked curve’s rolled section: n the horizontal left normal (bounds m1, m2 as R), u = T x n (bounds k1 + m1, k2 + 2 k1 m1 + m2), L = cos(phi) n + sin(phi) u and U = -sin(phi) n + cos(phi) u for the roll phi. With a_j = hypot(|n^(j)|, |u^(j)|) (Cauchy-Schwarz over cos, sin) and p_j >= sup |phi^(j)|, both have |X'| <= p1 + a1 and |X''| <= p2 + p1^2 + 2 p1 a1 + a2. The roll is asin(g), g = D / b (or D sqrt(1 + G^2) / b under the vertical-rise convention, G the grade), so |phi'| <= |g'| / c and |phi''| <= |g''| / c + |g| |g'|^2 / c^3 with c = sqrt(1 - sup |g|^2), from the cant law’s certified derivative suprema (crate::banked).
• The plan reading (FrameReading::Plan): T_p = T_xy / |T_xy| has the bounds m1, m2, L_p its quarter turn, U = +Z.

A reversed piece negates T and L, which keeps every magnitude; a placement that keeps +Z moves the frame rigidly (its stretch, a hair above one, scales the bounds); one that tilts +Z reads the reference-up frame of the moved tangent (SectionFrame::carried), bounded as above with rho from the moved tangent, and a plan-measured piece so placed is not bounded.

The measure

FrameLawBounds::measure bounds how far the distance a frame is read at may lie from the one asked for. A line, an elevated and a banked curve read their parameter from the distance in closed form: 0. A circle with an orthonormal frame and a polyline read it by the arc-length inverse (crate::arc_parameter); their speed is constant on every panel (a polyline’s panels split at its vertices), so the Gauss-Legendre rule is exact up to rounding and the root find stops within its tolerance: twice ARC_LENGTH_TOLERANCE * max(1, s).

The signed bend (#361)

The derivative suprema bound how far a section moves, not whether the section planes keep advancing. FrameLawBounds::forward bounds the forward rate O'.N of the basis point from below (one in arc length and in plan distance, the horizontal part of the tangent under the plan reading of an arc-length space curve, times a placement’s smallest column length), and FrameLaw::bend bounds it together with the tangent’s turning toward the lateral and the up axis, L.N' and U.N': a section point (a, b) advances at O'.N - a L.N' - b U.N' plus its longitudinal rate, and the planes fold where that is not positive. The bend module states the closed forms.

Read by quadrature (#316)

An ellipse, a B-spline and an offset beside a line, a circle, an ellipse or a B-spline read their frames through estimates (the arc-length inverse, an offset’s own length table, an offset’s tangent by a difference quotient), so piece_frame_bounds leaves them unbounded. FrameLaw bounds them against their EXACT frame law instead: the curve the length certificates of super::certify measure, framed by its own tangent at its true arc length from the piece’s start. Each read frame stands at a native parameter where the exact curve’s point and velocity are known in closed form to a certified error; the read point’s and each read axis’s distance from the exact frame there are computed and carried as FrameLawBounds::point_error and FrameLawBounds::axis_error, and the true arc length to that parameter, bounded by chord panels over the piece measured once, gives the measure. Over a span between two reads the exact law is bounded in its own arc length from the certified suprema of |P''| and |P'''| (the base’s |B''| to |B''''| beside an offset, and the frame’s unit vectors) and a floor of |P'|: |O''| = |T'| <= M2 / sigma^2 and |T''| <= (M3 / sigma + 3 M2^2 / sigma^2) / sigma^2 + M2^2 / sigma^4. The axes follow from the tangent as above. On a composite, a piece after one measured by quadrature starts where the kernel sums the lengths before it; its distance from the certified joint (super::CompositeBasis::joint_intervals) adds to the measure.

Intrinsic curves (#361)

An intrinsic curve’s heading is the closed-form integral of its curvature law, so over a seam-free span |T'| <= sup |k| and |T''| <= sup |k'| + sup k^2 in arc length, from the law’s own suprema (crate::bound::intrinsic_derivative_bounds2), and the axes follow by the rules above. An elevated curve over an intrinsic plan composes them with the profile in plan distance, as over a line or a circle, and a banked curve over one adds the roll bounded from its cant law (#396, Kind::Banked). Only the POINT is a quadrature, with no error bound of its own, so piece_frame_bounds leaves these curves unbounded and FrameLaw compares every frame it reads with the exact one, as for the curves read by quadrature: the exact point from a certified IntrinsicPositionTable, the exact axes from the closed-form heading. The measure is exact. The families are a 2D intrinsic curve, a level planar intrinsic space curve and an elevated or banked curve over an intrinsic plan with a closed-form profile (a banked curve’s cant without a held-rail piece), each with an orthonormal start frame and any curvature law with closed-form bounds of k to k'''.

One station (#405)

A part placed at ONE station rests on one frame, not a run of them: FrameLaw::error_at charges the frame read at a distance against the exact frame law’s there, its point and each axis (StationFrameError).

The frame is read as StationPiece::section_on reads it: the piece a composite names at distance from side, a seam of the curve inside it read from the side named (#263). Two charges make the error:

• The read (e_p, e_a). A slot read in closed form (a circle, a polyline, an elevated or banked curve over a line or a circle) has no error of its own but the rounding of the read: POINT_ROUNDING of the point’s largest coordinate (one at least), and 1e-14 per axis. An intrinsic curve’s slot (a 2D curve, a level planar space curve, an elevated or banked curve over an intrinsic plan) compares the read frame with the exact one, as FrameLaw::bounds does for a run: both sides of a seam of its law are compared, which covers the one named.
• The distance’s resolution (delta, the bounds’ measure). Where the distance is resolved by the arc-length inverse (a circle, a polyline) the read stands within delta of the distance asked for, and on a composite a piece after pieces measured by quadrature adds its start’s certified distance from the true joint. The exact frame at the distance asked for is then within delta |O'| of the read point and delta max(|T'|, |L'|, |U'|) of each read axis, the suprema taken over [u - 2 delta, u + 2 delta] on the side read: where the station is ON a seam it is clipped to the side named. A curve whose distance is exact (a line, an elevated or banked curve, an intrinsic curve) has delta = 0.

Not charged, None: a slot read by quadrature or unbounded, a composite piece placed inexactly, a seam or a joint within 2 delta of the station that it is not on (the exact frame might stand on its other side), and a result that is not finite.

Not bounded

None, never a guess: a chain, and an offset beside one of them, beside an intrinsic, an elevated or a banked curve; a banked curve over a chain plan; an intrinsic space curve with torsion or out of a level plane; an intrinsic curve with a stretched or skewed start frame; a circle with a skewed frame; an elevated or banked curve with another plan, an intrinsic profile or a held-rail cant over an intrinsic plan; a span that crosses a seam, a vertex of a polyline or a piece of a law; a tangent too steep for a horizontal lower bound; a cant whose roll reaches a quarter turn; a curve read by quadrature placed in a frame that tilts +Z, and a placed offset piece. piece_frame_bounds alone also leaves an ellipse, a B-spline and every offset unbounded: they are FrameLaw’s.

Structs

BendBounds

Certified bounds, over a span of station distance, of the coefficients of the signed bend of a section frame law; see the module documentation.

FrameLaw

Certified bounds on the frame law along a station basis (#316): an atomic curve or a CompositeBasis, over spans that cross no seam.

FrameLawBounds

Certified suprema, over a span of station distance, of the derivatives of a section frame law in that distance; see the module documentation.

StationFrameError

How far a frame read at a station lies from the exact frame law’s, see the module documentation.

Enums

FrameReading

Which section frame a run places its sections in.

Functions

piece_frame_bounds

Certified bounds on the derivatives, in station distance, of the section frame piece presents over [from, to] (distances into the piece, in the composite’s direction), read as reading; see the module documentation.