Struct math_functions::F3D

pub struct F3D(_);

Representation of a function with 3 variables

Implementations

impl F3D

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

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

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

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

ctx.add_f2d("CUSTOM", &func);

let func2 = F3D::build("z(CUSTOM+CUSTOM)", &ctx).unwrap();

assert_eq!(func2, F3D::from_str("z(yx^2+yx^2)").unwrap());

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

Evaluate F3D at a given (x,y,z)

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

let func = F3D::from_str("ysin(x)ln(z)").unwrap();

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

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

Computes the gradient of a F3D

use math_functions::{F3D, Vec3};
use std::str::FromStr;

let func = F3D::from_str("xyz^2").unwrap();

assert_eq!(func.derivative(), Vec3{ x: F3D::from_str("yz^2").unwrap(), y:
F3D::from_str("xz^2").unwrap(), z: F3D::from_str("2xyz").unwrap()});

pub fn hessian(&self) -> Matrix<F3D>

Computes hessian matrix of the given function

use math_functions::{F3D, Matrix};
use std::str::FromStr;
let func = F3D::from_str("3x^2+y^4+xyz^2").unwrap();
let hessian = func.hessian();
println!("{}", hessian);
//|         6          |        z^2         |        2yz         |
//|        z^2         |       12y^2        |        2xz         |
//|        2yz         |        2xz         |        2xy         |
let result: Matrix<F3D> = Matrix::new(
   vec![
       F3D::from_str("6").unwrap(),
       F3D::from_str("z^2").unwrap(),
       F3D::from_str("2yz").unwrap(),
       F3D::from_str("z^2").unwrap(),
       F3D::from_str("12y^2").unwrap(),
       F3D::from_str("2xz").unwrap(),
       F3D::from_str("2yz").unwrap(),
       F3D::from_str("2xz").unwrap(),
       F3D::from_str("2xy").unwrap(),
   ],
   3,
   3,
);
assert_eq!(result, hessian);

impl F3D

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

Raise function to a f64

Trait Implementations

impl Add<F3D> for F3D

type Output = F3D

The resulting type after applying the + operator.

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

Performs the + operation.

impl Debug for F3D

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

Formats the value using the given formatter.

impl Display for F3D

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

Formats the value using the given formatter.

impl Div<F3D> for F3D

type Output = F3D

The resulting type after applying the / operator.

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

Performs the / operation.

impl FromStr for F3D

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

type Output = F3D

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq<F3D> for F3D

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

type Output = F3D

The resulting type after applying the - operator.

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

Performs the - operation.

impl StructuralPartialEq for F3D