cratification: start moving over the math commands to nu-cmd-extra (#9647)

* arccos
* arccosh
* arcsin
* arcsinh
* arctan
* arctanh

The above commands are being ported over to nu-cmd-extra

I initially moved all of the math commands over but there are some
issues with the tests...

So we will move them over slowly --- and actually I kind of like this
idea better...

Because some of the math commands we might want to leave in the core
nushell...

Stay tuned...

For more details 👍 
Read this document:

https://github.com/stormasm/nutmp/blob/main/commands/math.md

crates/nu-cmd-extra/src/extra/math/arccos.rs

@@ -0,0 +1,111 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Type, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math arccos"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math arccos")
+            .switch("degrees", "Return degrees instead of radians", Some('d'))
+            .input_output_types(vec![(Type::Number, Type::Float)])
+            .vectorizes_over_list(true)
+            .category(Category::Math)
+    }
+
+    fn usage(&self) -> &str {
+        "Returns the arccosine of the number."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["trigonometry", "inverse"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        let use_degrees = call.has_flag("degrees");
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        input.map(
+            move |value| operate(value, head, use_degrees),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get the arccosine of 1",
+                example: "1 | math arccos",
+                result: Some(Value::test_float(0.0f64)),
+            },
+            Example {
+                description: "Get the arccosine of -1 in degrees",
+                example: "-1 | math arccos -d",
+                result: Some(Value::test_float(180.0)),
+            },
+        ]
+    }
+}
+
+fn operate(value: Value, head: Span, use_degrees: bool) -> Value {
+    match value {
+        numeric @ (Value::Int { .. } | Value::Float { .. }) => {
+            let (val, span) = match numeric {
+                Value::Int { val, span } => (val as f64, span),
+                Value::Float { val, span } => (val, span),
+                _ => unreachable!(),
+            };
+
+            if (-1.0..=1.0).contains(&val) {
+                let val = val.acos();
+                let val = if use_degrees { val.to_degrees() } else { val };
+
+                Value::Float { val, span }
+            } else {
+                Value::Error {
+                    error: Box::new(ShellError::UnsupportedInput(
+                        "'arccos' undefined for values outside the closed interval [-1, 1].".into(),
+                        "value originates from here".into(),
+                        head,
+                        span,
+                    )),
+                }
+            }
+        }
+        Value::Error { .. } => value,
+        other => Value::Error {
+            error: Box::new(ShellError::OnlySupportsThisInputType {
+                exp_input_type: "numeric".into(),
+                wrong_type: other.get_type().to_string(),
+                dst_span: head,
+                src_span: other.expect_span(),
+            }),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-cmd-extra/src/extra/math/arccosh.rs

@@ -0,0 +1,101 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Type, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math arccosh"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math arccosh")
+            .input_output_types(vec![(Type::Number, Type::Float)])
+            .vectorizes_over_list(true)
+            .category(Category::Math)
+    }
+
+    fn usage(&self) -> &str {
+        "Returns the inverse of the hyperbolic cosine function."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["trigonometry", "inverse", "hyperbolic"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        input.map(
+            move |value| operate(value, head),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the arccosh of 1",
+            example: "1 | math arccosh",
+            result: Some(Value::test_float(0.0f64)),
+        }]
+    }
+}
+
+fn operate(value: Value, head: Span) -> Value {
+    match value {
+        numeric @ (Value::Int { .. } | Value::Float { .. }) => {
+            let (val, span) = match numeric {
+                Value::Int { val, span } => (val as f64, span),
+                Value::Float { val, span } => (val, span),
+                _ => unreachable!(),
+            };
+
+            if (1.0..).contains(&val) {
+                let val = val.acosh();
+
+                Value::Float { val, span }
+            } else {
+                Value::Error {
+                    error: Box::new(ShellError::UnsupportedInput(
+                        "'arccosh' undefined for values below 1.".into(),
+                        "value originates from here".into(),
+                        head,
+                        span,
+                    )),
+                }
+            }
+        }
+        Value::Error { .. } => value,
+        other => Value::Error {
+            error: Box::new(ShellError::OnlySupportsThisInputType {
+                exp_input_type: "numeric".into(),
+                wrong_type: other.get_type().to_string(),
+                dst_span: head,
+                src_span: other.expect_span(),
+            }),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-cmd-extra/src/extra/math/arcsin.rs

@@ -0,0 +1,112 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Type, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math arcsin"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math arcsin")
+            .switch("degrees", "Return degrees instead of radians", Some('d'))
+            .input_output_types(vec![(Type::Number, Type::Float)])
+            .vectorizes_over_list(true)
+            .category(Category::Math)
+    }
+
+    fn usage(&self) -> &str {
+        "Returns the arcsine of the number."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["trigonometry", "inverse"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        let use_degrees = call.has_flag("degrees");
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        input.map(
+            move |value| operate(value, head, use_degrees),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        let pi = std::f64::consts::PI;
+        vec![
+            Example {
+                description: "Get the arcsine of 1",
+                example: "1 | math arcsin",
+                result: Some(Value::test_float(pi / 2.0)),
+            },
+            Example {
+                description: "Get the arcsine of 1 in degrees",
+                example: "1 | math arcsin -d",
+                result: Some(Value::test_float(90.0)),
+            },
+        ]
+    }
+}
+
+fn operate(value: Value, head: Span, use_degrees: bool) -> Value {
+    match value {
+        numeric @ (Value::Int { .. } | Value::Float { .. }) => {
+            let (val, span) = match numeric {
+                Value::Int { val, span } => (val as f64, span),
+                Value::Float { val, span } => (val, span),
+                _ => unreachable!(),
+            };
+
+            if (-1.0..=1.0).contains(&val) {
+                let val = val.asin();
+                let val = if use_degrees { val.to_degrees() } else { val };
+
+                Value::Float { val, span }
+            } else {
+                Value::Error {
+                    error: Box::new(ShellError::UnsupportedInput(
+                        "'arcsin' undefined for values outside the closed interval [-1, 1].".into(),
+                        "value originates from here".into(),
+                        head,
+                        span,
+                    )),
+                }
+            }
+        }
+        Value::Error { .. } => value,
+        other => Value::Error {
+            error: Box::new(ShellError::OnlySupportsThisInputType {
+                exp_input_type: "numeric".into(),
+                wrong_type: other.get_type().to_string(),
+                dst_span: head,
+                src_span: other.expect_span(),
+            }),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-cmd-extra/src/extra/math/arcsinh.rs

@@ -0,0 +1,90 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Type, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math arcsinh"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math arcsinh")
+            .input_output_types(vec![(Type::Number, Type::Float)])
+            .vectorizes_over_list(true)
+            .category(Category::Math)
+    }
+
+    fn usage(&self) -> &str {
+        "Returns the inverse of the hyperbolic sine function."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["trigonometry", "inverse", "hyperbolic"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        input.map(
+            move |value| operate(value, head),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the arcsinh of 0",
+            example: "0 | math arcsinh",
+            result: Some(Value::test_float(0.0f64)),
+        }]
+    }
+}
+
+fn operate(value: Value, head: Span) -> Value {
+    match value {
+        numeric @ (Value::Int { .. } | Value::Float { .. }) => {
+            let (val, span) = match numeric {
+                Value::Int { val, span } => (val as f64, span),
+                Value::Float { val, span } => (val, span),
+                _ => unreachable!(),
+            };
+
+            let val = val.asinh();
+
+            Value::Float { val, span }
+        }
+        Value::Error { .. } => value,
+        other => Value::Error {
+            error: Box::new(ShellError::OnlySupportsThisInputType {
+                exp_input_type: "numeric".into(),
+                wrong_type: other.get_type().to_string(),
+                dst_span: head,
+                src_span: other.expect_span(),
+            }),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-cmd-extra/src/extra/math/arctan.rs

@@ -0,0 +1,101 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Type, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math arctan"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math arctan")
+            .switch("degrees", "Return degrees instead of radians", Some('d'))
+            .input_output_types(vec![(Type::Number, Type::Float)])
+            .vectorizes_over_list(true)
+            .category(Category::Math)
+    }
+
+    fn usage(&self) -> &str {
+        "Returns the arctangent of the number."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["trigonometry", "inverse"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        let use_degrees = call.has_flag("degrees");
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        input.map(
+            move |value| operate(value, head, use_degrees),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        let pi = std::f64::consts::PI;
+        vec![
+            Example {
+                description: "Get the arctangent of 1",
+                example: "1 | math arctan",
+                result: Some(Value::test_float(pi / 4.0f64)),
+            },
+            Example {
+                description: "Get the arctangent of -1 in degrees",
+                example: "-1 | math arctan -d",
+                result: Some(Value::test_float(-45.0)),
+            },
+        ]
+    }
+}
+
+fn operate(value: Value, head: Span, use_degrees: bool) -> Value {
+    match value {
+        numeric @ (Value::Int { .. } | Value::Float { .. }) => {
+            let (val, span) = match numeric {
+                Value::Int { val, span } => (val as f64, span),
+                Value::Float { val, span } => (val, span),
+                _ => unreachable!(),
+            };
+
+            let val = val.atan();
+            let val = if use_degrees { val.to_degrees() } else { val };
+
+            Value::Float { val, span }
+        }
+        Value::Error { .. } => value,
+        other => Value::Error {
+            error: Box::new(ShellError::OnlySupportsThisInputType {
+                exp_input_type: "numeric".into(),
+                wrong_type: other.get_type().to_string(),
+                dst_span: head,
+                src_span: other.expect_span(),
+            }),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-cmd-extra/src/extra/math/arctanh.rs

@@ -0,0 +1,101 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Type, Value};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "math arctanh"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("math arctanh")
+            .input_output_types(vec![(Type::Number, Type::Float)])
+            .vectorizes_over_list(true)
+            .category(Category::Math)
+    }
+
+    fn usage(&self) -> &str {
+        "Returns the inverse of the hyperbolic tangent function."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["trigonometry", "inverse", "hyperbolic"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let head = call.head;
+        // This doesn't match explicit nulls
+        if matches!(input, PipelineData::Empty) {
+            return Err(ShellError::PipelineEmpty { dst_span: head });
+        }
+        input.map(
+            move |value| operate(value, head),
+            engine_state.ctrlc.clone(),
+        )
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Get the arctanh of 1",
+            example: "1 | math arctanh",
+            result: Some(Value::test_float(f64::INFINITY)),
+        }]
+    }
+}
+
+fn operate(value: Value, head: Span) -> Value {
+    match value {
+        numeric @ (Value::Int { .. } | Value::Float { .. }) => {
+            let (val, span) = match numeric {
+                Value::Int { val, span } => (val as f64, span),
+                Value::Float { val, span } => (val, span),
+                _ => unreachable!(),
+            };
+
+            if (-1.0..=1.0).contains(&val) {
+                let val = val.atanh();
+
+                Value::Float { val, span }
+            } else {
+                Value::Error {
+                    error: Box::new(ShellError::UnsupportedInput(
+                        "'arctanh' undefined for values outside the open interval (-1, 1).".into(),
+                        "value originates from here".into(),
+                        head,
+                        span,
+                    )),
+                }
+            }
+        }
+        Value::Error { .. } => value,
+        other => Value::Error {
+            error: Box::new(ShellError::OnlySupportsThisInputType {
+                exp_input_type: "numeric".into(),
+                wrong_type: other.get_type().to_string(),
+                dst_span: head,
+                src_span: other.expect_span(),
+            }),
+        },
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-cmd-extra/src/extra/math/mod.rs

@@ -0,0 +1,13 @@
+mod arccos;
+mod arccosh;
+mod arcsin;
+mod arcsinh;
+mod arctan;
+mod arctanh;
+
+pub use arccos::SubCommand as MathArcCos;
+pub use arccosh::SubCommand as MathArcCosH;
+pub use arcsin::SubCommand as MathArcSin;
+pub use arcsinh::SubCommand as MathArcSinH;
+pub use arctan::SubCommand as MathArcTan;
+pub use arctanh::SubCommand as MathArcTanH;

crates/nu-cmd-extra/src/extra/mod.rs

@@ -3,6 +3,7 @@ mod bytes;
 mod conversions;
 mod filters;
 mod formats;
+mod math;
 mod platform;
 mod strings;
 
@@ -30,6 +31,13 @@ pub use bits::BitsShl;
 pub use bits::BitsShr;
 pub use bits::BitsXor;
 
+pub use math::MathArcCos;
+pub use math::MathArcCosH;
+pub use math::MathArcSin;
+pub use math::MathArcSinH;
+pub use math::MathArcTan;
+pub use math::MathArcTanH;
+
 use nu_protocol::engine::{EngineState, StateWorkingSet};
 
 pub fn add_extra_command_context(mut engine_state: EngineState) -> EngineState {
@@ -98,6 +106,16 @@ pub fn add_extra_command_context(mut engine_state: EngineState) -> EngineState {
             BytesBuild
         }
 
+        // Math
+        bind_command! {
+            MathArcSin,
+            MathArcCos,
+            MathArcTan,
+            MathArcSinH,
+            MathArcCosH,
+            MathArcTanH
+        };
+
         working_set.render()
     };