Struct MathUtils 

pub struct MathUtils {}

Implementations

impl MathUtils

pub const LOG10_P_OF_ZERO: f64 = -1.0E+6f64

pub fn median_clone<T: PartialOrd + Copy>(numbers: &[T]) -> T

pub fn median<T: Ord + PartialOrd + Copy>(numbers: &mut [T]) -> T

pub fn normalize_pls(pls: &[f64]) -> Vec<f64>

pub fn ebe_add_in_place<T: Send + Sync + Add + Copy + AddAssign>( a: &mut [T], b: &[T], )

Element by elemnt addition of two vectors in place

pub fn ebe_add<T: Send + Sync + Add + Copy + Add<Output = T>>( a: &[T], b: &[T], ) -> Vec<T>

Element by elemnt addition of two vectors

pub fn ebe_subtract<T: Send + Sync + Sub + Copy + Sub<Output = T>>( a: &[T], b: &[T], ) -> Vec<T>

Element by elemnt subtraction of two vectors

pub fn ebe_multiply<T: Send + Sync + Mul + Copy + Mul<Output = T>>( a: &[T], b: &[T], ) -> Vec<T>

Element by elemnt multiplication of two vectors

pub fn dot_product<T: Send + Sync + Mul + Add + Copy + Mul<Output = T> + Add<Output = T> + Sum>( a: &[T], b: &[T], ) -> T

calculates the dot product of two vectors

pub fn log_to_log10(ln: f64) -> f64

Converts LN to LOG10 @param ln log(x) @return log10(x)

pub fn log10_binomial_coeffecient(n: f64, k: f64) -> f64

@see #binomialCoefficient(int, int) with log10 applied to result

pub fn log10_factorial(n: f64) -> f64

pub fn max_element_index(array: &[f64], start: usize, finish: usize) -> usize

Gets the maximum element’s index of an array of f64 values Rather convoluted due to Rust not allowing proper comparisons between floats

pub fn normalize_log10(array: Vec<f64>, take_log10_of_output: bool) -> Vec<f64>

pub fn log10_sum_log10(log10_values: &[f64], start: usize, finish: usize) -> f64

pub fn log10_sum_log10_two_values(a: f64, b: f64) -> f64

pub fn log10_sum_log10_three_values(a: f64, b: f64, c: f64) -> f64

Do the log-sum trick for three double values. @param a @param b @param c @return the sum… perhaps NaN or infinity if it applies.

pub fn scale_log_space_array_for_numeric_stability(array: &[f64]) -> Vec<f64>

Given an array of log space (log or log10) values, subtract all values by the array maximum so that the max element in log space is zero. This is equivalent to dividing by the maximum element in real space and is useful for avoiding underflow/overflow when the array’s values matter only up to an arbitrary normalizing factor, for example, an array of likelihoods.

@param array @return the scaled-in-place array

pub fn normalize_from_log10( array: &[f64], take_log10_of_output: bool, keep_in_log_space: bool, ) -> Vec<f64>

See #normalizeFromLog10 but with the additional option to use an approximation that keeps the calculation always in log-space

@param array @param takeLog10OfOutput @param keepInLogSpace

@return array

pub fn is_valid_log10_probability(result: f64) -> bool

pub fn log10_to_log(log10: f64) -> f64

pub fn log10_one_minus_pow10(a: f64) -> f64

Calculates {@code log10(1-10^a)} without losing precision.

@param a the input exponent. @return {@link Double#NaN NaN} if {@code a > 0}, otherwise the corresponding value.

pub fn approximate_log10_sum_log10(a: f64, b: f64) -> f64

pub fn approximate_log10_sum_log10_vec( vals: &[f64], from_index: usize, to_index: usize, ) -> f64

Calculate the approximate log10 sum of an array range. @param vals the input values. @param fromIndex the first inclusive index in the input array. @param toIndex index following the last element to sum in the input array (exclusive). @return the approximate sum. @throws IllegalArgumentException if {@code vals} is {@code null} or {@code fromIndex} is out of bounds or if {@code toIndex} is larger than the length of the input array or {@code fromIndex} is larger than {@code toIndex}.

pub fn well_formed_f64(val: f64) -> bool

pub fn normal_distribution(mean: f64, sd: f64, x: f64) -> f64

Calculate f(x) = Normal(x | mu = mean, sigma = sd) @param mean the desired mean of the Normal distribution @param sd the desired standard deviation of the Normal distribution @param x the value to evaluate @return a well-formed double

pub fn normalize_sum_to_one(array: Vec<f64>) -> Vec<f64>

normalizes the real-space probability array.

Does not assume anything about the values in the array, beyond that no elements are below 0. It’s ok to have values in the array of > 1, or have the sum go above 0.

@param array the array to be normalized @return a newly allocated array corresponding the normalized values in array

pub fn fast_bernoulli_entropy(p: f64) -> f64

Computes the entropy -p*ln(p) - (1-p)*ln(1-p) of a Bernoulli distribution with success probability p using an extremely fast Pade approximation that is very accurate for all values of 0 <= p <= 1.

See http://www.nezumi.demon.co.uk/consult/logx.htm

pub fn is_valid_probability(result: f64) -> bool