Skip to main content

vibe/stdlib_v2/num_and_autodiff/
autodiff.rs

1//! First-Class Forward-Mode Automatic Differentiation (`autodiff.*`) for VibeScript v0.02.
2//!
3//! Provides exact Dual numbers (`x + x' ε` with `ε² = 0`), elementary transcendental
4//! chain-rule operators, univariate `value_and_grad` / `grad`, and multivariate
5//! exact `jacobian` evaluation (§16 Julia/Mojo).
6
7use 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/// Forward-mode dual number `val + deriv * ε`.
16#[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
80/// Dispatch an `autodiff.*` call.
81pub 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            // (1 - x)^2 + 100 * (x^2 - x)^2
219            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}