Struct distimate::Triangular

pub struct Triangular { /* private fields */ }

Represents a Triangular distribution.

The Triangular distribution is defined by its minimum, most likely (mode), and maximum values.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_eq!(triangular.min(), 1.0);
assert_eq!(triangular.mode(), 2.0);
assert_eq!(triangular.max(), 3.0);
assert_relative_eq!(triangular.mean().unwrap(), 2.0, epsilon = 1e-4);

Implementations

impl Triangular

pub fn new(min: f64, likely: f64, max: f64) -> Result<Self>

Creates a new Triangular distribution with the given minimum, likely, and maximum values.

Arguments

• min - The minimum value of the distribution
• likely - The most likely value (mode) of the distribution
• max - The maximum value of the distribution

Returns

Returns a Result containing the new Triangular instance if the parameters are valid, or an Error if the parameters are invalid.

Errors

Returns an error if:

• min is greater than or equal to max
• likely is less than min or greater than max

Examples

use distimate::prelude::*;
use distimate::Triangular;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_eq!(triangular.min(), 1.0);
assert_eq!(triangular.mode(), 2.0);
assert_eq!(triangular.max(), 3.0);

Trait Implementations

impl Clone for Triangular

fn clone(&self) -> Triangular

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Continuous<f64, f64> for Triangular

Implementation of the Continuous trait for the Triangular distribution.

This implementation provides methods to calculate the probability density function (PDF) and its natural logarithm for the Triangular distribution.

fn pdf(&self, x: f64) -> f64

Calculates the probability density function (PDF) of the Triangular distribution at a given point.

Arguments

• x - The point at which to calculate the PDF

Returns

The value of the PDF at the given point as an f64.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_relative_eq!(triangular.pdf(2.0), 1.0, epsilon = 1e-6);
assert_eq!(triangular.pdf(0.0), 0.0); // Outside the distribution's range

fn ln_pdf(&self, x: f64) -> f64

Calculates the natural logarithm of the probability density function (PDF) of the Triangular distribution at a given point.

Arguments

• x - The point at which to calculate the log PDF

Returns

The natural logarithm of the PDF at the given point as an f64.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_relative_eq!(triangular.ln_pdf(2.0), 0.0, epsilon = 1e-6);
assert_eq!(triangular.ln_pdf(0.0), f64::NEG_INFINITY); // Outside the distribution's range

impl ContinuousCDF<f64, f64> for Triangular

Implementation of the ContinuousCDF trait for the Triangular distribution.

fn cdf(&self, x: f64) -> f64

Calculates the cumulative distribution function (CDF) of the Triangular distribution at a given point.

Arguments

• x - The point at which to calculate the CDF

Returns

The value of the CDF at the given point as an f64, in the range [0, 1].

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_relative_eq!(triangular.cdf(2.0), 0.5, epsilon = 1e-6);
assert_eq!(triangular.cdf(1.0), 0.0);
assert_eq!(triangular.cdf(3.0), 1.0);

fn inverse_cdf(&self, p: f64) -> f64

Calculates the inverse of the cumulative distribution function (inverse CDF) of the Triangular distribution for a given probability.

Arguments

• p - The probability for which to calculate the inverse CDF, must be in the range [0, 1]

Returns

The value x for which the CDF of the distribution equals the given probability.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_relative_eq!(triangular.inverse_cdf(0.5), 2.0, epsilon = 1e-4);
assert_relative_eq!(triangular.inverse_cdf(0.0), 1.0, epsilon = 1e-4);
assert_relative_eq!(triangular.inverse_cdf(1.0), 3.0, epsilon = 1e-4);

fn sf(&self, x: K) -> T

Returns the survival function calculated at x for a given distribution. May panic depending on the implementor.

impl Debug for Triangular

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

Formats the value using the given formatter.

impl Distribution<f64> for Triangular

Implementation of the Distribution trait for the Triangular distribution.

This implementation provides methods to calculate various statistical properties of the Triangular distribution.

fn mean(&self) -> Option<f64>

Calculates the mean of the Triangular distribution.

Returns

The mean of the distribution as an Option<f64>. Always returns Some(value) as the Triangular distribution always has a defined mean.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_relative_eq!(triangular.mean().unwrap(), 2.0, epsilon = 1e-6);

fn variance(&self) -> Option<f64>

Calculates the variance of the Triangular distribution.

Returns

The variance of the distribution as an Option<f64>. Always returns Some(value) as the Triangular distribution always has a defined variance.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_relative_eq!(triangular.variance().unwrap(), 0.1666667, epsilon = 1e-6);

fn skewness(&self) -> Option<f64>

Calculates the skewness of the Triangular distribution.

Returns

