Struct au::rational_function::Rf

pub struct Rf<T> { /* fields omitted */ }

Rational function

Implementations

impl<T> Rf<T>

Implementation of rational function methods

pub fn inv_mut(&mut self)

Compute the reciprocal of a rational function in place.

impl<T> Rf<T>

#[must_use]pub fn new(num: Poly<T>, den: Poly<T>) -> Self

Create a new rational function given its numerator and denominator

Arguments

• num - Rational function numerator
• den - Rational function denominator

Example

use au::{poly, Rf};
let rf = Rf::new(poly!(1., 2.), poly!(-4., 6., -2.));

#[must_use]pub fn num(&self) -> &Poly<T>

Extract rational function numerator

Example

use au::{poly, Rf};
let num = poly!(1., 2.);
let rf = Rf::new(num.clone(), poly!(-4., 6., -2.));
assert_eq!(&num, rf.num());

#[must_use]pub fn den(&self) -> &Poly<T>

Extract rational function denominator

Example

use au::{poly, Rf};
let den = poly!(-4., 6., -2.);
let rf = Rf::new(poly!(1., 2.), den.clone());
assert_eq!(&den, rf.den());

impl<T: Clone + PartialEq + Zero> Rf<T>

#[must_use]pub fn relative_degree(&self) -> i32

Calculate the relative degree between denominator and numerator.

Example

use au::{num_traits::Inv, poly, Rf};
let rf = Rf::new(poly!(1., 2.), poly!(-4., 6., -2.));
let expected = rf.relative_degree();
assert_eq!(expected, 1);
assert_eq!(rf.inv().relative_degree(), -1);

impl<T: Float + RealField> Rf<T>

#[must_use]pub fn real_poles(&self) -> Option<Vec<T>>

Calculate the poles of the rational function

#[must_use]pub fn complex_poles(&self) -> Vec<Complex<T>>

Calculate the poles of the rational function

#[must_use]pub fn real_zeros(&self) -> Option<Vec<T>>

Calculate the zeros of the rational function

#[must_use]pub fn complex_zeros(&self) -> Vec<Complex<T>>

Calculate the zeros of the rational function

impl<T: Clone + Div<Output = T> + One + PartialEq + Zero> Rf<T>

#[must_use]pub fn normalize(&self) -> Self

Normalization of rational function. If the denominator is zero the same rational function is returned.

from:

       b_n*z^n + b_(n-1)*z^(n-1) + ... + b_1*z + b_0
G(z) = ---------------------------------------------
       a_n*z^n + a_(n-1)*z^(n-1) + ... + a_1*z + a_0

to:

       b'_n*z^n + b'_(n-1)*z^(n-1) + ... + b'_1*z + b'_0
G(z) = -------------------------------------------------
         z^n + a'_(n-1)*z^(n-1) + ... + a'_1*z + a'_0

Example

use au::{poly, Rf};
let rf = Rf::new(poly!(1., 2.), poly!(-4., 6., -2.));
let expected = Rf::new(poly!(-0.5, -1.), poly!(2., -3., 1.));
assert_eq!(expected, rf.normalize());

pub fn normalize_mut(&mut self)

In place normalization of rational function. If the denominator is zero no operation is done.

from:

       b_n*z^n + b_(n-1)*z^(n-1) + ... + b_1*z + b_0
G(z) = ---------------------------------------------
       a_n*z^n + a_(n-1)*z^(n-1) + ... + a_1*z + a_0

to:

       b'_n*z^n + b'_(n-1)*z^(n-1) + ... + b'_1*z + b'_0
G(z) = -------------------------------------------------
         z^n + a'_(n-1)*z^(n-1) + ... + a'_1*z + a'_0

Example

use au::{poly, Rf};
let mut rf = Rf::new(poly!(1., 2.), poly!(-4., 6., -2.));
rf.normalize_mut();
let expected = Rf::new(poly!(-0.5, -1.), poly!(2., -3., 1.));
assert_eq!(expected, rf);

impl<T: Clone> Rf<T>

pub fn eval_by_val<N>(&self, s: N) -> N where
    N: Add<T, Output = N> + Clone + Div<Output = N> + Mul<Output = N> + Zero, 

Evaluate the rational function.

Arguments

