Struct Catenary

pub struct Catenary<T: DualNum<f64>> {
    pub a: T,
    pub c: T,
    pub h: T,
    pub s_0: T,
    pub s_1: T,
}

Represents a Catenary curve.

The Catenary curve is defined by the equation: y(x) = a * cosh((x - c) / a) - a + h where:

• a is the parameter that controls the shape of the curve.
• c is the horizontal shift of the curve.
• h is the vertical shift of the curve.
• s_0 and s_1 are linear abscissa of end points (negative on the left of minimum, positive on the right).

Fields

a: T

The parameter that controls the shape of the curve.

c: T

The horizontal shift of the curve.

h: T

The vertical shift of the curve.

s_0: T

The linear abscissa of the left endpoint (from min).

s_1: T

The linear abscissa of the right endpoint (from min).

Implementations

impl<T: DualNum<f64>> Catenary<T>

pub fn new(a: T, c: T, h: T, s_0: T, s_1: T) -> Self

Creates a new instance of the Catenary structure.

Arguments

• a - The parameter that controls the shape of the curve.
• c - The horizontal shift of the curve.
• h - The vertical shift of the curve.
• s_0 - The linear abscissa of the left endpoint (from min).
• s_1 - The linear abscissa of the right endpoint (from min).

pub fn x_from_y(&self, y: &T) -> Roots<T>

Computes the x-coordinate(s) from the given y-coordinate on the catenary curve.

Arguments

• y - The y-coordinate.

Returns

The roots of the equation representing the x-coordinate(s).

pub fn y_from_abscissa(&self, s: &T) -> T

Computes the y-coordinate(s) from the given abscissa on the catenary curve.

Arguments

• s - The abscissa.

Returns

The y-coordinate(s) corresponding to the given abscissa.

pub fn s_from_x(&self, x: &T) -> T

Computes the abscissa s from the given x-coordinate on the catenary curve.

Arguments

• x - The x-coordinate.

Returns

The abscissa s corresponding to the given x-coordinate.

pub fn x_from_abscissa(&self, s: &T) -> T

Computes the x-coordinate from the given abscissa on the catenary curve.

Arguments

• s - The abscissa.

Returns

The x-coordinate corresponding to the given abscissa.

pub fn length(&self) -> T

Returns the length of the catenary curve.

pub fn end_points(&self) -> (Point2<T>, Point2<T>)

Returns the end points of the catenary curve.

Returns

A tuple containing the start and end points of the catenary curve.

impl Catenary<f64>

pub fn from_points_length_init( p0: &Point2<f64>, p1: &Point2<f64>, length: f64, cat0: &Self, ) -> Option<Self>

Creates a catenary curve from two points and a specified length, and an initial guess

Arguments

• p0 - The start point of the catenary curve.
• p1 - The end point of the catenary curve.
• length - The desired length of the catenary curve.
• cat0 - The initial catenary curve to use as a starting point.

Returns

An Option containing the catenary curve if it could be created, or None otherwise.

pub fn from_points_length( p0: &Point2<f64>, p1: &Point2<f64>, length: f64, ) -> Option<Self>

Creates a catenary curve from two points and a specified length. (same as from_points_length_init but without the initial guess)

Arguments

• p0 - The start point of the catenary curve.
• p1 - The end point of the catenary curve.
• length - The desired length of the catenary curve.

Returns

An Option containing the catenary curve if it could be created, or None otherwise.

pub fn from_segment(p0: &Point2<f64>, p1: &Point2<f64>) -> Self

Creates a (almost line) Catenary from a line segment defined by two points (degenerate case with big a, or 0 if vertical)

pub fn from_segment_length( p0: &Point2<f64>, p1: &Point2<f64>, length: f64, ) -> Option<Self>

Creates a Catenary from a line segment defined by two points and a optimize with the length. To use when the catenary is almost a straight line. The optimization starts from a straight line catenary.

Trait Implementations

impl<T: DualNum<f64>> Add for Catenary<T>

type Output = Catenary<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Clone + DualNum<f64>> Clone for Catenary<T>

fn clone(&self) -> Catenary<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: DualNum<f64>> Contour<T> for Catenary<T>

fn position(&self, s: &T) -> Point2<T>

Returns the position on the contour for a given input value.

fn divide(&self, start: F, end: F, n_points: u32) -> Vec<OPoint<F, Const<2>>>

Divides the contour into a specified number of points between the start and end values.

impl<T: Debug + DualNum<f64>> Debug for Catenary<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default + DualNum<f64>> Default for Catenary<T>

fn default() -> Catenary<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Catenary<T>

where T: Deserialize<'de> + DualNum<f64>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Catenary<f64>> for Catenary<DualSVec64<3>>

fn from(cat: Catenary<f64>) -> Self

Converts to this type from the input type.

impl From<Catenary<f64>> for Catenary<DualSVec64<5>>

fn from(cat: Catenary<f64>) -> Self

Converts to this type from the input type.

impl<T: DualNum<f64>> Mul<&T> for Catenary<T>

type Output = Catenary<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation.

impl<T: PartialEq + DualNum<f64>> PartialEq for Catenary<T>

fn eq(&self, other: &Catenary<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for Catenary<T>

where T: Serialize + DualNum<f64>,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: DualNum<f64>> Sub for &Catenary<T>

type Output = Catenary<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: DualNum<f64>> Sub for Catenary<T>

type Output = Catenary<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: Copy + DualNum<f64>> Copy for Catenary<T>

impl<T: DualNum<f64>> StructuralPartialEq for Catenary<T>