Struct math_functions::F1D

pub struct F1D(_);

Representation of a function with 1 variable

Implementations

impl F1D

pub fn build(input: &str, ctx: &Context<'_>) -> Result<Self, ParsingError>

Builds a F1D from a string and a context (meaning that you can use already created functions)

use math_functions::{F1D, context::Context};
use std::str::FromStr;

let func = F1D::from_str("x^2").unwrap();
let mut ctx = Context::new();

ctx.add_f1d("POWER", &func);

let func2 = F1D::build("POWER(x)+POWER(x)", &ctx);

assert_eq!(func2, F1D::from_str("x^2+x^2"));

pub fn eval(&self, x: f64) -> f64

Evaluate F1D at a given x

use math_functions::{F1D,approx};
use std::str::FromStr;

let func = F1D::from_str("xsin(x)").unwrap();

assert_eq!(approx(func.eval(2.), 5), 1.81859);

pub fn derivative(&self) -> Self

Computes the derivative of a F1D

use math_functions::F1D;
use std::str::FromStr;

let func = F1D::from_str("xln(x)").unwrap();

assert_eq!(func.derivative(), F1D::from_str("ln(x)+1").unwrap());

pub fn integrate(&self, a: f64, b: f64, steps: u32) -> f64

Computes the definite integral of F1D

use math_functions::{F1D,approx};
use std::str::FromStr;

let func = F1D::from_str("x^2+6").unwrap();

assert_eq!(approx(func.integrate(0.,1., 10_000), 5), 6.33333)

impl F1D

pub fn powf(self, exp: f64) -> Self

Raise function to a f64

Trait Implementations

impl Add<F1D> for F1D

type Output = F1D

The resulting type after applying the + operator.

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

Performs the + operation.

impl Debug for F1D

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

Formats the value using the given formatter.

impl Display for F1D

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

Formats the value using the given formatter.

impl Div<F1D> for F1D

type Output = F1D

The resulting type after applying the / operator.

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

Performs the / operation.

impl FromStr for F1D

type Err = ParsingError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Mul<F1D> for F1D

type Output = F1D

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq<F1D> for F1D

fn eq(&self, other: &F1D) -> 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 Sub<F1D> for F1D

type Output = F1D

The resulting type after applying the - operator.

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

Performs the - operation.

impl StructuralPartialEq for F1D