Enum FunctionProperties 

pub enum FunctionProperties {
    Elementary(Box<ElementaryProperties>),
    Special(Box<SpecialProperties>),
    Polynomial(Box<PolynomialProperties>),
    UserDefined(Box<UserProperties>),
}

Mathematical properties for all function types

Boxed variants to minimize memory footprint while providing comprehensive mathematical intelligence.

Memory Layout Optimization

• Uses Box<T> to keep enum size small (8 bytes per variant)
• Reduces memory fragmentation through consistent allocation patterns
• Enables efficient cache utilization for hot path operations

Variants

Elementary(Box<ElementaryProperties>)

Elementary functions: sin, cos, exp, log, etc.

Special(Box<SpecialProperties>)

Special functions: gamma, bessel, zeta, etc.

Polynomial(Box<PolynomialProperties>)

Polynomial families: legendre, hermite, laguerre, etc.

UserDefined(Box<UserProperties>)

User-defined functions: f, g, h, etc.

Implementations

impl FunctionProperties

pub fn has_derivative(&self) -> bool

Check if function has derivative rule

Hot path method for performance-critical operations

pub fn has_antiderivative(&self) -> bool

Check if function has antiderivative rule

Hot path method for performance-critical operations

pub fn get_derivative_rule(&self) -> Option<&DerivativeRule>

Get derivative rule if available

Returns a reference to the derivative rule for registry-based differentiation

pub fn get_derivative_expression(&self, arg: &Expression) -> Option<Expression>

Get derivative expression using registry rules

Computes the derivative of f(arg) with respect to arg using the registered derivative rule. The chain rule (multiplying by d(arg)/dx) must be applied separately.

Arguments

• arg - The argument expression to the function

Returns

Returns the derivative expression, or None if no derivative rule exists

Examples

use mathhook_core::functions::intelligence::get_universal_registry;
use mathhook_core::{expr, symbol};

let registry = get_universal_registry();
let x = symbol!(x);

if let Some(props) = registry.get_properties("sin") {
    let derivative = props.get_derivative_expression(&x.into());
}

pub fn get_antiderivative_rule(&self) -> Option<&AntiderivativeRule>

Get antiderivative rule if available

Returns a reference to the antiderivative rule for registry-based integration

pub fn special_value_count(&self) -> usize

Get special value count for caching optimization

pub fn family(&self) -> FunctionFamily

Get function family for quick classification

pub fn wolfram_name(&self) -> Option<&'static str>

Get Wolfram Language function name

Used for Wolfram formatting without hardcoded function name matching. Returns the Wolfram name if registered, otherwise None.

Examples

use mathhook_core::functions::intelligence::get_universal_registry;

let registry = get_universal_registry();
if let Some(props) = registry.get_properties("sin") {
    assert_eq!(props.wolfram_name(), Some("Sin"));
}
if let Some(props) = registry.get_properties("ln") {
    assert_eq!(props.wolfram_name(), Some("Log"));
}

Trait Implementations

impl Clone for FunctionProperties

fn clone(&self) -> FunctionProperties

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FunctionProperties

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

Formats the value using the given formatter.