vibe/stdlib_v2/num_and_autodiff/
mod.rs1pub mod autodiff;
5pub mod decimal;
6pub mod math_ext;
7
8use crate::error::{DiagCode, Diagnostic};
9use crate::span::Span;
10use crate::value::Value;
11
12pub const NUM_AND_AUTODIFF_BINDINGS: &[&str] = &[
14 "num.parse_i64",
16 "num.parse_u64",
17 "num.parse_f64",
18 "decimal.from_str",
20 "decimal.from_parts",
21 "decimal.add",
22 "decimal.sub",
23 "decimal.mul",
24 "decimal.div",
25 "decimal.round",
26 "decimal.to_fixed",
27 "decimal.eq",
28 "decimal.cmp",
29 "math.idiv",
31 "math.imod",
32 "math.divmod",
33 "math.gcd",
34 "math.lcm",
35 "math.lerp",
36 "math.sum_precise",
37 "math.min_list",
38 "math.max_list",
39 "math.add_checked",
40 "math.sub_checked",
41 "math.mul_checked",
42 "math.add_saturating",
43 "math.sub_saturating",
44 "math.mul_saturating",
45 "math.round_mode",
46 "math.prng_seed",
48 "math.prng_next_u64",
49 "math.prng_next_f64",
50 "math.prng_range",
51 "autodiff.dual",
53 "autodiff.dual_add",
54 "autodiff.dual_sub",
55 "autodiff.dual_mul",
56 "autodiff.dual_div",
57 "autodiff.dual_sin",
58 "autodiff.dual_cos",
59 "autodiff.dual_exp",
60 "autodiff.dual_pow",
61 "autodiff.value_and_grad",
62 "autodiff.grad",
63 "autodiff.jacobian",
64];
65
66pub fn call_num_and_autodiff(
68 path: &str,
69 args: &[Value],
70 span: Span,
71) -> Result<Option<Value>, Diagnostic> {
72 if let Some(v) = decimal::call_decimal(path, args, span)? {
73 return Ok(Some(v));
74 }
75 if let Some(v) = math_ext::call_math_ext(path, args, span)? {
76 return Ok(Some(v));
77 }
78 autodiff::call_autodiff(path, args, span)
79}
80
81pub(crate) fn extract_str(
82 args: &[Value],
83 idx: usize,
84 ctx: &str,
85 span: Span,
86) -> Result<String, Diagnostic> {
87 match args.get(idx) {
88 Some(Value::String(s)) | Some(Value::Iri(s)) => Ok(s.clone()),
89 _ => Err(Diagnostic::new(
90 DiagCode::E100,
91 span,
92 format!("{ctx}: argument #{idx} must be a String"),
93 )),
94 }
95}
96
97pub(crate) fn extract_i64(
98 args: &[Value],
99 idx: usize,
100 ctx: &str,
101 span: Span,
102) -> Result<i64, Diagnostic> {
103 args.get(idx).and_then(Value::as_i64).ok_or_else(|| {
104 Diagnostic::new(
105 DiagCode::E100,
106 span,
107 format!("{ctx}: argument #{idx} must be an I64"),
108 )
109 })
110}
111
112pub(crate) fn extract_f64(
113 args: &[Value],
114 idx: usize,
115 ctx: &str,
116 span: Span,
117) -> Result<f64, Diagnostic> {
118 args.get(idx).and_then(Value::as_f64).ok_or_else(|| {
119 Diagnostic::new(
120 DiagCode::E100,
121 span,
122 format!("{ctx}: argument #{idx} must be a number"),
123 )
124 })
125}
126
127pub(crate) fn extract_list(
128 args: &[Value],
129 idx: usize,
130 ctx: &str,
131 span: Span,
132) -> Result<Vec<Value>, Diagnostic> {
133 match args.get(idx) {
134 Some(Value::List(items)) => Ok(items.clone()),
135 _ => Err(Diagnostic::new(
136 DiagCode::E100,
137 span,
138 format!("{ctx}: argument #{idx} must be a List"),
139 )),
140 }
141}
142
143pub(crate) fn opt_i64(args: &[Value], idx: usize, default: i64) -> i64 {
144 args.get(idx).and_then(Value::as_i64).unwrap_or(default)
145}
146
147pub(crate) fn opt_str(args: &[Value], idx: usize, default: &str) -> String {
148 match args.get(idx) {
149 Some(Value::String(s)) | Some(Value::Iri(s)) => s.clone(),
150 _ => default.to_string(),
151 }
152}