Function System

MathHook provides a comprehensive mathematical function system with intelligent evaluation, symbolic manipulation, and educational explanations. Functions are first-class expressions supporting exact symbolic computation and high-performance numerical evaluation through a modular intelligence architecture.

πŸ“

Mathematical Definition

Functions in MathHook follow standard mathematical definitions:

Trigonometric:

sin⁑(x),cos⁑(x),tan⁑(x)\sin(x), \cos(x), \tan(x)
with periodicity
2Ο€2\pi

Exponential/Logarithmic:

ex,ln⁑(x),log⁑b(x)=ln⁑(x)ln⁑(b)e^x, \ln(x), \log_b(x) = \frac{\ln(x)}{\ln(b)}

Special Functions:

Ξ“(n)=∫0∞tnβˆ’1eβˆ’tdt\Gamma(n) = \int_0^{\infty} t^{n-1} e^{-t} dt

Code Examples

Creating Functions with Macros

Using function! and expr! macros for ergonomic function creation

use mathhook::prelude::*;

let x = symbol!(x);

// Single argument functions
let sine = function!(sin, x);
let cosine = function!(cos, x);

// Multi-argument functions
let log_base = function!(log, x, 10);

// Using expr! macro
let trig_identity = expr!(sin(x)^2 + cos(x)^2);
assert_eq!(trig_identity.simplify(), Expression::integer(1));

Trigonometric Functions with Exact Values

Automatic recognition of exact trigonometric values at special angles

use mathhook::prelude::*;

// Exact values recognized
assert_eq!(expr!(sin(0)), expr!(0));
assert_eq!(expr!(sin(pi/6)), expr!(1/2));
assert_eq!(expr!(sin(pi/4)), expr!(sqrt(2)/2));
assert_eq!(expr!(sin(pi/2)), expr!(1));

assert_eq!(expr!(cos(0)), expr!(1));
assert_eq!(expr!(cos(pi/3)), expr!(1/2));
assert_eq!(expr!(cos(pi/2)), expr!(0));

Logarithm and Exponential Identities

Automatic application of logarithm laws and exponential identities

use mathhook::prelude::*;

let a = symbol!(a);
let b = symbol!(b);
let n = symbol!(n);

// Logarithm laws
assert_eq!(expr!(ln(a*b)).expand(), expr!(ln(a) + ln(b)));
assert_eq!(expr!(ln(a/b)).expand(), expr!(ln(a) - ln(b)));
assert_eq!(expr!(ln(a^n)).expand(), expr!(n*ln(a)));

// Exponential identities
assert_eq!(expr!(e^(ln(a))).simplify(), a);
assert_eq!(expr!(ln(e^a)).simplify(), a);

Function Derivatives (Automatic Chain Rule)

Functions know their derivatives with automatic chain rule application

use mathhook::prelude::*;

let x = symbol!(x);

// Basic derivatives
assert_eq!(expr!(sin(x)).derivative(&x, 1), expr!(cos(x)));
assert_eq!(expr!(cos(x)).derivative(&x, 1), expr!(-sin(x)));
assert_eq!(expr!(exp(x)).derivative(&x, 1), expr!(exp(x)));
assert_eq!(expr!(ln(x)).derivative(&x, 1), expr!(1/x));

// Chain rule automatic
let f = expr!(sin(x^2));
assert_eq!(f.derivative(&x, 1), expr!(2*x*cos(x^2)));

Special Functions (Gamma and Bessel)

Advanced special functions for scientific and engineering applications

use mathhook::prelude::*;

// Gamma function (factorial generalization)
assert_eq!(expr!(gamma(1)), expr!(1));   // Ξ“(1) = 0! = 1
assert_eq!(expr!(gamma(5)), expr!(24));  // Ξ“(5) = 4! = 24
assert_eq!(expr!(gamma(1/2)), expr!(sqrt(pi)));

// Bessel functions (wave propagation)
let x = symbol!(x);
let bessel_j0 = expr!(bessel_j(0, x));
let bessel_y0 = expr!(bessel_y(0, x));

Real-World Physics Application

Damped harmonic oscillator using exponential and trigonometric functions

use mathhook::prelude::*;

// Damped harmonic motion: x(t) = A*e^(-Ξ³t)*cos(Ο‰t + Ο†)
let t = symbol!(t);
let A = expr!(1);
let gamma = expr!(0.1);
let omega = expr!(2*pi);
let phi = expr!(0);

let position = expr!(A * e^(-gamma*t) * cos(omega*t + phi));
let velocity = position.derivative(&t, 1);
let acceleration = velocity.derivative(&t, 1);

// Verify: ẍ + 2Ξ³αΊ‹ + ω²x = 0
let lhs = expr!(acceleration + 2*gamma*velocity + (omega^2)*position);
assert_eq!(lhs.simplify(), expr!(0));

πŸ”— Related Topics

Browse All Topics
Explore the full documentation library