1use std::collections::BTreeMap;
8
9use crate::error::{DiagCode, Diagnostic};
10use crate::span::Span;
11use crate::value::Value;
12
13use super::{extract_f64, extract_list};
14
15#[derive(Debug, Clone, Copy, PartialEq)]
17struct Dual {
18 val: f64,
19 deriv: f64,
20}
21
22impl Dual {
23 const fn new(val: f64, deriv: f64) -> Self {
24 Self { val, deriv }
25 }
26
27 fn add(self, rhs: Self) -> Self {
28 Self::new(self.val + rhs.val, self.deriv + rhs.deriv)
29 }
30
31 fn sub(self, rhs: Self) -> Self {
32 Self::new(self.val - rhs.val, self.deriv - rhs.deriv)
33 }
34
35 fn mul(self, rhs: Self) -> Self {
36 Self::new(
37 self.val * rhs.val,
38 self.val * rhs.deriv + self.deriv * rhs.val,
39 )
40 }
41
42 fn div(self, rhs: Self, span: Span) -> Result<Self, Diagnostic> {
43 if rhs.val.abs() < 1e-15 {
44 return Err(Diagnostic::new(
45 DiagCode::E600,
46 span,
47 "autodiff.dual_div: division by zero",
48 ));
49 }
50 Ok(Self::new(
51 self.val / rhs.val,
52 (self.deriv * rhs.val - self.val * rhs.deriv) / (rhs.val * rhs.val),
53 ))
54 }
55
56 fn sin(self) -> Self {
57 Self::new(self.val.sin(), self.val.cos() * self.deriv)
58 }
59
60 fn cos(self) -> Self {
61 Self::new(self.val.cos(), -self.val.sin() * self.deriv)
62 }
63
64 fn exp(self) -> Self {
65 let e = self.val.exp();
66 Self::new(e, e * self.deriv)
67 }
68
69 fn pow(self, n: f64) -> Self {
70 if n == 0.0 {
71 Self::new(1.0, 0.0)
72 } else if (n - 1.0).abs() < 1e-15 {
73 self
74 } else {
75 Self::new(self.val.powf(n), n * self.val.powf(n - 1.0) * self.deriv)
76 }
77 }
78}
79
80pub fn call_autodiff(
82 path: &str,
83 args: &[Value],
84 span: Span,
85) -> Result<Option<Value>, Diagnostic> {
86 match path {
87 "autodiff.dual" => {
88 let val = extract_f64(args, 0, "autodiff.dual(val, deriv)", span)?;
89 let deriv = args.get(1).and_then(Value::as_f64).unwrap_or(1.0);
90 Ok(Some(dual_to_record(Dual::new(val, deriv))))
91 }
92 "autodiff.dual_add" => {
93 let a = coerce_dual(args.first(), "autodiff.dual_add", span)?;
94 let b = coerce_dual(args.get(1), "autodiff.dual_add", span)?;
95 Ok(Some(dual_to_record(a.add(b))))
96 }
97 "autodiff.dual_sub" => {
98 let a = coerce_dual(args.first(), "autodiff.dual_sub", span)?;
99 let b = coerce_dual(args.get(1), "autodiff.dual_sub", span)?;
100 Ok(Some(dual_to_record(a.sub(b))))
101 }
102 "autodiff.dual_mul" => {
103 let a = coerce_dual(args.first(), "autodiff.dual_mul", span)?;
104 let b = coerce_dual(args.get(1), "autodiff.dual_mul", span)?;
105 Ok(Some(dual_to_record(a.mul(b))))
106 }
107 "autodiff.dual_div" => {
108 let a = coerce_dual(args.first(), "autodiff.dual_div", span)?;
109 let b = coerce_dual(args.get(1), "autodiff.dual_div", span)?;
110 Ok(Some(dual_to_record(a.div(b, span)?)))
111 }
112 "autodiff.dual_sin" => {
113 let a = coerce_dual(args.first(), "autodiff.dual_sin", span)?;
114 Ok(Some(dual_to_record(a.sin())))
115 }
116 "autodiff.dual_cos" => {
117 let a = coerce_dual(args.first(), "autodiff.dual_cos", span)?;
118 Ok(Some(dual_to_record(a.cos())))
119 }
120 "autodiff.dual_exp" => {
121 let a = coerce_dual(args.first(), "autodiff.dual_exp", span)?;
122 Ok(Some(dual_to_record(a.exp())))
123 }
124 "autodiff.dual_pow" => {
125 let a = coerce_dual(args.first(), "autodiff.dual_pow", span)?;
126 let n = extract_f64(args, 1, "autodiff.dual_pow(a, n)", span)?;
127 Ok(Some(dual_to_record(a.pow(n))))
128 }
129 "autodiff.value_and_grad" => {
130 let spec = args.first().ok_or_else(|| {
131 Diagnostic::new(DiagCode::E100, span, "autodiff.value_and_grad: missing spec")
132 })?;
133 let x = extract_f64(args, 1, "autodiff.value_and_grad(spec, x)", span)?;
134 let d = eval_univariate_spec(spec, Dual::new(x, 1.0), span)?;
135 let mut rec = BTreeMap::new();
136 rec.insert("value".into(), Value::F64(d.val));
137 rec.insert("grad".into(), Value::F64(d.deriv));
138 Ok(Some(Value::Record(rec)))
139 }
140 "autodiff.grad" => {
141 let spec = args.first().ok_or_else(|| {
142 Diagnostic::new(DiagCode::E100, span, "autodiff.grad: missing spec")
143 })?;
144 let x = extract_f64(args, 1, "autodiff.grad(spec, x)", span)?;
145 let d = eval_univariate_spec(spec, Dual::new(x, 1.0), span)?;
146 Ok(Some(Value::F64(d.deriv)))
147 }
148 "autodiff.jacobian" => eval_jacobian(args, span),
149 _ => Ok(None),
150 }
151}
152
153fn eval_univariate_spec(spec: &Value, x: Dual, span: Span) -> Result<Dual, Diagnostic> {
154 match spec {
155 Value::List(coeffs) => eval_poly_dual(coeffs, x, span),
156 Value::String(op) => apply_named_op(op, x, span),
157 Value::Record(map) => {
158 let inner = if let Some(Value::List(coeffs)) = map.get("coeffs") {
159 eval_poly_dual(coeffs, x, span)?
160 } else {
161 x
162 };
163 if let Some(Value::String(op)) = map.get("op") {
164 apply_named_op(op, inner, span)
165 } else {
166 Ok(inner)
167 }
168 }
169 _ => Err(Diagnostic::new(
170 DiagCode::E100,
171 span,
172 "autodiff: spec must be a polynomial coefficient List, op String, or Record",
173 )),
174 }
175}
176
177fn eval_poly_dual(coeffs: &[Value], x: Dual, span: Span) -> Result<Dual, Diagnostic> {
178 let mut acc = Dual::new(0.0, 0.0);
179 let mut x_pow = Dual::new(1.0, 0.0);
180 for (idx, c_val) in coeffs.iter().enumerate() {
181 let c = c_val.as_f64().ok_or_else(|| {
182 Diagnostic::new(
183 DiagCode::E100,
184 span,
185 format!("autodiff polynomial: coefficient #{idx} must be a number"),
186 )
187 })?;
188 acc = acc.add(Dual::new(c, 0.0).mul(x_pow));
189 x_pow = x_pow.mul(x);
190 }
191 Ok(acc)
192}
193
194fn apply_named_op(op: &str, x: Dual, span: Span) -> Result<Dual, Diagnostic> {
195 match op {
196 "identity" | "linear" => Ok(x),
197 "sin" => Ok(x.sin()),
198 "cos" => Ok(x.cos()),
199 "exp" => Ok(x.exp()),
200 "square" | "x^2" => Ok(x.mul(x)),
201 "cube" | "x^3" => Ok(x.pow(3.0)),
202 "sigmoid" => {
203 let neg_x = Dual::new(-x.val, -x.deriv);
204 let denom = Dual::new(1.0, 0.0).add(neg_x.exp());
205 Dual::new(1.0, 0.0).div(denom, span)
206 }
207 "softplus" => {
208 let e = x.val.exp();
209 let val = (1.0 + e).ln();
210 let sig = e / (1.0 + e);
211 Ok(Dual::new(val, sig * x.deriv))
212 }
213 "tanh" => {
214 let t = x.val.tanh();
215 Ok(Dual::new(t, (1.0 - t * t) * x.deriv))
216 }
217 "rosenbrock_1d" => {
218 let one_minus_x = Dual::new(1.0, 0.0).sub(x);
220 let term1 = one_minus_x.mul(one_minus_x);
221 let x2_minus_x = x.mul(x).sub(x);
222 let term2 = Dual::new(100.0, 0.0).mul(x2_minus_x.mul(x2_minus_x));
223 Ok(term1.add(term2))
224 }
225 _ => Err(Diagnostic::new(
226 DiagCode::E100,
227 span,
228 format!("autodiff: unsupported function op '{op}'"),
229 )),
230 }
231}
232
233fn eval_jacobian(args: &[Value], span: Span) -> Result<Option<Value>, Diagnostic> {
234 let rows_spec = extract_list(args, 0, "autodiff.jacobian(rows_spec, x_vec)", span)?;
235 let x_list = extract_list(args, 1, "autodiff.jacobian(rows_spec, x_vec)", span)?;
236 let mut x_vec = Vec::with_capacity(x_list.len());
237 for (j, v) in x_list.iter().enumerate() {
238 let f = v.as_f64().ok_or_else(|| {
239 Diagnostic::new(
240 DiagCode::E100,
241 span,
242 format!("autodiff.jacobian: x_vec[{j}] must be a number"),
243 )
244 })?;
245 x_vec.push(f);
246 }
247
248 let rows = rows_spec.len();
249 let cols = x_vec.len();
250 let mut values_out = Vec::with_capacity(rows);
251 let mut jac_out = Vec::with_capacity(rows);
252
253 for row_spec in &rows_spec {
254 let mut row_grad = Vec::with_capacity(cols);
255 let mut row_val = 0.0;
256 if cols == 0 {
257 let d = eval_row_spec(row_spec, &[], span)?;
258 row_val = d.val;
259 } else {
260 for j in 0..cols {
261 let dual_x: Vec<Dual> = x_vec
262 .iter()
263 .enumerate()
264 .map(|(k, &xv)| Dual::new(xv, if k == j { 1.0 } else { 0.0 }))
265 .collect();
266 let d = eval_row_spec(row_spec, &dual_x, span)?;
267 if j == 0 {
268 row_val = d.val;
269 }
270 row_grad.push(Value::F64(d.deriv));
271 }
272 }
273 values_out.push(Value::F64(row_val));
274 jac_out.push(Value::List(row_grad));
275 }
276
277 let mut rec = BTreeMap::new();
278 rec.insert("values".into(), Value::List(values_out));
279 rec.insert("jacobian".into(), Value::List(jac_out));
280 rec.insert("rows".into(), Value::I64(rows as i64));
281 rec.insert("cols".into(), Value::I64(cols as i64));
282 Ok(Some(Value::Record(rec)))
283}
284
285fn eval_row_spec(spec: &Value, x: &[Dual], span: Span) -> Result<Dual, Diagnostic> {
286 match spec {
287 Value::List(weights) => {
288 let mut acc = Dual::new(0.0, 0.0);
289 for (j, w_val) in weights.iter().enumerate() {
290 if let Some(&xj) = x.get(j) {
291 let w = w_val.as_f64().unwrap_or(0.0);
292 acc = acc.add(Dual::new(w, 0.0).mul(xj));
293 }
294 }
295 Ok(acc)
296 }
297 Value::Record(map) => {
298 let bias = map.get("bias").and_then(Value::as_f64).unwrap_or(0.0);
299 let mut acc = Dual::new(bias, 0.0);
300 let powers = map.get("powers").and_then(|v| match v {
301 Value::List(xs) => Some(xs),
302 _ => None,
303 });
304 if let Some(Value::List(weights)) = map.get("weights") {
305 for (j, w_val) in weights.iter().enumerate() {
306 if let Some(&xj) = x.get(j) {
307 let w = w_val.as_f64().unwrap_or(0.0);
308 let p = powers
309 .and_then(|ps| ps.get(j))
310 .and_then(Value::as_f64)
311 .unwrap_or(1.0);
312 acc = acc.add(Dual::new(w, 0.0).mul(xj.pow(p)));
313 }
314 }
315 }
316 if let Some(Value::String(op)) = map.get("op") {
317 apply_named_op(op, acc, span)
318 } else {
319 Ok(acc)
320 }
321 }
322 _ => Err(Diagnostic::new(
323 DiagCode::E100,
324 span,
325 "autodiff.jacobian: each row spec must be a List of weights or a Record",
326 )),
327 }
328}
329
330fn coerce_dual(val: Option<&Value>, ctx: &str, span: Span) -> Result<Dual, Diagnostic> {
331 match val {
332 Some(Value::Record(m)) => {
333 let v = m.get("val").and_then(Value::as_f64).ok_or_else(|| {
334 Diagnostic::new(DiagCode::E100, span, format!("{ctx}: Dual missing 'val'"))
335 })?;
336 let d = m.get("deriv").and_then(Value::as_f64).unwrap_or(0.0);
337 Ok(Dual::new(v, d))
338 }
339 Some(other) => {
340 let v = other.as_f64().ok_or_else(|| {
341 Diagnostic::new(
342 DiagCode::E100,
343 span,
344 format!("{ctx}: expected Dual record or number"),
345 )
346 })?;
347 Ok(Dual::new(v, 0.0))
348 }
349 None => Err(Diagnostic::new(
350 DiagCode::E100,
351 span,
352 format!("{ctx}: missing Dual argument"),
353 )),
354 }
355}
356
357fn dual_to_record(d: Dual) -> Value {
358 let mut rec = BTreeMap::new();
359 rec.insert("__dual".into(), Value::Bool(true));
360 rec.insert("val".into(), Value::F64(d.val));
361 rec.insert("deriv".into(), Value::F64(d.deriv));
362 Value::Record(rec)
363}