yufmath 0.1.1

//! # 基础计算引擎
//!
//! 实现基本的数学计算功能。

use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use crate::core::{Expression, Number, MathConstant};
use super::{ComputeEngine, ComputeError};
use super::simplify::Simplifier;
use super::polynomial::PolynomialEngine;
use super::number_theory::NumberTheoryEngine;
use super::calculus::CalculusEngine;
use super::matrix::MatrixEngine;

/// 基础计算引擎实现
pub struct BasicComputeEngine {
    /// 表达式简化器
    simplifier: Arc<Mutex<Simplifier>>,
    /// 多项式运算引擎
    polynomial_engine: PolynomialEngine,
    /// 数论和组合数学引擎
    number_theory_engine: NumberTheoryEngine,
    /// 微积分引擎
    calculus_engine: CalculusEngine,
    /// 矩阵和向量运算引擎
    matrix_engine: MatrixEngine,
}

impl BasicComputeEngine {
    /// 创建新的计算引擎
    pub fn new() -> Self {
        Self {
            simplifier: Arc::new(Mutex::new(Simplifier::new())),
            polynomial_engine: PolynomialEngine::new(),
            number_theory_engine: NumberTheoryEngine::new(),
            calculus_engine: CalculusEngine::new(),
            matrix_engine: MatrixEngine::new(),
        }
    }
    
    /// 计算二元运算
    fn evaluate_binary_op(&self, left: &Number, right: &Number, op: &crate::core::BinaryOperator) -> Result<Number, ComputeError> {
        use crate::core::BinaryOperator;
        
        match op {
            BinaryOperator::Add => left.add(right),
            BinaryOperator::Subtract => left.subtract(right),
            BinaryOperator::Multiply => left.multiply(right),
            BinaryOperator::Divide => left.divide(right),
            BinaryOperator::Power => left.power(right),
            _ => Err(ComputeError::unsupported_operation(&format!("不支持的二元运算: {:?}", op)))
        }
    }
    
    /// 计算一元运算
    fn evaluate_unary_op(&self, operand: &Number, op: &crate::core::UnaryOperator) -> Result<Number, ComputeError> {
        use crate::core::UnaryOperator;
        
        match op {
            UnaryOperator::Negate => operand.negate(),
            UnaryOperator::Plus => Ok(operand.clone()),
            UnaryOperator::Abs => operand.abs(),
            _ => Err(ComputeError::unsupported_operation(&format!("不支持的一元运算: {:?}", op)))
        }
    }
}

impl ComputeEngine for BasicComputeEngine {
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
    fn simplify(&self, expr: &Expression) -> Result<Expression, ComputeError> {
        self.simplifier.lock()
            .map_err(|_| ComputeError::internal("无法获取简化器锁"))?
            .simplify(expr)
    }
    
    fn evaluate(&self, expr: &Expression, vars: &HashMap<String, Number>) -> Result<Number, ComputeError> {
        match expr {
            Expression::Number(n) => Ok(n.clone()),
            Expression::Variable(name) => {
                vars.get(name)
                    .cloned()
                    .ok_or_else(|| ComputeError::undefined_variable(name))
            }
            Expression::BinaryOp { op, left, right } => {
                use crate::core::BinaryOperator;
                
                // 对于矩阵和向量专用运算符，在表达式级别处理
                match op {
                    BinaryOperator::MatrixMultiply => {
                        let result = self.matrix_engine.matrix_multiply(left, right)?;
                        self.evaluate(&result, vars)
                    }
                    BinaryOperator::DotProduct => {
                        let result = self.matrix_engine.vector_dot(left, right)?;
                        self.evaluate(&result, vars)
                    }
                    BinaryOperator::CrossProduct => {
                        let result = self.matrix_engine.vector_cross(left, right)?;
                        self.evaluate(&result, vars)
                    }
                    _ => {
                        // 对于其他运算符，先求值操作数再计算
                        let left_val = self.evaluate(left, vars)?;
                        let right_val = self.evaluate(right, vars)?;
                        self.evaluate_binary_op(&left_val, &right_val, op)
                    }
                }
            }
            Expression::UnaryOp { op, operand } => {
                use crate::core::UnaryOperator;
                
                // 对于矩阵专用运算符，在表达式级别处理
                match op {
                    UnaryOperator::Transpose => {
                        let result = self.matrix_engine.matrix_transpose(operand)?;
                        self.evaluate(&result, vars)
                    }
                    UnaryOperator::Determinant => {
                        let result = self.matrix_engine.matrix_determinant(operand)?;
                        self.evaluate(&result, vars)
                    }
                    UnaryOperator::Inverse => {
                        let result = self.matrix_engine.matrix_inverse(operand)?;
                        self.evaluate(&result, vars)
                    }
                    UnaryOperator::Trace => {
                        let result = self.matrix_engine.matrix_trace(operand)?;
                        self.evaluate(&result, vars)
                    }
                    _ => {
                        // 对于其他运算符，先求值操作数再计算
                        let operand_val = self.evaluate(operand, vars)?;
                        self.evaluate_unary_op(&operand_val, op)
                    }
                }
            }
            Expression::Constant(c) => {
                self.constant_to_number(c)
            }
            Expression::Matrix(elements) => {
                // 矩阵求值：对每个元素求值
                let mut evaluated_elements = Vec::with_capacity(elements.len());
                for row in elements {
                    let mut evaluated_row = Vec::with_capacity(row.len());
                    for elem in row {
                        let evaluated_elem = self.evaluate(elem, vars)?;
                        evaluated_row.push(evaluated_elem);
                    }
                    evaluated_elements.push(evaluated_row);
                }
                
                // 如果矩阵是1×1，返回单个数值
                if evaluated_elements.len() == 1 && evaluated_elements[0].len() == 1 {
                    Ok(evaluated_elements[0][0].clone())
                } else {
                    Err(ComputeError::unsupported_operation("矩阵无法求值为单个数值"))
                }
            }
            Expression::Vector(elements) => {
                // 向量求值：对每个元素求值
                let mut evaluated_elements = Vec::with_capacity(elements.len());
                for elem in elements {
                    let evaluated_elem = self.evaluate(elem, vars)?;
                    evaluated_elements.push(evaluated_elem);
                }
                
                // 如果向量只有一个元素，返回该元素
                if evaluated_elements.len() == 1 {
                    Ok(evaluated_elements[0].clone())
                } else {
                    Err(ComputeError::unsupported_operation("向量无法求值为单个数值"))
                }
            }
            _ => {
                // 对于其他复杂表达式，先简化再求值
                let simplified = self.simplify(expr)?;
                if simplified != *expr {
                    self.evaluate(&simplified, vars)
                } else {
                    Err(ComputeError::unsupported_operation(&format!("无法求值表达式: {:?}", expr)))
                }
            }
        }
    }
    
