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
9pub 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
33pub 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}