extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-08-09 05:34:58 +02:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
This commit is contained in:
Michael Angerman
2023-07-10 12:08:45 -07:00
committed by GitHub
parent cf36f052c4
commit e10d84b72f
10 changed files with 31 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
crates/nu-command/src/math/arccos.rs
View File

@ -1,111 +0,0 @@
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 {})
}
}

101
crates/nu-command/src/math/arccosh.rs
View File

@ -1,101 +0,0 @@
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 {})
}
}

112
crates/nu-command/src/math/arcsin.rs
View File

@ -1,112 +0,0 @@
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 {})
}
}

90
crates/nu-command/src/math/arcsinh.rs
View File

@ -1,90 +0,0 @@
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 {})
}
}

101
crates/nu-command/src/math/arctan.rs
View File

@ -1,101 +0,0 @@
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 {})
}
}

101
crates/nu-command/src/math/arctanh.rs
View File

@ -1,101 +0,0 @@
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 {})
}
}

13
crates/nu-command/src/math/mod.rs
View File

@ -1,10 +1,4 @@
mod abs;
mod arccos;
mod arccosh;
mod arcsin;
mod arcsinh;
mod arctan;
mod arctanh;
mod avg;
mod ceil;
mod cos;
@ -59,13 +53,6 @@ pub use sinh::SubCommand as MathSinH;
pub use tan::SubCommand as MathTan;
pub use tanh::SubCommand as MathTanH;
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;
pub use egamma::SubCommand as MathEulerGamma;
pub use euler::SubCommand as MathEuler;
pub use phi::SubCommand as MathPhi;