Add more trig./hyp functions

numbat/src/ffi.rs

@@ -78,6 +78,30 @@ pub(crate) fn functions() -> &'static HashMap<&'static str, ForeignFunction> {
                 callable: Callable::Function(sin),
             },
         );
+        m.insert(
+            "asin",
+            ForeignFunction {
+                name: "asin".into(),
+                arity: 1..=1,
+                callable: Callable::Function(asin),
+            },
+        );
+        m.insert(
+            "acos",
+            ForeignFunction {
+                name: "acos".into(),
+                arity: 1..=1,
+                callable: Callable::Function(acos),
+            },
+        );
+        m.insert(
+            "atan",
+            ForeignFunction {
+                name: "atan".into(),
+                arity: 1..=1,
+                callable: Callable::Function(atan),
+            },
+        );
         m.insert(
             "atan2",
             ForeignFunction {
@@ -86,6 +110,54 @@ pub(crate) fn functions() -> &'static HashMap<&'static str, ForeignFunction> {
                 callable: Callable::Function(atan2),
             },
         );
+        m.insert(
+            "sinh",
+            ForeignFunction {
+                name: "sinh".into(),
+                arity: 1..=1,
+                callable: Callable::Function(sinh),
+            },
+        );
+        m.insert(
+            "cosh",
+            ForeignFunction {
+                name: "cosh".into(),
+                arity: 1..=1,
+                callable: Callable::Function(cosh),
+            },
+        );
+        m.insert(
+            "tanh",
+            ForeignFunction {
+                name: "tanh".into(),
+                arity: 1..=1,
+                callable: Callable::Function(tanh),
+            },
+        );
+        m.insert(
+            "asinh",
+            ForeignFunction {
+                name: "asinh".into(),
+                arity: 1..=1,
+                callable: Callable::Function(asinh),
+            },
+        );
+        m.insert(
+            "acosh",
+            ForeignFunction {
+                name: "acosh".into(),
+                arity: 1..=1,
+                callable: Callable::Function(acosh),
+            },
+        );
+        m.insert(
+            "atanh",
+            ForeignFunction {
+                name: "atanh".into(),
+                arity: 1..=1,
+                callable: Callable::Function(atanh),
+            },
+        );
         m.insert(
             "ln",
             ForeignFunction {
@@ -167,6 +239,69 @@ fn sin(args: &[Quantity]) -> Quantity {
     Quantity::from_scalar(input.sin())
 }
 
+fn asin(args: &[Quantity]) -> Quantity {
+    assert!(args.len() == 1);
+
+    let input = args[0].as_scalar().unwrap().to_f64();
+    Quantity::from_scalar(input.asin())
+}
+
+fn acos(args: &[Quantity]) -> Quantity {
+    assert!(args.len() == 1);
+
+    let input = args[0].as_scalar().unwrap().to_f64();
+    Quantity::from_scalar(input.acos())
+}
+
+fn atan(args: &[Quantity]) -> Quantity {
+    assert!(args.len() == 1);
+
+    let input = args[0].as_scalar().unwrap().to_f64();
+    Quantity::from_scalar(input.atan())
+}
+
+fn sinh(args: &[Quantity]) -> Quantity {
+    assert!(args.len() == 1);
+
+    let input = args[0].as_scalar().unwrap().to_f64();
+    Quantity::from_scalar(input.sinh())
+}
+
+fn cosh(args: &[Quantity]) -> Quantity {
+    assert!(args.len() == 1);
+
+    let input = args[0].as_scalar().unwrap().to_f64();
+    Quantity::from_scalar(input.cosh())
+}
+
+fn tanh(args: &[Quantity]) -> Quantity {
+    assert!(args.len() == 1);
+
+    let input = args[0].as_scalar().unwrap().to_f64();
+    Quantity::from_scalar(input.tanh())
+}
+
+fn asinh(args: &[Quantity]) -> Quantity {
+    assert!(args.len() == 1);
+
+    let input = args[0].as_scalar().unwrap().to_f64();
+    Quantity::from_scalar(input.asinh())
+}
+
+fn acosh(args: &[Quantity]) -> Quantity {
+    assert!(args.len() == 1);
+
+    let input = args[0].as_scalar().unwrap().to_f64();
+    Quantity::from_scalar(input.acosh())
+}
+
+fn atanh(args: &[Quantity]) -> Quantity {
+    assert!(args.len() == 1);
+
+    let input = args[0].as_scalar().unwrap().to_f64();
+    Quantity::from_scalar(input.atanh())
+}
+
 fn ln(args: &[Quantity]) -> Quantity {
     assert!(args.len() == 1);
 

prelude.nbt

@@ -214,8 +214,20 @@ let speed_of_light = 299792458 meter / second
 
 fn abs<T>(x: T) -> T
 fn round<T>(x: T) -> T
+
 fn sin(x: Scalar) -> Scalar
+fn asin(x: Scalar) -> Scalar
+fn acos(x: Scalar) -> Scalar
+fn atan(x: Scalar) -> Scalar
 fn atan2<T>(y: T, x: T) -> Scalar
+
+fn sinh(x: Scalar) -> Scalar
+fn cosh(x: Scalar) -> Scalar
+fn tanh(x: Scalar) -> Scalar
+fn asinh(x: Scalar) -> Scalar
+fn acosh(x: Scalar) -> Scalar
+fn atanh(x: Scalar) -> Scalar
+
 fn ln(x: Scalar) -> Scalar
 
 # TODO: implement these as foreign functions? => benchmark
@@ -227,6 +239,7 @@ fn exp(x: Scalar) -> Scalar = e^x
 fn cos(x: Scalar) -> Scalar = sin(x + π / 2)
 fn tan(x: Scalar) = sin(x) / cos(x)
 
+fn log(x: Scalar) -> Scalar = ln(x)
 fn log10(x: Scalar) -> Scalar = ln(x) / ln(10)
 fn log2(x: Scalar) -> Scalar = ln(x) / ln(2)