Struct astro_nalgebra::ConstCtx

pub struct ConstCtx<const P: usize, const RM: u8 = 1> { /* private fields */ }

Computation context for BigFloat that has a compile-time constant precision and rounding mode. This tag struct is required to specify what the precision result will be for methods in nalgebra that do not take any arguments such as RealField::pi.

Example

use astro_nalgebra::{BigFloat, ConstCtx, RoundingMode};

// This defines a type that has a precision upper bound of
// 1024 bits in the mantissa and no explicit rounding mode
type BF1024 = BigFloat<ConstCtx<1024>>;

// This defines a type that has a precision upper bound of 256 bits in the
// mantissa and rounds up for all imprecise operations.
// Note that casting cannot be inlined into the const generic, so it has to
// be declared as a constant outside and then referenced.
const UP: u8 = RoundingMode::Up as u8;
type BF256Up = BigFloat<ConstCtx<256,UP>>;

fn main() {
    let two: BF1024 = "2".parse().unwrap();
}

This struct is meant to be used as a tag, so it is never actually constructable.

Trait Implementations

impl<const P: usize, const RM: u8> BigFloatCtx for ConstCtx<P, RM>

fn get_prec() -> usize

Returns the precision in bits of this specific context. This is either a const for ConstCtx or dynamic with make_dyn_ctx.

fn get_rm() -> RoundingMode

Returns the RoundingMode of this specific context. This is either a const for ConstCtx or dynamic with make_dyn_ctx.

fn run<F, R>(f: F) -> R

where F: FnOnce(&mut Context) -> R,

impl<const P: usize, const RM: u8> Clone for ConstCtx<P, RM>

fn clone(&self) -> ConstCtx<P, RM>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const P: usize, const RM: u8> Debug for ConstCtx<P, RM>

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

Formats the value using the given formatter.

impl<const P: usize, const RM: u8> PartialEq for ConstCtx<P, RM>

fn eq(&self, other: &ConstCtx<P, RM>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<const P: usize, const RM: u8> Copy for ConstCtx<P, RM>

impl<const P: usize, const RM: u8> StructuralPartialEq for ConstCtx<P, RM>