• s - Value at which the rational function is evaluated.

Example

use au::{poly, Rf};
use au::num_complex::Complex as C;
let rf = Rf::new(poly!(1., 2., 3.), poly!(-4., -3., 1.));
assert_eq!(-8.5, rf.eval_by_val(3.));
assert_eq!(C::new(0.64, -0.98), rf.eval_by_val(C::new(0., 2.0_f32)));

impl<T> Rf<T>

pub fn eval<'a, N>(&'a self, s: &'a N) -> N where
    T: 'a,
    N: 'a + Add<&'a T, Output = N> + Div<Output = N> + Mul<&'a N, Output = N> + Zero, 

Evaluate the rational function.

Arguments

• s - Value at which the rational function is evaluated.

Example

use au::{poly, Rf};
use au::num_complex::Complex as C;
let rf = Rf::new(poly!(1., 2., 3.), poly!(-4., -3., 1.));
assert_eq!(-8.5, rf.eval(&3.));
assert_eq!(C::new(0.64, -0.98), rf.eval(&C::new(0., 2.0_f32)));

Trait Implementations

impl<T: Clone + Mul<Output = T> + One + PartialEq + Zero> Add<&'_ Rf<T>> for &Rf<T>

Implementation of rational function addition

type Output = Rf<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Clone + Mul<Output = T> + PartialEq + Zero> Add<&'_ T> for Rf<T>

Implementation of rational function addition

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: &T) -> Self

Performs the + operation.

impl<T: Clone + One + PartialEq + Zero> Add<Rf<T>> for Rf<T>

Implementation of rational function addition

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<T: Clone + Mul<Output = T> + PartialEq + Zero> Add<T> for Rf<T>

Implementation of rational function addition

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self

Performs the + operation.

impl<T: Clone> Clone for Rf<T>

fn clone(&self) -> Rf<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Rf<T>

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

Formats the value using the given formatter.

impl<T> Display for Rf<T> where
    T: Display + One + PartialEq + PartialOrd + Zero, 

Implementation of rational function printing

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

Formats the value using the given formatter.

impl<T: Clone + One + PartialEq + Zero> Div<&'_ Rf<T>> for &Rf<T>

Implementation of rational function division

type Output = Rf<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T: Clone + One + PartialEq + Zero> Div<Rf<T>> for Rf<T>

Implementation of rational function division

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl<T: Clone> Inv for &Rf<T>

type Output = Rf<T>

The result after applying the operator.

fn inv(self) -> Self::Output

Compute the reciprocal of a rational function.

impl<T: Clone> Inv for Rf<T>

type Output = Self

The result after applying the operator.

fn inv(self) -> Self::Output

Compute the reciprocal of a rational function.

impl<T: Clone + One + PartialEq + Zero> Mul<&'_ Rf<T>> for &Rf<T>

Implementation of rational function multiplication

type Output = Rf<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T: Clone + One + PartialEq + Zero> Mul<&'_ Rf<T>> for Rf<T>

Implementation of rational function multiplication

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: &Rf<T>) -> Self

Performs the * operation.

impl<T: Clone + One + PartialEq + Zero> Mul<Rf<T>> for Rf<T>

Implementation of rational function multiplication

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<T: Clone + Neg<Output = T>> Neg for &Rf<T>

Implementation of rational function negation. Negative sign is transferred to the numerator.

type Output = Rf<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Clone + Neg<Output = T>> Neg for Rf<T>

Implementation of rational function negation. Negative sign is transferred to the numerator.

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq<Rf<T>> for Rf<T>

fn eq(&self, other: &Rf<T>) -> bool

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

fn ne(&self, other: &Rf<T>) -> bool

This method tests for !=.

impl<T> StructuralPartialEq for Rf<T>

impl<T: Clone + Neg<Output = T> + PartialEq + Sub<Output = T> + Zero + One> Sub<&'_ Rf<T>> for &Rf<T>

Implementation of rational function subtraction

type Output = Rf<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: Clone + Neg<Output = T> + One + PartialEq + Sub<Output = T> + Zero> Sub<Rf<T>> for Rf<T>

Implementation of rational function subtraction

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<T: Clone + One + PartialEq + Zero> Zero for Rf<T>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

pub fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.