Skip to main content

prima_core/
render.rs

1use num_bigint::BigInt;
2use num_rational::BigRational;
3use num_traits::Signed;
4
5use crate::expr_pool::{ExprData, ExprId, ExprPool};
6use crate::number::{Number, Real};
7use crate::symbol::SymbolTable;
8
9/// LaTeX view of a number (spec §8.3 default `print_format := latex`): rationals render as `\frac{n}{d}`.
10pub fn render_number(n: &Number) -> String {
11    match n {
12        Number::Integer(i) => i.to_string(),
13        Number::Rational(r) => format!("\\frac{{{}}}{{{}}}", r.numer(), r.denom()),
14        Number::Real(Real::F64(f)) => f.to_string(),
15        Number::Real(Real::F32(f)) => f.to_string(),
16        Number::Complex { re, im } => format!("{} + {}i", render_number(re), render_number(im)),
17        Number::I8(v) => v.to_string(),
18        Number::I16(v) => v.to_string(),
19        Number::I32(v) => v.to_string(),
20        Number::I64(v) => v.to_string(),
21        Number::I128(v) => v.to_string(),
22        Number::U8(v) => v.to_string(),
23        Number::U16(v) => v.to_string(),
24        Number::U32(v) => v.to_string(),
25        Number::U64(v) => v.to_string(),
26        Number::U128(v) => v.to_string(),
27        Number::Isize(v) => v.to_string(),
28        Number::Usize(v) => v.to_string(),
29        Number::BigFloat(f) => f.to_string(),
30    }
31}
32
33/// ExprDAG → LaTeX view (spec §8.3 level 0, preserving the original form). TeX names come from the symbol table (spec §7);
34/// rendering is just a view conversion, decoupled from the reverse parsing of `tex"..."` (spec §4.9).
35pub fn render_latex(pool: &ExprPool, symbols: &SymbolTable, id: ExprId) -> String {
36    match pool.get(id) {
37        Some(ExprData::Symbol(s)) => symbols.name(s).unwrap_or_else(|| format!("?{}", s.0)),
38        Some(ExprData::Integer(i)) => i.to_string(),
39        Some(ExprData::Rational(r)) => render_number(&Number::Rational(*r)),
40        Some(ExprData::Real(Real::F64(f))) => f.to_string(),
41        Some(ExprData::Real(Real::F32(f))) => f.to_string(),
42        Some(ExprData::Add(items)) => render_add(pool, symbols, &items),
43        Some(ExprData::Mul(items)) => render_mul(pool, symbols, &items),
44        Some(ExprData::Pow { base, exp }) => render_pow(pool, symbols, base, exp),
45        Some(ExprData::Apply { f, args }) => render_apply(pool, symbols, f, &args),
46        Some(ExprData::Indeterminate(_)) => "\\text{indeterminate}".into(),
47        None => "?".into(),
48    }
49}
50
51fn render_add(pool: &ExprPool, symbols: &SymbolTable, items: &[ExprId]) -> String {
52    let mut ordered: Vec<ExprId> = items.to_vec();
53    ordered.sort_by_key(|&id| {
54        match pool.get(id) {
55            Some(ExprData::Integer(_) | ExprData::Rational(_) | ExprData::Real(_)) => (1u8, 0u8),
56            Some(ExprData::Symbol(_)) => (0u8, 1u8),
57            _ => (0u8, 0u8),
58        }
59    });
60    let mut parts = Vec::new();
61    for (i, &item) in ordered.iter().enumerate() {
62        let s = render_signed(pool, symbols, item);
63        if i == 0 {
64            let trimmed = s.strip_prefix("+ ").unwrap_or(&s);
65            parts.push(trimmed.to_string());
66        } else {
67            parts.push(s);
68        }
69    }
70    parts.join(" ")
71}
72
73fn render_signed(pool: &ExprPool, symbols: &SymbolTable, id: ExprId) -> String {
74    match pool.get(id) {
75        Some(ExprData::Integer(i)) if *i < BigInt::from(0) => format!("- {}", -(*i)),
76        Some(ExprData::Rational(r)) if *r < BigRational::new(BigInt::from(0), BigInt::from(1)) => {
77            format!("- {}", render_number(&Number::Rational(r.abs())))
78        }
79        Some(ExprData::Real(Real::F64(f))) if f < 0.0 => format!("- {}", -f),
80        Some(ExprData::Real(Real::F32(f))) if f < 0.0 => format!("- {}", -f),
81        _ => {
82            let s = render_latex(pool, symbols, id);
83            if s.starts_with('-') {
84                s
85            } else {
86                format!("+ {s}")
87            }
88        }
89    }
90}
91
92fn render_mul(pool: &ExprPool, symbols: &SymbolTable, items: &[ExprId]) -> String {
93    let mut neg = false;
94    let mut parts = Vec::new();
95    for &item in items.iter() {
96        match pool.get(item) {
97            Some(ExprData::Integer(i)) if *i == BigInt::from(-1) && items.len() > 1 => neg = !neg,
98            _ => {
99                let s = render_latex(pool, symbols, item);
100                if is_atomic(pool, item) {
101                    parts.push(s);
102                } else {
103                    parts.push(format!("\\left({s}\\right)"));
104                }
105            }
106        }
107    }
108    let body = if parts.is_empty() { "1".to_string() } else { parts.join(" ") };
109    if neg {
110        format!("-{body}")
111    } else {
112        body
113    }
114}
115
116fn is_atomic(pool: &ExprPool, id: ExprId) -> bool {
117    matches!(pool.get(id), Some(ExprData::Symbol(_) | ExprData::Integer(_) | ExprData::Rational(_) | ExprData::Real(_)))
118}
119
120fn render_pow(pool: &ExprPool, symbols: &SymbolTable, base: ExprId, exp: ExprId) -> String {
121    let half = BigRational::new(BigInt::from(1), BigInt::from(2));
122    if matches!(pool.const_number(exp), Some(Number::Rational(r)) if r == half) {
123        return format!("\\sqrt{{{}}}", render_latex(pool, symbols, base));
124    }
125    let base_s = render_latex(pool, symbols, base);
126    let base_s = if is_atomic(pool, base) { base_s } else { format!("\\left({base_s}\\right)") };
127    format!("{base_s}^{{{}}}", render_latex(pool, symbols, exp))
128}
129
130fn render_apply(pool: &ExprPool, symbols: &SymbolTable, f: ExprId, args: &[ExprId]) -> String {
131    let name = match pool.get(f) {
132        Some(ExprData::Symbol(s)) => symbols.name(s).unwrap_or_else(|| "f".to_string()),
133        _ => "f".to_string(),
134    };
135    let arg_strs: Vec<String> = args.iter().map(|&a| render_latex(pool, symbols, a)).collect();
136    if name == "\\sqrt" && args.len() == 1 {
137        return format!("\\sqrt{{{}}}", arg_strs[0]);
138    }
139    format!("{name}\\left({}\\right)", arg_strs.join(", "))
140}