Enum ExpressionClass 

pub enum ExpressionClass {
    Integer,
    Rational,
    UnivariatePolynomial {
        var: Symbol,
        degree: i64,
    },
    MultivariatePolynomial {
        vars: Vec<Symbol>,
        total_degree: i64,
    },
    RationalFunction,
    Transcendental,
    Symbolic,
}

Classification of expression type for algorithm routing

Used to select optimal algorithms based on expression structure. The classification determines which specialized algorithms to use for operations like GCD, factorization, and simplification.

Examples

use mathhook_core::core::expression::classification::ExpressionClass;
use mathhook_core::core::polynomial::PolynomialClassification;
use mathhook_core::{expr, symbol};

let x = symbol!(x);
let poly = expr!(x ^ 2);

match poly.classify() {
    ExpressionClass::UnivariatePolynomial { var, degree } => {
        assert_eq!(degree, 2);
    }
    _ => panic!("Expected univariate polynomial"),
}

Variants

Integer

Integer constant

Pure integer values like 0, 1, -5, 42. Fast-path for integer arithmetic.

Rational

Rational number

Fractions like 1/2, 3/4, -7/11. Uses rational arithmetic algorithms.

UnivariatePolynomial

Univariate polynomial in one variable

Polynomials like x^2 + 2x + 1, 3y^5 - y. Enables specialized univariate algorithms (Euclidean GCD, etc.).

Fields

var: Symbol

The variable of the polynomial

degree: i64

The degree of the polynomial

MultivariatePolynomial

Multivariate polynomial in multiple variables

Polynomials like x^2 + xy + y^2, xyz + 1. Uses multivariate algorithms (Buchberger, etc.).

Fields

vars: Vec<Symbol>

All variables in the polynomial

total_degree: i64

Total degree (sum of degrees in all variables)

RationalFunction

Rational function (ratio of polynomials)

Expressions like (x+1)/(x-1), 1/(x^2+1). Requires special handling for simplification.

Transcendental

Contains transcendental functions (sin, cos, exp, log)

Expressions involving sin, cos, tan, exp, log, etc. Limited algebraic simplification possible.

Symbolic

Symbolic expression that doesn’t fit other categories

General symbolic expressions that don’t match any of the more specific classifications.

Trait Implementations

impl Clone for ExpressionClass

fn clone(&self) -> ExpressionClass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionClass

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

Formats the value using the given formatter.

impl PartialEq for ExpressionClass

fn eq(&self, other: &ExpressionClass) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ExpressionClass