Struct HigherOrderDerivatives 

pub struct HigherOrderDerivatives;

Higher-order derivative operations

Implementations

impl HigherOrderDerivatives

pub fn compute(expr: &Expression, variable: Symbol, order: u32) -> Expression

Compute nth-order derivative

Examples

use mathhook_core::simplify::Simplify;
use mathhook_core::calculus::derivatives::Derivative;
use mathhook_core::{Expression};
use mathhook_core::symbol;
use mathhook_core::calculus::derivatives::HigherOrderDerivatives;

let x = symbol!(x);
let expr = Expression::pow(Expression::symbol(x.clone()), Expression::integer(4));
let second_derivative = HigherOrderDerivatives::compute(&expr, x, 2);

pub fn mixed_partial( expr: &Expression, derivatives: Vec<(Symbol, u32)>, ) -> Expression

Compute mixed partial derivatives

Examples

use mathhook_core::{Expression, symbol};
use mathhook_core::calculus::derivatives::HigherOrderDerivatives;

let x = symbol!(x);
let y = symbol!(y);
let expr = Expression::mul(vec![
    Expression::pow(Expression::symbol(x.clone()), Expression::integer(2)),
    Expression::symbol(y.clone())
]);
let mixed_partial = HigherOrderDerivatives::mixed_partial(&expr, vec![(x.clone(), 1), (y.clone(), 1)]);

pub fn exists(expr: &Expression, variable: Symbol, order: u32) -> bool

Check if higher-order derivative exists

Examples

use mathhook_core::simplify::Simplify;
use mathhook_core::calculus::derivatives::Derivative;
use mathhook_core::{Expression, symbol};
use mathhook_core::calculus::derivatives::HigherOrderDerivatives;

let x = symbol!(x);
let expr = Expression::function("sin", vec![Expression::symbol(x.clone())]);
let exists = HigherOrderDerivatives::exists(&expr, x.clone(), 5);

pub fn derivative_table( expr: &Expression, variable: &Symbol, max_order: u32, ) -> Vec<Expression>

Compute derivative table up to specified order

Examples

use mathhook_core::{Expression, symbol};
use mathhook_core::calculus::derivatives::HigherOrderDerivatives;

let x = symbol!(x);
let expr = Expression::function("sin", vec![Expression::symbol(x.clone())]);
let table = HigherOrderDerivatives::derivative_table(&expr, &x, 4);

pub fn find_pattern( expr: &Expression, variable: Symbol, check_orders: u32, ) -> Option<u32>

Find pattern in higher-order derivatives

Examples

use mathhook_core::{Expression, symbol};
use mathhook_core::calculus::derivatives::HigherOrderDerivatives;

let x = symbol!(x);
let expr = Expression::function("sin", vec![Expression::symbol(x.clone())]);
let pattern = HigherOrderDerivatives::find_pattern(&expr, x.clone(), 8);

pub fn leibniz_rule( u: &Expression, v: &Expression, variable: &Symbol, n: u32, ) -> Expression

Compute Leibniz rule for nth derivative of product

Examples

use mathhook_core::simplify::Simplify;
use mathhook_core::{Expression, symbol};
use mathhook_core::calculus::derivatives::HigherOrderDerivatives;

let x = symbol!(x);
let u = Expression::symbol(x.clone());
let v = Expression::function("sin", vec![Expression::symbol(x.clone())]);
let nth_product = HigherOrderDerivatives::leibniz_rule(&u, &v, &x, 3);

pub fn faa_di_bruno( outer_function: &str, inner_function: &Expression, variable: Symbol, n: u32, ) -> Expression

Compute Faà di Bruno’s formula for chain rule higher derivatives

Examples

use mathhook_core::{Expression, symbol};
use mathhook_core::calculus::derivatives::HigherOrderDerivatives;

let x = symbol!(x);
let inner = Expression::pow(Expression::symbol(x.clone()), Expression::integer(2));
let outer_name = "sin";
let chain_derivative = HigherOrderDerivatives::faa_di_bruno(outer_name, &inner, x.clone(), 2);