use alloc::format;
use alloc::string::String;
use crate::runtime::{Runtime, RuntimeError, Value};
fn the_number(rt: &mut Runtime<'_>, values: &[Value], at: usize) -> Option<Value> {
let value = values.get(at)?;
match value {
Value::Int(_) | Value::Float(_) => Some(value.clone()),
other => crate::v1::the_number_at_the_start_of_a_text(&rt.the_text_of(other)),
}
}
fn the_number_or_zero(rt: &mut Runtime<'_>, values: &[Value], at: usize) -> f64 {
the_number(rt, values, at)
.and_then(|value| value.to_number())
.unwrap_or(0.0)
}
fn the_whole_number(rt: &mut Runtime<'_>, values: &[Value], at: usize) -> Option<Value> {
let value = values.get(at)?;
match value {
Value::Int(_) | Value::Float(_) => Some(value.clone()),
other => crate::v1::the_number_of_a_text(&rt.the_text_of(other)),
}
}
pub(crate) fn abs(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let Some(number) = the_whole_number(rt, values, 0) else {
return Ok(Value::Text(String::new()));
};
Ok(match number {
Value::Int(number) => Value::Int(number.abs()),
other => Value::Float(other.to_number().unwrap_or(0.0).abs()),
})
}
pub(crate) fn ceil(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Int(
crate::runtime::ceil(the_number_or_zero(rt, values, 0)) as i64,
))
}
pub(crate) fn floor(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Int(
crate::runtime::floor(the_number_or_zero(rt, values, 0)) as i64,
))
}
pub(crate) fn round(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_or_zero(rt, values, 0);
if values.get(1).is_none() {
return Ok(Value::Int(crate::runtime::round(number) as i64));
}
let digits = the_number_or_zero(rt, values, 1) as i32;
let factor = crate::runtime::powf(10.0, digits as f64);
let rounded = crate::runtime::round(number * factor) / factor;
if digits <= 0 {
return Ok(Value::Int(rounded as i64));
}
Ok(Value::Text(format!("{:.*}", digits as usize, rounded)))
}
pub(crate) fn exp(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Float(crate::runtime::exp(the_number_or_zero(
rt, values, 0,
))))
}
pub(crate) fn ln(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_or_zero(rt, values, 0);
if number < 0.0 {
return Ok(Value::Text(String::new()));
}
Ok(Value::Float(crate::runtime::ln(number)))
}
pub(crate) fn log(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_or_zero(rt, values, 0);
if number < 0.0 {
return Ok(Value::Text(String::new()));
}
Ok(Value::Float(crate::runtime::log10(number)))
}
pub(crate) fn sqrt(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_or_zero(rt, values, 0);
if number < 0.0 {
return Ok(Value::Text(String::new()));
}
Ok(Value::Float(crate::runtime::sqrt(number)))
}
pub(crate) fn modulo(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let (Some(dividend), Some(divisor)) = (
the_whole_number(rt, values, 0),
the_whole_number(rt, values, 1),
) else {
return Ok(Value::Text(String::new()));
};
let (dividend_number, divisor_number) = (
dividend.to_number().unwrap_or(0.0),
divisor.to_number().unwrap_or(0.0),
);
if divisor_number == 0.0 {
return Ok(Value::Text(String::new()));
}
Ok(match (dividend, divisor) {
(Value::Int(dividend), Value::Int(divisor)) => Value::Int(dividend % divisor),
_ => Value::Float(dividend_number % divisor_number),
})
}
pub(crate) fn sin(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Float(crate::runtime::sin(the_number_or_zero(
rt, values, 0,
))))
}
pub(crate) fn cos(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Float(crate::runtime::cos(the_number_or_zero(
rt, values, 0,
))))
}
pub(crate) fn tan(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Float(crate::runtime::tan(the_number_or_zero(
rt, values, 0,
))))
}
pub(crate) fn asin(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_or_zero(rt, values, 0);
if !(-1.0..=1.0).contains(&number) {
return Ok(Value::Text(String::new()));
}
Ok(Value::Float(crate::runtime::asin(number)))
}
pub(crate) fn acos(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
let number = the_number_or_zero(rt, values, 0);
if !(-1.0..=1.0).contains(&number) {
return Ok(Value::Text(String::new()));
}
Ok(Value::Float(crate::runtime::acos(number)))
}
pub(crate) fn atan(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
Ok(Value::Float(crate::runtime::atan(the_number_or_zero(
rt, values, 0,
))))
}
pub(crate) fn max(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_biggest_or_the_smallest(rt, values, true)
}
pub(crate) fn min(
rt: &mut Runtime<'_>,
values: &[Value],
_line: u32,
_variant: u8,
) -> Result<Value, RuntimeError> {
the_biggest_or_the_smallest(rt, values, false)
}
fn the_biggest_or_the_smallest(
rt: &mut Runtime<'_>,
values: &[Value],
the_biggest: bool,
) -> Result<Value, RuntimeError> {
let mut answer: Option<Value> = None;
for at in 0..values.len() {
let Some(number) = the_whole_number(rt, values, at) else {
return Ok(Value::Text(String::new()));
};
let number_value = number.to_number().unwrap_or(0.0);
answer = Some(match answer {
None => number,
Some(previous) => {
let previous_value = previous.to_number().unwrap_or(0.0);
if (the_biggest && number_value > previous_value)
|| (!the_biggest && number_value < previous_value)
{
number
} else {
previous
}
}
});
}
Ok(answer.unwrap_or(Value::Text(String::new())))
}