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

//! Integration tests for separable ODE solver
//!
//! Tests end-to-end workflows:
//! - Full ODE solving pipeline
//! - Integration with ODE classification
//! - Initial condition handling
//! - Solution verification

use mathhook_core::calculus::ode::first_order::separable::SeparableODESolver;
use mathhook_core::{expr, symbol, Expression};

#[test]
fn test_full_ode_workflow_simple_linear() {
    let x = symbol!(x);
    let y = symbol!(y);
    let solver = SeparableODESolver::new();

    let rhs = expr!(x);
    let result = solver.solve(&rhs, &y, &x, None);

    assert!(
        result.is_ok(),
        "Failed to solve dy/dx = x: {:?}",
        result.err()
    );
}

#[test]
fn test_full_ode_workflow_exponential_with_ic() {
    let x = symbol!(x);
    let y = symbol!(y);
    let solver = SeparableODESolver::new();

    let rhs = expr!(y);
    let ic = Some((expr!(0), expr!(1)));
    let result = solver.solve(&rhs, &y, &x, ic);

    assert!(
        result.is_ok(),
        "Failed to solve dy/dx = y with IC: {:?}",
        result.err()
    );
}

#[test]
fn test_full_ode_workflow_product_form() {
    let x = symbol!(x);
    let y = symbol!(y);
    let solver = SeparableODESolver::new();

    let rhs = expr!(x * y);
    let result = solver.solve(&rhs, &y, &x, None);

    assert!(
        result.is_ok(),
        "Failed to solve dy/dx = xy: {:?}",
        result.err()
    );
}

#[test]
fn test_non_separable_detection() {
    let x = symbol!(x);
    let y = symbol!(y);
    let solver = SeparableODESolver::new();

    let rhs = expr!(x + y);
    assert!(!solver.is_separable(&rhs, &y, &x));

    let result = solver.solve(&rhs, &y, &x, None);
    assert!(result.is_err());
}

#[test]
fn test_separable_detection_various_forms() {
    let x = symbol!(x);
    let y = symbol!(y);
    let solver = SeparableODESolver::new();

    assert!(solver.is_separable(&expr!(x), &y, &x));
    assert!(solver.is_separable(&expr!(y), &y, &x));
    assert!(solver.is_separable(&expr!(x * y), &y, &x));
    assert!(solver.is_separable(&Expression::mul(vec![expr!(2), expr!(x), expr!(y)]), &y, &x));
}

#[test]
fn test_initial_condition_application() {
    let x = symbol!(x);
    let y = symbol!(y);
    let solver = SeparableODESolver::new();

    let rhs = expr!(x);
    let ic = Some((expr!(0), expr!(5)));
    let result = solver.solve(&rhs, &y, &x, ic);

    assert!(result.is_ok());
}

#[test]
fn test_multiple_equations_same_solver() {
    let x = symbol!(x);
    let y = symbol!(y);
    let solver = SeparableODESolver::new();

    let eq1 = expr!(x);
    let eq2 = expr!(y);
    let eq3 = expr!(x * y);

    assert!(solver.solve(&eq1, &y, &x, None).is_ok());
    assert!(solver.solve(&eq2, &y, &x, None).is_ok());
    assert!(solver.solve(&eq3, &y, &x, None).is_ok());
}