ries 2.0.1

Find algebraic equations given their solution - Rust implementation
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

//! Integration tests for the profile module

#![cfg(not(target_arch = "wasm32"))]
#![allow(clippy::field_reassign_with_default)]

use ries_rs::profile::{Profile, UserConstant};
use ries_rs::symbol::{NumType, Symbol};

/// Test creating an empty profile
#[test]
fn test_empty_profile() {
    let profile = Profile::new();
    assert!(profile.constants.is_empty());
    assert!(profile.symbol_names.is_empty());
    assert!(profile.symbol_weights.is_empty());
    assert!(profile.includes.is_empty());
}

/// Test profile merging
#[test]
fn test_profile_merge() {
    let mut p1 = Profile::new();
    p1.constants.push(UserConstant {
        weight: 4,
        name: "a".to_string(),
        description: "First constant".to_string(),
        value: 1.0,
        num_type: NumType::Integer,
    });
    p1.symbol_names.insert(Symbol::Pi, "π".to_string());

    let mut p2 = Profile::new();
    p2.constants.push(UserConstant {
        weight: 5,
        name: "b".to_string(),
        description: "Second constant".to_string(),
        value: 2.0,
        num_type: NumType::Integer,
    });
    p2.symbol_names.insert(Symbol::E, "ℯ".to_string());

    let merged = p1.merge(p2).unwrap();

    assert_eq!(merged.constants.len(), 2);
    assert_eq!(merged.symbol_names.len(), 2);
}

/// Test that later profiles override earlier ones
#[test]
fn test_profile_override() {
    let mut p1 = Profile::new();
    p1.constants.push(UserConstant {
        weight: 4,
        name: "a".to_string(),
        description: "Original".to_string(),
        value: 1.0,
        num_type: NumType::Integer,
    });

    let mut p2 = Profile::new();
    p2.constants.push(UserConstant {
        weight: 8,
        name: "a".to_string(),
        description: "Override".to_string(),
        value: 2.0,
        num_type: NumType::Integer,
    });

    let merged = p1.merge(p2).unwrap();

    // Should have only one constant (the override)
    assert_eq!(merged.constants.len(), 1);
    assert_eq!(merged.constants[0].value, 2.0);
    assert_eq!(merged.constants[0].weight, 8);
}

/// Test UserConstant structure
#[test]
fn test_user_constant() {
    let constant = UserConstant {
        weight: 10,
        name: "gamma".to_string(),
        description: "Euler's constant".to_string(),
        value: 0.5772156649,
        num_type: NumType::Transcendental,
    };

    assert_eq!(constant.weight, 10);
    assert_eq!(constant.name, "gamma");
    assert!((constant.value - 0.5772156649).abs() < 1e-10);
}

/// Test symbol name customization
#[test]
fn test_symbol_names() {
    let mut profile = Profile::new();
    profile.symbol_names.insert(Symbol::Pi, "π".to_string());
    profile.symbol_names.insert(Symbol::E, "ℯ".to_string());
    profile.symbol_names.insert(Symbol::Phi, "φ".to_string());

    assert_eq!(
        profile.symbol_names.get(&Symbol::Pi),
        Some(&"π".to_string())
    );
    assert_eq!(profile.symbol_names.get(&Symbol::E), Some(&"ℯ".to_string()));
    assert_eq!(
        profile.symbol_names.get(&Symbol::Phi),
        Some(&"φ".to_string())
    );
}

/// Test symbol weight customization
#[test]
fn test_symbol_weights() {
    let mut profile = Profile::new();
    profile.symbol_weights.insert(Symbol::LambertW, 20);
    profile.symbol_weights.insert(Symbol::Pi, 15);

    assert_eq!(profile.symbol_weights.get(&Symbol::LambertW), Some(&20));
    assert_eq!(profile.symbol_weights.get(&Symbol::Pi), Some(&15));
}