Trait exmex::Differentiate
source · pub trait Differentiate<'a, T>{
// Provided methods
fn partial(self, var_idx: usize) -> ExResult<Self> { ... }
fn partial_relaxed(
self,
var_idx: usize,
missing_op_mode: MissingOpMode,
) -> ExResult<Self> { ... }
fn partial_nth(self, var_idx: usize, n: usize) -> ExResult<Self> { ... }
fn partial_nth_relaxed(
self,
var_idx: usize,
n: usize,
missing_op_mode: MissingOpMode,
) -> ExResult<Self> { ... }
fn partial_iter<I>(self, var_idxs: I) -> ExResult<Self>
where I: Iterator<Item = usize> + Clone { ... }
fn partial_iter_relaxed<I>(
self,
var_idxs: I,
missing_op_mode: MissingOpMode,
) -> ExResult<Self>
where I: Iterator<Item = usize> + Clone { ... }
}
Expand description
feature = "partial"
- Trait for partial differentiation. This is implemented for expressions
with datatypes that implement DiffDataType
.
Provided Methods§
sourcefn partial(self, var_idx: usize) -> ExResult<Self>
fn partial(self, var_idx: usize) -> ExResult<Self>
feature = "partial"
- This method computes a new expression
that is the partial derivative of self
with default operators.
§Example
use exmex::prelude::*;
let expr = FlatEx::<f64>::parse("sin(1+y^2)*x")?;
let dexpr_dx = expr.partial(0)?;
assert!((dexpr_dx.eval(&[9e5, 2.0])? - (5.0 as f64).sin()).abs() < 1e-12);
// |
// The partial derivative dexpr_dx does depend on x. Still, it
// expects the same number of parameters as the corresponding
// antiderivative. Hence, you can pass any number for x.
§Arguments
var_idx
- variable with respect to which the partial derivative is computed
§Errors
- If you use custom operators this might not work as expected. It could return an
ExError
if an operator is not found or compute a wrong result if an operator is defined in an un-expected way.
sourcefn partial_relaxed(
self,
var_idx: usize,
missing_op_mode: MissingOpMode,
) -> ExResult<Self>
fn partial_relaxed( self, var_idx: usize, missing_op_mode: MissingOpMode, ) -> ExResult<Self>
Like Differentiate::partial
. The only difference is that in case there is no differentation defined for
a binary operator this will not necessarily throw an error depending on missing_op_mode
, see MissingOpMode
.
sourcefn partial_nth(self, var_idx: usize, n: usize) -> ExResult<Self>
fn partial_nth(self, var_idx: usize, n: usize) -> ExResult<Self>
feature = "partial"
- Computes the nth partial derivative with respect to one variable
§Example
use exmex::prelude::*;
let mut expr = FlatEx::<f64>::parse("x^4+y^4")?;
let dexpr_dxx_nth = expr.clone().partial_nth(0, 2)?;
let dexpr_dx = expr.partial(0)?;
let dexpr_dxx_2step = dexpr_dx.partial(0)?;
assert!((dexpr_dxx_2step.eval(&[4.3, 2.1])? - dexpr_dxx_nth.eval(&[4.3, 2.1])?).abs() < 1e-12);
§Arguments
var_idx
- variable with respect to which the partial derivative is computedn
- order of derivation
§Errors
- If you use custom operators this might not work as expected. It could return an
ExError
if an operator is not found or compute a wrong result if an operator is defined in an un-expected way.
sourcefn partial_nth_relaxed(
self,
var_idx: usize,
n: usize,
missing_op_mode: MissingOpMode,
) -> ExResult<Self>
fn partial_nth_relaxed( self, var_idx: usize, n: usize, missing_op_mode: MissingOpMode, ) -> ExResult<Self>
Like Differentiate::partial_nth
. The only difference is that in case there is no differentation defined for
a binary operator this will not necessarily throw an error depending on missing_op_mode
, see MissingOpMode
.
sourcefn partial_iter<I>(self, var_idxs: I) -> ExResult<Self>
fn partial_iter<I>(self, var_idxs: I) -> ExResult<Self>
feature = "partial"
- Computes a chain of partial derivatives with respect to the variables passed as iterator
§Example
use exmex::prelude::*;
let mut expr = FlatEx::<f64>::parse("x^4+y^4")?;
let dexpr_dxy_iter = expr.clone().partial_iter([0, 1].iter().copied())?;
let dexpr_dx = expr.partial(0)?;
let dexpr_dxy_2step = dexpr_dx.partial(1)?;
assert!((dexpr_dxy_2step.eval(&[4.3, 2.1])? - dexpr_dxy_iter.eval(&[4.3, 2.1])?).abs() < 1e-12);
§Arguments
var_idxs
- variables with respect to which the partial derivative is computedn
- order of derivation
§Errors
- If you use custom operators this might not work as expected. It could return an
ExError
if an operator is not found or compute a wrong result if an operator is defined in an un-expected way.
sourcefn partial_iter_relaxed<I>(
self,
var_idxs: I,
missing_op_mode: MissingOpMode,
) -> ExResult<Self>
fn partial_iter_relaxed<I>( self, var_idxs: I, missing_op_mode: MissingOpMode, ) -> ExResult<Self>
Like Differentiate::partial_iter
. The only difference is that in case there is no differentation defined for
a binary this will not necessarily throw an error depending on missing_op_mode
, see MissingOpMode
.