The skewness of the distribution as an Option<f64>. Always returns Some(value) as the Triangular distribution always has a defined skewness.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_relative_eq!(triangular.skewness().unwrap(), 0.0, epsilon = 1e-6);

fn entropy(&self) -> Option<f64>

Calculates the entropy of the Triangular distribution.

The entropy is a measure of the average amount of information contained in the distribution.

Returns

The entropy of the distribution as an Option<f64>. Always returns Some(value) as the Triangular distribution always has a defined entropy.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_relative_eq!(triangular.entropy().unwrap(), 0.5, epsilon = 1e-6);

fn std_dev(&self) -> Option<T>

Returns the standard deviation, if it exists.

impl Distribution<f64> for Triangular

Implementation of the rand::distributions::Distribution trait for the Triangular distribution.

This implementation allows for random sampling from the Triangular distribution using any random number generator that implements the rand::Rng trait.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64

Generates a random sample from the Triangular distribution.

This method uses the inverse transform sampling technique: it generates a uniform random number between 0 and 1, then applies the inverse CDF to this number to produce a sample from the Triangular distribution.

Arguments

• rng - A random number generator that implements the rand::Rng trait

Returns

A random sample from the Triangular distribution as an f64.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use rand::prelude::*;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
let mut rng = StdRng::seed_from_u64(42);  // For reproducibility

let sample = triangular.sample(&mut rng);
assert!(sample >= 1.0 && sample <= 3.0);

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl EstimationDistribution for Triangular

Implementation of the EstimationDistribution trait for the Triangular distribution.

This trait marks the Triangular distribution as suitable for use in estimation contexts. It doesn’t add any new methods, but signals that this distribution is appropriate for modeling uncertain estimates or durations.

Examples

use distimate::prelude::*;
use distimate::Triangular;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
// The fact that we can create a Triangular instance demonstrates
// that it implements EstimationDistribution

fn percentile_estimate(&self, p: f64) -> Result<f64>

Returns the estimate at a given percentile.

fn optimistic_estimate(&self) -> f64

Returns the optimistic (best-case) estimate, typically the 5th percentile.

fn pessimistic_estimate(&self) -> f64

Returns the pessimistic (worst-case) estimate, typically the 95th percentile.

fn most_likely_estimate(&self) -> f64

Returns the most likely estimate (mode).

fn expected_value(&self) -> f64

Returns the expected value (mean) of the distribution.

fn uncertainty(&self) -> f64

Returns the standard deviation of the distribution.

fn probability_of_completion(&self, estimate: f64) -> f64

Calculates the probability of completing a task or project by a given estimate.

fn risk_of_overrun(&self, estimate: f64) -> f64

Calculates the risk of exceeding a given estimate.

fn confidence_interval(&self, confidence_level: f64) -> (f64, f64)

Returns a confidence interval for the estimate.

fn evaluate_fit_quality(&self, data: &[f64]) -> Result<EstimationFitQuality>

Evaluates how well the distribution fits a given dataset in the context of estimation.

fn calculate_within_interval( &self, data: &[f64], lower_percentile: f64, upper_percentile: f64, ) -> Result<f64>

Helper method to calculate the proportion of data within a given interval.

impl Max<f64> for Triangular

Implementation of the Max trait for the Triangular distribution.

fn max(&self) -> f64

Returns the maximum value of the Triangular distribution.

Returns

The maximum value of the distribution as an f64.

Examples

use distimate::prelude::*;
use distimate::Triangular;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_eq!(triangular.max(), 3.0);

impl Median<f64> for Triangular

Implementation of the Median trait for the Triangular distribution.

fn median(&self) -> f64

Calculates the median of the Triangular distribution.

The median is the value separating the higher half from the lower half of the distribution.

Returns

The median of the distribution as an f64 value.

Examples

use distimate::prelude::*;
use distimate::Triangular;
use approx::assert_relative_eq;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_relative_eq!(triangular.median(), 2.0, epsilon = 1e-6);

impl Min<f64> for Triangular

Implementation of the Min trait for the Triangular distribution.

fn min(&self) -> f64

Returns the minimum value of the Triangular distribution.

Returns

The minimum value of the distribution as an f64.

Examples

use distimate::prelude::*;
use distimate::Triangular;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_eq!(triangular.min(), 1.0);

impl Mode<f64> for Triangular

Implementation of the Mode trait for the Triangular distribution.

fn mode(&self) -> f64

Returns the mode of the Triangular distribution.

The mode is the most likely value of the distribution, which is one of the defining parameters of the Triangular distribution.

Returns

The mode of the distribution as an f64 value.

Examples

use distimate::prelude::*;
use distimate::Triangular;

let triangular = Triangular::new(1.0, 2.0, 3.0).unwrap();
assert_eq!(triangular.mode(), 2.0);