    fn differentiate(&self, expr: &Expression, var: &str) -> Result<Expression, ComputeError> {
        self.calculus_engine.differentiate(expr, var)
    }
    
    fn integrate(&self, expr: &Expression, var: &str) -> Result<Expression, ComputeError> {
        self.calculus_engine.integrate(expr, var)
    }
    
    fn limit(&self, expr: &Expression, var: &str, point: &Expression) -> Result<Expression, ComputeError> {
        self.calculus_engine.limit(expr, var, point)
    }
    
    fn series(&self, expr: &Expression, var: &str, point: &Expression, order: usize) -> Result<Expression, ComputeError> {
        self.calculus_engine.series(expr, var, point, order)
    }
    
    fn numerical_evaluate(&self, expr: &Expression, vars: &HashMap<String, f64>) -> Result<f64, ComputeError> {
        self.calculus_engine.numerical_evaluate(expr, vars)
    }
    
    fn constant_to_number(&self, constant: &MathConstant) -> Result<Number, ComputeError> {
        use crate::core::MathConstant;
        
        match constant {
            MathConstant::Pi => Ok(Number::Float(std::f64::consts::PI)),
            MathConstant::E => Ok(Number::Float(std::f64::consts::E)),
            MathConstant::I => Ok(Number::i()),
            MathConstant::EulerGamma => Ok(Number::Float(0.5772156649015329)),
            MathConstant::GoldenRatio => Ok(Number::Float(1.618033988749895)),
            MathConstant::Catalan => Ok(Number::Float(0.915965594177219)),
            MathConstant::PositiveInfinity => Ok(Number::Float(f64::INFINITY)),
            MathConstant::NegativeInfinity => Ok(Number::Float(f64::NEG_INFINITY)),
            MathConstant::Undefined => Ok(Number::Float(f64::NAN)),
        }
    }
    
    fn simplify_constants(&self, _expr: &Expression) -> Result<Expression, ComputeError> {
        // 占位符实现，将在后续任务中完成
        todo!("常量简化功能将在后续任务中实现")
    }
    
    fn expand(&self, expr: &Expression) -> Result<Expression, ComputeError> {
        self.polynomial_engine.expand(expr)
    }
    
    fn factor(&self, expr: &Expression) -> Result<Expression, ComputeError> {
        self.polynomial_engine.factor(expr)
    }
    
    fn collect(&self, expr: &Expression, var: &str) -> Result<Expression, ComputeError> {
        self.polynomial_engine.collect(expr, var)
    }
    
    fn polynomial_divide(&self, dividend: &Expression, divisor: &Expression) 
        -> Result<(Expression, Expression), ComputeError> {
        self.polynomial_engine.polynomial_divide(dividend, divisor)
    }
    
    fn polynomial_gcd(&self, a: &Expression, b: &Expression) -> Result<Expression, ComputeError> {
        self.polynomial_engine.polynomial_gcd(a, b)
    }
    
