Struct ConstCache 

pub struct ConstCache { /* private fields */ }

An opt-in cache of mathematical constants.

Holds exact binary-splitting tree state so that repeated calls at increasing precision extend prior work instead of recomputing from scratch. For example, computing π at 100 digits and then at 1000 digits only pays for the extra ~900 digits of work.

The cache is base-free: a single ConstCache serves any base. The base and rounding mode are specified on each method call (e.g. cache.pi::<10, HalfAway>(100) for 100 decimal digits).

ConstCache is a plain struct of big integers, so it is Send + Sync. The methods take &mut self (they extend the cached state on a miss), so a caller either owns one directly, or — to share it across many values and operations — wraps it in Rc<RefCell<ConstCache>> as the CachedFBig type does. To share one cache across threads, wrap a ConstCache (or a CachedFBig) in Arc<Mutex<..>>.

Examples

use dashu_float::ConstCache;
use dashu_float::round::mode::HalfAway;

let mut cache = ConstCache::new();
// first call computes from scratch
let _pi_100 = cache.pi::<10, HalfAway>(100).value();
// second call at higher precision extends the cached state
let pi_1000 = cache.pi::<10, HalfAway>(1000).value();
assert!(pi_1000.to_string().starts_with("3.141592653589793"));

Implementations

impl ConstCache

pub const fn new() -> Self

Create an empty cache.

pub fn pi<const B: Word, R: Round>( &mut self, precision: usize, ) -> Rounded<FBig<R, B>>

π at precision base-B digits, rounded per R. Extends any prior π state cached in self.

Panics

Panics if precision is 0.

pub fn ln2<const B: Word, R: Round>(&mut self, precision: usize) -> FBig<R, B>

ln(2) at precision base-B digits, reusing the cached L(6) and L(99) sub-series.

Panics

Panics if precision is 0.

pub fn ln10<const B: Word, R: Round>(&mut self, precision: usize) -> FBig<R, B>

ln(10) at precision base-B digits, reusing the cached L(6), L(99), and L(9) sub-series.

Panics

Panics if precision is 0.

pub fn ln_base<const B: Word, R: Round>( &mut self, precision: usize, ) -> FBig<R, B>

ln(B) at precision base-B digits, reusing the cached ln2 / ln10 where possible.

Panics

Panics if precision is 0.

pub fn total_terms(&self) -> usize

Sum of num_terms across all populated cache slots.

pub fn total_words(&self) -> usize

Sum of word counts across all cached big integers (P, Q, T, and the cached √10005 isqrt).

This reflects the underlying storage words used by the cached state.

pub fn clear(&mut self)

Clear all cached constant state, freeing the underlying memory.

After calling clear(), the next constant computation will start from scratch rather than extending the prior cached state.

Trait Implementations

impl Debug for ConstCache

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

Formats the value using the given formatter.

impl Default for ConstCache

fn default() -> Self

Returns the “default value” for a type.