Struct FunctionIntegrals 

pub struct FunctionIntegrals;

Function integration handler

Implementations

impl FunctionIntegrals

pub fn integrate( name: &str, args: &[Expression], variable: Symbol, ) -> Expression

Integrate function expressions using known antiderivatives

Examples

use mathhook_core::{Expression, FunctionIntegrals};
use mathhook_core::symbol;

let x = symbol!(x);
let args = vec![Expression::symbol(x.clone())];
let result = FunctionIntegrals::integrate("sin", &args, x.clone());

let expected = Expression::mul(vec![
    Expression::integer(-1),
    Expression::function("cos", vec![Expression::symbol(x)]),
]);
assert_eq!(result, expected);

pub fn integrate_simple_function(name: &str, variable: Symbol) -> Expression

Integrate simple functions f(x) using standard antiderivatives

Examples

use mathhook_core::{Expression, FunctionIntegrals};
use mathhook_core::symbol;

let x = symbol!(x);
let result = FunctionIntegrals::integrate_simple_function("sin", x.clone());

let expected = Expression::mul(vec![
    Expression::integer(-1),
    Expression::function("cos", vec![Expression::symbol(x)]),
]);
assert_eq!(result, expected);

pub fn integrate_composite_function( name: &str, inner: &Expression, variable: Symbol, ) -> Expression

Integrate composite functions f(g(x)) using substitution when possible

Examples

use mathhook_core::{Expression, FunctionIntegrals};
use mathhook_core::symbol;

let x = symbol!(x);
let inner = Expression::mul(vec![
    Expression::integer(2),
    Expression::symbol(x.clone()),
]);
let result = FunctionIntegrals::integrate_composite_function("sin", &inner, x.clone());

let expected = Expression::mul(vec![
    Expression::pow(Expression::integer(2), Expression::integer(-1)),
    Expression::mul(vec![
        Expression::integer(-1),
        Expression::function("cos", vec![
            Expression::mul(vec![
                Expression::integer(2),
                Expression::symbol(x),
            ])
        ]),
    ]),
]);
assert_eq!(result, expected);

pub fn integrate_linear_substitution( name: &str, coefficient: &Expression, variable: Symbol, ) -> Expression

Handle integration of f(ax) where a is constant

Examples

use mathhook_core::{Expression, FunctionIntegrals};
use mathhook_core::symbol;

let x = symbol!(x);
let a = Expression::integer(3);
let result = FunctionIntegrals::integrate_linear_substitution("sin", &a, x.clone());

let expected = Expression::mul(vec![
    Expression::pow(Expression::integer(3), Expression::integer(-1)),
    Expression::mul(vec![
        Expression::integer(-1),
        Expression::function("cos", vec![
            Expression::mul(vec![
                Expression::integer(3),
                Expression::symbol(x),
            ])
        ]),
    ]),
]);
assert_eq!(result, expected);