Struct Contour 

pub struct Contour<F: ComplexScalar> { /* private fields */ }

Ordered integration contour.

A Contour stores a sequence of ContourSegments. The integrator evaluates each segment independently and sums the resulting contributions.

The current concrete contour type is designed for complex-valued contours and supports heterogeneous built-in pieces such as line segments and circular arcs.

Implementations

impl<F> Contour<F>

where F: ComplexScalar + FromPrimitive,

pub fn indent( self, pole: F::Complex, radius: F, side: IndentSide, tolerance: F, ) -> Self

impl<F: ComplexScalar> Contour<F>

pub fn from_pieces(pieces: Vec<ContourSegment<F>>) -> Self

Creates a contour from explicit contour pieces.

Panics

Panics if pieces is empty.

pub fn pieces(&self) -> &[ContourSegment<F>]

pub fn into_pieces(self) -> Vec<ContourSegment<F>>

pub fn reverse(self) -> Self

pub fn close(self) -> Self

pub fn with_principal_value( self, pole: F::Complex, radius: F, side: IndentSide, tolerance: F, ) -> Self

where F: ComplexScalar + FromPrimitive,

pub fn indent_many( self, singularities: impl IntoIterator<Item = (F::Complex, F, IndentSide)>, tolerance: F, ) -> Self

where F: ComplexScalar + FromPrimitive,

impl<F> Contour<F>

where F: ComplexScalar,

pub fn piecewise_linear(points: Vec<F::Complex>) -> Self

Creates a piecewise-linear contour through the supplied points.

Consecutive points are joined by line segments.

Panics

Panics if fewer than two points are supplied.

pub fn upper_half_disk_centered(center: F::Complex, radius: F) -> Self

where F: FromPrimitive,

Counter-clockwise upper half-disk contour.

Path:

center - R  →  center + R
center + R  →  center - R   through the upper half-plane

pub fn lower_half_disk_centered(center: F::Complex, radius: F) -> Self

where F: FromPrimitive,

Clockwise lower half-disk contour.

Path:

center - R  →  center + R
center + R  →  center - R   through the lower half-plane

pub fn real_axis(radius: F) -> Self

where F: FromPrimitive,

Constructs a contour following the real axis from -radius to radius.

This is the canonical finite approximation to the real line used when numerically evaluating improper integrals over (-∞, ∞).

The contour consists of a single straight line segment.

Orientation

The contour is traversed from left to right.

Notes

The infinite real axis is recovered in the limit radius → ∞.

pub fn real_axis_offset(radius: F, imaginary_offset: F) -> Self

where F: FromPrimitive,

Constructs a straight contour parallel to the real axis.

The contour runs from

-radius + i·offset

to

radius + i·offset.

Orientation

The contour is traversed from left to right.

Applications

Offset contours occur frequently in physics and applied mathematics, including:

• causal Green’s functions (i0⁺ prescriptions),
• Laplace and Fourier inversion,
• contour deformation to avoid poles,
• regularisation of principal-value integrals.

pub fn upper_half_disk(radius: F) -> Self

where F: FromPrimitive,

Constructs a counter-clockwise upper half-disk.

The contour consists of

1. a straight line along the real axis from -radius to radius,
2. a circular arc returning through the upper half-plane.

       ●
    .-' '-.
  .'       '.
-R-----------R

Orientation

The resulting contour is positively oriented (counter-clockwise).

Applications

This contour is commonly used with:

• the residue theorem,
• Jordan’s lemma,
• Fourier transform evaluation,
• contour integration in wave propagation.

Notes

The infinite upper-half-plane contour is recovered by taking radius → ∞.

pub fn lower_half_disk(radius: F) -> Self

where F: FromPrimitive,

Constructs a clockwise lower half-disk.

The contour consists of

1. a straight line along the real axis from -radius to radius,
2. a circular arc returning through the lower half-plane.

-R-----------R
  '.       .'
    '-._.-'

Orientation

The resulting contour is negatively oriented (clockwise).

Applications

Useful when applying the residue theorem to integrands that decay in the lower half-plane, such as Fourier integrals with negative arguments.

Notes

The infinite lower-half-plane contour is recovered by taking radius → ∞.

pub fn upper_half_disk_offset(radius: F, imaginary_offset: F) -> Self

where F: FromPrimitive,

Constructs an upper half-disk translated vertically.

The contour is identical to upper_half_disk except that it is centred at

i · imaginary_offset.

Consequently, the straight segment lies along

Im(z) = imaginary_offset.

Applications

Shifted contours are useful when implementing

• i0⁺ prescriptions,
• contour regularisation,
• displaced Bromwich contours,
• Green’s function calculations.

pub fn lower_half_disk_offset(radius: F, imaginary_offset: F) -> Self

where F: FromPrimitive,

Constructs a lower half-disk translated vertically.

The contour is identical to lower_half_disk except that it is centred at

i · imaginary_offset.

The straight segment therefore lies on

Im(z) = imaginary_offset.

This contour is frequently used when closing contours below the real axis while avoiding nearby singularities.

Trait Implementations

impl<F: Clone + ComplexScalar> Clone for Contour<F>

fn clone(&self) -> Contour<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + ComplexScalar> Debug for Contour<F>

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

Formats the value using the given formatter.