Struct fitting::Gaussian

pub struct Gaussian<F: Float> { /* private fields */ }

Gaussian Distribution

Implementations

impl<F: Float> Gaussian<F>

pub fn new(mu: F, sigma: F, a: F) -> Gaussian<F>

Create a new Gaussian with given parameters.

pub fn mu(&self) -> &F

Return a reference to mu.

pub fn mu_mut(&mut self) -> &mut F

Return a mutable reference to mu.

pub fn sigma(&self) -> &F

Return a reference to sigma.

pub fn sigma_mut(&mut self) -> &mut F

Return a mutable reference to sigma.

pub fn a(&self) -> &F

Return a reference to a.

pub fn a_mut(&mut self) -> &mut F

Return a mutable reference to a.

pub fn as_tuple(&self) -> (&F, &F, &F)

Return a reference to self as a tuple (mu, sigma, a).

pub fn as_mut_tuple(&mut self) -> (&mut F, &mut F, &mut F)

Return a mutable reference to self as a tuple (mu, sigma, a).

pub fn to_tuple(&self) -> (F, F, F)

Returns a copy of self as a new tuple (mu, sigma, a).

pub fn into_tuple(self) -> (F, F, F)

Consume self and returns a tuple (mu, sigma, a).

pub fn value(&self, x: F) -> F

Returns a value of gaussian function.

Examples

Returns a value of gaussian function.

use fitting::Gaussian;

let gaussian = Gaussian::new(5., 3., 1.);
let x = 5.;
let y = gaussian.value(x);
assert_eq!(&y, gaussian.a());

pub fn values(&self, x_vec: Array1<F>) -> Array1<F>

Returns the values of gaussian function.

Examples

Returns the values of gaussian function.

use fitting::approx::assert_abs_diff_eq;
use fitting::Gaussian;
use fitting::ndarray::{array, Array, Array1};

let gaussian = Gaussian::new(5., 3., 1.);
let x_vec: Array1<f64> = Array::range(1., 10., 1.);
let y_vec: Array1<f64> = gaussian.values(x_vec);
let expected_ans = array![
    0.41111229050718745,
    0.6065306597126334,
    0.8007374029168081,
    0.9459594689067654,
    1.,
    0.9459594689067654,
    0.8007374029168081,
    0.6065306597126334,
    0.41111229050718745
];
assert_abs_diff_eq!(&y_vec, &expected_ans, epsilon = 1e-9);

pub fn fit(x_vec: Array1<F>, y_vec: Array1<F>) -> Result<Gaussian<F>, Error>

Estimates the parameters of gaussian function for generic data. The return value is (mu, sigma, a)

This function implements the Guos Algorithm.

Examples

Estimates the parameters for sample data.

use fitting::approx::assert_abs_diff_eq;
use fitting::Gaussian;
use fitting::ndarray::{array, Array, Array1};

let gaussian = Gaussian::new(5., 3., 1.);
let x_vec: Array1<f64> = Array::range(1., 10., 1.);
let y_vec: Array1<f64> = gaussian.values(x_vec.clone());
let estimated = Gaussian::fit(x_vec, y_vec).unwrap();
assert_abs_diff_eq!(gaussian, estimated, epsilon = 1e-9);

Limitations

• x_vec must have at least one element
• All elements of y_vec must be positive numbers
• If the distribution is “long-tailed”, it affects the fitting accuracy.
  • A detailed description can be found in Reference 1.
  • Also, you can see the reproduction and workaround in GitHub.

References

[1] E. Pastuchov ́a and M. Z ́akopˇcan, ”Comparison of Algorithms for Fitting a Gaussian Function used in Testing Smart Sensors”, Journal of Electrical Engineering, vol. 66, no. 3, pp. 178-181, 2015.

Trait Implementations

impl<F: Float> AbsDiffEq<Gaussian<F>> for Gaussian<F>where
    F::Epsilon: Copy,

type Epsilon = <F as AbsDiffEq<F>>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> F::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: F::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<F: Clone + Float> Clone for Gaussian<F>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Float> Debug for Gaussian<F>

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

Formats the value using the given formatter.

impl<F: Default + Float> Default for Gaussian<F>

fn default() -> Gaussian<F>

Returns the “default value” for a type.

impl<'de, F> Deserialize<'de> for Gaussian<F>where
    F: Deserialize<'de> + Float,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F: Float> From<(F, F, F)> for Gaussian<F>

fn from(tuple: (F, F, F)) -> Self

Converts to this type from the input type.

impl<F: Float> From<Gaussian<F>> for (F, F, F)

fn from(gaussian: Gaussian<F>) -> Self

Converts to this type from the input type.

impl<F: Float> From<Gaussian<F>> for Array1<F>

fn from(gaussian: Gaussian<F>) -> Self

Converts to this type from the input type.

impl<F: Hash + Float> Hash for Gaussian<F>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: PartialEq + Float> PartialEq<Gaussian<F>> for Gaussian<F>

fn eq(&self, other: &Gaussian<F>) -> 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<F: PartialOrd + Float> PartialOrd<Gaussian<F>> for Gaussian<F>

fn partial_cmp(&self, other: &Gaussian<F>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<F: Float> RelativeEq<Gaussian<F>> for Gaussian<F>where
    F::Epsilon: Copy,

fn default_max_relative() -> F::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    other: &Self,
    epsilon: F::Epsilon,
    max_relative: F::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<F> Serialize for Gaussian<F>where
    F: Serialize + Float,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F: Float> TryFrom<ArrayBase<OwnedRepr<F>, Dim<[usize; 1]>>> for Gaussian<F>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(arr: Array1<F>) -> Result<Self, Self::Error>

Performs the conversion.

impl<F: Float> UlpsEq<Gaussian<F>> for Gaussian<F>where
    F::Epsilon: Copy,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: F::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<F: Copy + Float> Copy for Gaussian<F>

impl<F: Eq + Float> Eq for Gaussian<F>

impl<F: Float> StructuralEq for Gaussian<F>

impl<F: Float> StructuralPartialEq for Gaussian<F>