    // 数论和组合数学功能实现
    
    fn gcd(&self, a: &Expression, b: &Expression) -> Result<Expression, ComputeError> {
        self.number_theory_engine.gcd(a, b)
    }
    
    fn lcm(&self, a: &Expression, b: &Expression) -> Result<Expression, ComputeError> {
        self.number_theory_engine.lcm(a, b)
    }
    
    fn is_prime(&self, n: &Expression) -> Result<bool, ComputeError> {
        self.number_theory_engine.is_prime(n)
    }
    
    fn prime_factors(&self, n: &Expression) -> Result<Vec<Expression>, ComputeError> {
        self.number_theory_engine.prime_factors(n)
    }
    
    fn binomial(&self, n: &Expression, k: &Expression) -> Result<Expression, ComputeError> {
        self.number_theory_engine.binomial(n, k)
    }
    
    fn permutation(&self, n: &Expression, k: &Expression) -> Result<Expression, ComputeError> {
        self.number_theory_engine.permutation(n, k)
    }
    
    fn mean(&self, values: &[Expression]) -> Result<Expression, ComputeError> {
        self.number_theory_engine.mean(values)
    }
    
    fn variance(&self, values: &[Expression]) -> Result<Expression, ComputeError> {
        self.number_theory_engine.variance(values)
    }
    
    fn standard_deviation(&self, values: &[Expression]) -> Result<Expression, ComputeError> {
        self.number_theory_engine.standard_deviation(values)
    }
    
    // 方程求解功能实现（暂时使用占位符）
    
    fn solve(&self, _equation: &Expression, _var: &str) -> Result<Vec<Expression>, ComputeError> {
        // 占位符实现，将在后续任务中完成
        todo!("方程求解功能将在后续任务中实现")
    }
    
    fn solve_system(&self, _equations: &[Expression], _vars: &[String]) 
        -> Result<Vec<HashMap<String, Expression>>, ComputeError> {
        // 占位符实现，将在后续任务中完成
        todo!("方程组求解功能将在后续任务中实现")
    }
    
    // 矩阵运算功能实现（暂时使用占位符）
    
    fn matrix_add(&self, a: &Expression, b: &Expression) -> Result<Expression, ComputeError> {
        self.matrix_engine.matrix_add(a, b)
    }
    
    fn matrix_multiply(&self, a: &Expression, b: &Expression) -> Result<Expression, ComputeError> {
        self.matrix_engine.matrix_multiply(a, b)
    }
    
    fn matrix_determinant(&self, matrix: &Expression) -> Result<Expression, ComputeError> {
        self.matrix_engine.matrix_determinant(matrix)
    }
    
    fn matrix_inverse(&self, matrix: &Expression) -> Result<Expression, ComputeError> {
        self.matrix_engine.matrix_inverse(matrix)
    }
    
    // 复数运算功能实现（暂时使用占位符）
    
    fn complex_conjugate(&self, _expr: &Expression) -> Result<Expression, ComputeError> {
        // 占位符实现，将在后续任务中完成
        todo!("复数共轭功能将在后续任务中实现")
    }
    
    fn complex_modulus(&self, _expr: &Expression) -> Result<Expression, ComputeError> {
        // 占位符实现，将在后续任务中完成
        todo!("复数模长功能将在后续任务中实现")
    }
    
    fn complex_argument(&self, _expr: &Expression) -> Result<Expression, ComputeError> {
        // 占位符实现，将在后续任务中完成
        todo!("复数幅角功能将在后续任务中实现")
    }
    
    // 向量运算功能实现（暂时使用占位符）
    
    fn vector_dot(&self, a: &Expression, b: &Expression) -> Result<Expression, ComputeError> {
        self.matrix_engine.vector_dot(a, b)
    }
    
    fn vector_cross(&self, a: &Expression, b: &Expression) -> Result<Expression, ComputeError> {
        self.matrix_engine.vector_cross(a, b)
    }
    
    fn vector_norm(&self, v: &Expression) -> Result<Expression, ComputeError> {
        self.matrix_engine.vector_norm(v)
    }
    
    // 集合运算功能实现（暂时使用占位符）
    
    fn set_union(&self, _a: &Expression, _b: &Expression) -> Result<Expression, ComputeError> {
        // 占位符实现，将在后续任务中完成
        todo!("集合并集功能将在后续任务中实现")
    }
    
    fn set_intersection(&self, _a: &Expression, _b: &Expression) -> Result<Expression, ComputeError> {
        // 占位符实现，将在后续任务中完成
        todo!("集合交集功能将在后续任务中实现")
    }
    
    fn set_difference(&self, _a: &Expression, _b: &Expression) -> Result<Expression, ComputeError> {
        // 占位符实现，将在后续任务中完成
        todo!("集合差集功能将在后续任务中实现")
    }
}