mathhook-core 0.2.0

Core mathematical engine for MathHook - expressions, algebra, and solving
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Common factor extraction and GCD operations

use crate::core::{Expression, Number};
use num_bigint::BigInt;
use num_integer::Integer;
use num_traits::{One, Zero};

impl Expression {
    /// Find common factor in a list of terms
    pub(super) fn find_common_factor_in_terms(&self, terms: &[Expression]) -> Expression {
        if terms.is_empty() {
            return Expression::integer(1);
        }

        let mut common = self.extract_factors(&terms[0]);

        for term in &terms[1..] {
            let term_factors = self.extract_factors(term);
            common = self.intersect_factors(&common, &term_factors);

            if common.is_empty() {
                return Expression::integer(1);
            }
        }

        if common.is_empty() {
            Expression::integer(1)
        } else {
            Expression::mul(common)
        }
    }

    /// Extract factors from an expression
    pub(super) fn extract_factors(&self, expr: &Expression) -> Vec<Expression> {
        match expr {
            Expression::Number(Number::Integer(n)) => {
                if !n.is_zero() && !n.is_one() {
                    vec![expr.clone()]
                } else {
                    vec![]
                }
            }
            Expression::Symbol(_) => vec![expr.clone()],
            Expression::Mul(factors) => (**factors).clone(),
            Expression::Pow(base, _exp) => vec![(**base).clone()],
            _ => vec![expr.clone()],
        }
    }

    /// Find intersection of two factor lists
    pub(super) fn intersect_factors(
        &self,
        factors1: &[Expression],
        factors2: &[Expression],
    ) -> Vec<Expression> {
        let mut common = Vec::new();

        for factor1 in factors1 {
            if factors2.contains(factor1) {
                common.push(factor1.clone());
            }
        }

        let num1 = self.extract_numeric_factor(factors1);
        let num2 = self.extract_numeric_factor(factors2);

        if let (Some(n1), Some(n2)) = (num1, num2) {
            let gcd_num = n1.gcd(&n2);
            if !gcd_num.is_one() {
                common.push(Expression::big_integer(gcd_num));
            }
        }

        common
    }

    /// Extract numeric factor from factor list
    pub(super) fn extract_numeric_factor(&self, factors: &[Expression]) -> Option<BigInt> {
        for factor in factors {
            if let Expression::Number(Number::Integer(n)) = factor {
                return Some(BigInt::from(*n));
            }
        }
        None
    }

    /// Divide expression by a factor (simplified division)
    pub(super) fn divide_by_factor(&self, expr: &Expression, factor: &Expression) -> Expression {
        match (expr, factor) {
            (Expression::Number(Number::Integer(a)), Expression::Number(Number::Integer(b))) => {
                if !b.is_zero() && (a % b).is_zero() {
                    Expression::integer(a / b)
                } else {
                    expr.clone()
                }
            }

            (Expression::Symbol(s1), Expression::Symbol(s2)) if s1 == s2 => Expression::integer(1),

            (Expression::Mul(factors), _) => {
                let mut remaining_factors = factors.as_ref().clone();
                if let Some(pos) = remaining_factors.iter().position(|f| f == factor) {
                    remaining_factors.remove(pos);
                    if remaining_factors.is_empty() {
                        Expression::integer(1)
                    } else if remaining_factors.len() == 1 {
                        remaining_factors[0].clone()
                    } else {
                        Expression::mul(remaining_factors)
                    }
                } else {
                    expr.clone()
                }
            }

            _ => expr.clone(),
        }
    }

    /// Factor out numeric coefficients
    pub fn factor_numeric_coefficient(&self) -> (BigInt, Expression) {
        match self {
            Expression::Number(Number::Integer(n)) => (BigInt::from(*n), Expression::integer(1)),
            Expression::Number(Number::BigInteger(n)) => {
                (n.as_ref().clone(), Expression::integer(1))
            }
            Expression::Mul(factors) => {
                let mut coefficient = BigInt::one();
                let mut non_numeric_factors = Vec::new();

                for factor in factors.iter() {
                    match factor {
                        Expression::Number(Number::Integer(n)) => {
                            coefficient *= BigInt::from(*n);
                        }
                        Expression::Number(Number::BigInteger(n)) => {
                            coefficient *= n.as_ref();
                        }
                        _ => {
                            non_numeric_factors.push(factor.clone());
                        }
                    }
                }

                let remaining = if non_numeric_factors.is_empty() {
                    Expression::integer(1)
                } else if non_numeric_factors.len() == 1 {
                    non_numeric_factors[0].clone()
                } else {
                    Expression::mul(non_numeric_factors)
                };

                (coefficient, remaining)
            }
            _ => (BigInt::one(), self.clone()),
        }
    }
}