use std::sync::Arc;
use rust_decimal::{Decimal, MathematicalOps};
use crate::interpreter::{Interpreter, Value};
use super::{NIL, delsh_bool};
pub fn is_number(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let arg = interpreter.eval(args[0].clone());
delsh_bool(arg.number().is_some())
}
pub fn is_int(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let arg = interpreter.eval(args[0].clone());
delsh_bool(arg.number().is_some_and(|num| num.is_integer()))
}
pub fn is_equal(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let a = interpreter.eval(args[0].clone());
let b = interpreter.eval(args[1].clone());
delsh_bool(a == b)
}
pub fn is_less(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let a = *interpreter
.eval(args[0].clone())
.number()
.expect("two numbers");
let b = *interpreter
.eval(args[1].clone())
.number()
.expect("two numbers");
delsh_bool(a < b)
}
pub fn is_greater(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let a = *interpreter
.eval(args[0].clone())
.number()
.expect("two numbers");
let b = *interpreter
.eval(args[1].clone())
.number()
.expect("two numbers");
delsh_bool(a > b)
}
pub fn is_zero(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let arg = interpreter.eval(args[0].clone());
delsh_bool(arg.number().is_some_and(|num| *num == Decimal::ZERO))
}
pub fn is_one(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let arg = interpreter.eval(args[0].clone());
delsh_bool(arg.number().is_some_and(|num| *num == Decimal::ONE))
}
pub fn is_negative(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let arg = interpreter.eval(args[0].clone());
delsh_bool(arg.number().is_some_and(|num| num.is_sign_negative()))
}
pub fn plus(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let mut total = Decimal::ZERO;
for arg in args {
let arg = interpreter.eval(arg.clone());
match &*arg {
Value::Number(num) => total += num,
_ => panic!("Expected a number"),
}
}
Arc::new(Value::Number(total))
}
pub fn minus(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
if args.len() == 1 {
let Value::Number(arg) = &*interpreter.eval(args[0].clone()) else {
panic!("expected a number")
};
Arc::new(Value::Number(-arg))
} else if args.len() == 2 {
let Value::Number(a) = &*interpreter.eval(args[0].clone()) else {
panic!("expected a number")
};
let Value::Number(b) = &*interpreter.eval(args[1].clone()) else {
panic!("expected a number")
};
return Arc::new(Value::Number(a - b));
} else {
panic!("expected one or two arguments")
}
}
pub fn negate(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let Value::Number(arg) = &*interpreter.eval(args[0].clone()) else {
panic!("expected a number")
};
Arc::new(Value::Number(-arg))
}
pub fn times(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let mut total = Decimal::ONE;
for arg in args {
let Value::Number(arg) = &*interpreter.eval(arg.clone()) else {
panic!("expected a number")
};
total *= arg;
}
Arc::new(Value::Number(total))
}
pub fn divide(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let Value::Number(arg1) = &*interpreter.eval(args[0].clone()) else {
panic!("expected a number")
};
let Value::Number(arg2) = &*interpreter.eval(args[1].clone()) else {
panic!("expected a number")
};
Arc::new(Value::Number(arg1 / arg2))
}
pub fn quotient(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let numerator = interpreter.eval(args[0].clone());
let numerator = numerator.number().expect("two numbers");
let denominator = interpreter.eval(args[1].clone());
let denominator = denominator.number().expect("two numbers");
Arc::new(Value::Number((numerator / denominator).floor()))
}
pub fn remainder(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let Value::Number(arg1) = &*interpreter.eval(args[0].clone()) else {
panic!("expected a number")
};
let Value::Number(arg2) = &*interpreter.eval(args[1].clone()) else {
panic!("expected a number")
};
Arc::new(Value::Number(arg1 % arg2))
}
pub fn add1(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
Arc::new(Value::Number(
interpreter
.eval(args[0].clone())
.number()
.expect("a number")
+ Decimal::ONE,
))
}
pub fn sub1(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
Arc::new(Value::Number(
interpreter
.eval(args[0].clone())
.number()
.expect("a number")
- Decimal::ONE,
))
}
pub fn max(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let max = interpreter.eval(args[0].clone());
let mut max = *max.number().expect("all args to be numbers");
for arg in &args[1..] {
let arg = interpreter.eval(arg.clone());
let arg = arg.number().expect("all args to be numbers");
max = max.max(*arg);
}
Arc::new(Value::Number(max))
}
pub fn min(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let min = interpreter.eval(args[0].clone());
let mut min = *min.number().expect("all args to be numbers");
for arg in &args[1..] {
let arg = interpreter.eval(arg.clone());
let arg = arg.number().expect("all args to be numbers");
min = min.min(*arg);
}
Arc::new(Value::Number(min))
}
pub fn recip(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let number = interpreter.eval(args[0].clone());
let number = number.number().expect("a number");
Arc::new(Value::Number(Decimal::ONE / number))
}
pub fn expt(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let x = *interpreter
.eval(args[0].clone())
.number()
.expect("two numbers");
let y = *interpreter
.eval(args[0].clone())
.number()
.expect("two numbers");
Arc::new(Value::Number(x.powd(y)))
}
pub fn sqrt(interpreter: &mut Interpreter, args: &[Arc<Value>]) -> Arc<Value> {
let Value::Number(arg) = &*interpreter.eval(args[0].clone()) else {
panic!("expected a number")
};
let Some(sqrt) = arg.sqrt() else {
return NIL.clone();
};
Arc::new(Value::Number(sqrt))
}
|
