Struct math_functions::F2D

pub struct F2D(_);

Representation of a function with 2 variables

Implementations

impl F2D

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

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

use math_functions::{F1D,F2D,F3D, 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 = F2D::build("y(POWER+POWER)", &ctx).unwrap();

assert_eq!(func2, F2D::from_str("y(x^2+x^2)").unwrap());

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

Evaluate F2D at a given (x,y)

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

let func = F2D::from_str("ysin(x)").unwrap();

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

pub fn derivative(&self) -> Vec2<Self>

Computes the derivative of a F2D

use math_functions::{F2D, Vec2};
use std::str::FromStr;

let func = F2D::from_str("yln(x)").unwrap();

assert_eq!(func.derivative(), Vec2{ x: F2D::from_str("y/x").unwrap(), y:
F2D::from_str("ln(x)").unwrap()});

impl F2D

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

Raise function to a f64

Trait Implementations

impl Add<F2D> for F2D

type Output = F2D

The resulting type after applying the + operator.

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

Performs the + operation.

impl Debug for F2D

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

Formats the value using the given formatter.

impl Display for F2D

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

Formats the value using the given formatter.

impl Div<F2D> for F2D

type Output = F2D

The resulting type after applying the / operator.

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

Performs the / operation.

impl FromStr for F2D

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<F2D> for F2D

type Output = F2D

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq<F2D> for F2D

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

type Output = F2D

The resulting type after applying the - operator.

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

Performs the - operation.

impl StructuralPartialEq for F2D