aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorBryan Newbold <bnewbold@robocracy.org>2021-10-24 17:50:04 -0700
committerBryan Newbold <bnewbold@robocracy.org>2021-10-24 17:50:04 -0700
commit04c53bb88bfbbc5c65b25104959c66d06e2b4fa1 (patch)
treeacd6a70c7e83f3cf4c31bc085f6d4130a9b7be20 /src
parent76a5c98ef5588e94301f2d1b44b51907e5004abe (diff)
downloadcasual-04c53bb88bfbbc5c65b25104959c66d06e2b4fa1.tar.gz
casual-04c53bb88bfbbc5c65b25104959c66d06e2b4fa1.zip
constants; clean up product and sum code
Diffstat (limited to 'src')
-rw-r--r--src/cexpr.rs223
1 files changed, 169 insertions, 54 deletions
diff --git a/src/cexpr.rs b/src/cexpr.rs
index 1971feb..b183c4a 100644
--- a/src/cexpr.rs
+++ b/src/cexpr.rs
@@ -1,8 +1,7 @@
/*
- * Canonical Expressions
+ * "Canonical" Expressions
*
* AKA, simplified, normalized algebraic expressions.
- *
*/
use crate::sexpr::SExpr;
@@ -10,25 +9,30 @@ use std::fmt;
#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub enum NumericConstant {
- Pi, // 3.141592...
- E, // 2.718281...
+ Pi,
+ E,
+ GoldenRatio,
}
impl NumericConstant {
- pub fn as_number(&self) -> CNumber {
- use CNumber::*;
- use NumericConstant::*;
- match self {
- Pi => Float(3.141592f64),
- E => Float(2.718281f64),
+ /*
+ pub fn as_number(&self) -> CNumber {
+ use CNumber::*;
+ use NumericConstant::*;
+ match self {
+ Pi => Float(3.14159265358979323846f64),
+ E => Float(2.71828182845904523536f64),
+ GoldenRatio => Float(1.61803398874989484820f64),
+ }
}
- }
+ */
pub fn as_string(&self) -> String {
use NumericConstant::*;
match self {
Pi => "pi".to_string(),
E => "e".to_string(),
+ GoldenRatio => "golden-ratio".to_string(),
}
}
}
@@ -53,6 +57,46 @@ impl CNumber {
CNumber::Float(v) => Ok(SExpr::SFloat(*v)),
}
}
+
+ pub fn sum(&self, other: &CNumber) -> CNumber {
+ use CNumber::*;
+ match (self, other) {
+ (Integer(a), Integer(b)) => Integer(a + b),
+ (Integer(i), Rational(n, d)) | (Rational(n, d), Integer(i)) => Rational(n + d * i, *d),
+ (Rational(a, b), Rational(c, d)) if b == d => Rational(a + c, *d),
+ (Rational(a, b), Rational(c, d)) => Rational(a * d + c * b, b * d),
+ (Float(a), Float(b)) => Float(a + b),
+ (Integer(i), Float(f)) | (Float(f), Integer(i)) => Float((*i as f64) + f),
+ (Rational(n, d), Float(f)) | (Float(f), Rational(n, d)) => {
+ Float(f + (*n as f64) / (*d as f64))
+ }
+ }
+ }
+
+ pub fn product(&self, other: &CNumber) -> CNumber {
+ use CNumber::*;
+ match (self, other) {
+ (Integer(0), _) | (_, Integer(0)) => Integer(0),
+ (Integer(a), Integer(b)) => Integer(a * b),
+ (Integer(i), Rational(n, d)) | (Rational(n, d), Integer(i)) => Rational(i * n, *d),
+ (Rational(a, b), Rational(c, d)) if a == d && b == c => Integer(1),
+ (Rational(a, b), Rational(c, d)) => Rational(a * c, b * d),
+ (Float(a), Float(b)) => Float(a * b),
+ (Integer(i), Float(f)) | (Float(f), Integer(i)) => Float((*i as f64) * f),
+ (Rational(n, d), Float(f)) | (Float(f), Rational(n, d)) => {
+ Float(f * (*n as f64) / (*d as f64))
+ }
+ }
+ }
+
+ pub fn is_negative(&self) -> bool {
+ use CNumber::*;
+ match self {
+ Integer(i) => *i < 0,
+ Rational(n, _) => *n < 0,
+ Float(f) => *f < 0.0f64,
+ }
+ }
}
#[derive(Clone, PartialEq, PartialOrd)]
@@ -68,6 +112,16 @@ pub enum CExpr {
UnaryFunction(String, Box<CExpr>),
}
+fn compute_factorial(n: i64) -> i64 {
+ if n < 0 {
+ panic!("tried to compute negative factorial");
+ } else if n == 0 {
+ return 1;
+ } else {
+ return n * compute_factorial(n - 1);
+ }
+}
+
impl CExpr {
pub fn from_sexpr(sexpr: &SExpr) -> Result<CExpr, String> {
// not all cases are handled; some atoms are covered trivialy
@@ -76,10 +130,11 @@ impl CExpr {
SExpr::SBoolean(_) => Err("booleans not handled".to_string()),
SExpr::SInteger(v) => Ok(CExpr::Number(CNumber::Integer(*v))),
SExpr::SFloat(v) => Ok(CExpr::Number(CNumber::Float(*v))),
- SExpr::SString(_) => Err("null not handled".to_string()),
+ SExpr::SString(_) => Err("strings not handled".to_string()),
SExpr::SIdentifier(v) => match v.as_str() {
"pi" => Ok(CExpr::Constant(NumericConstant::Pi)),
"e" => Ok(CExpr::Constant(NumericConstant::E)),
+ "golden-ratio" => Ok(CExpr::Constant(NumericConstant::GoldenRatio)),
_ => Ok(CExpr::Symbol(v.to_string())),
},
SExpr::SList(l) => CExpr::from_sexpr_list(l),
@@ -87,10 +142,19 @@ impl CExpr {
}
pub fn from_sexpr_list(list: &Vec<SExpr>) -> Result<CExpr, String> {
+ use CExpr::*;
+ use CNumber::*;
+ use SExpr::*;
// https://adventures.michaelfbryan.com/posts/daily/slice-patterns/
if let [SExpr::SIdentifier(ident), rest @ ..] = list.as_slice() {
match (ident.as_str(), rest.len()) {
- ("factorial", 1) => Ok(CExpr::Factorial(Box::new(CExpr::from_sexpr(&rest[0])?))),
+ ("factorial", 1) => match CExpr::from_sexpr(&rest[0])? {
+ Number(n) if n.is_negative() => {
+ Err("negative factorial is not defined".to_string())
+ }
+ Number(Integer(i)) if i <= 18 => Ok(Number(Integer(compute_factorial(i)))),
+ other => Ok(Factorial(Box::new(other))),
+ },
("cos" | "sin" | "tan", 1) => Ok(CExpr::UnaryFunction(
ident.to_string(),
Box::new(CExpr::from_sexpr(&rest[0])?),
@@ -98,40 +162,43 @@ impl CExpr {
("^", 2) => {
let base = CExpr::from_sexpr(&rest[0])?;
let power = CExpr::from_sexpr(&rest[1])?;
- use CExpr::*;
- use CNumber::*;
match (base, power) {
(Number(Integer(0)), _) => Ok(Number(Integer(0))),
(Number(Integer(1)), _) => Ok(Number(Integer(1))),
(_, Number(Integer(0))) => Ok(Number(Integer(1))),
(base, Number(Integer(1))) => Ok(base),
+ (Number(Rational(1, d)), Number(Integer(-1))) => Ok(Number(Integer(d))),
+ (Number(Rational(n, d)), Number(Integer(-1))) => Ok(Number(Rational(d, n))),
+ (Exponent(base, p1), p2) => match (*p1, p2) {
+ (Number(n1), Number(n2)) => {
+ Ok(Exponent(base, Box::new(Number(n1.product(&n2)))))
+ }
+ (p1, p2) => {
+ Ok(Exponent(base, Box::new(CExpr::new_product(vec![p1, p2])?)))
+ }
+ },
(base, power) => Ok(Exponent(Box::new(base), Box::new(power))),
}
}
- ("/", 2) => {
- use CExpr::*;
- use CNumber::*;
- use SExpr::*;
- match (&rest[0], &rest[1]) {
- (_, SInteger(0)) => Err("division by zero".to_string()),
- (SInteger(0), _) => Ok(Number(Integer(0))),
- (se, SInteger(1)) => CExpr::from_sexpr(se),
- (SInteger(a), SInteger(b)) if a == b => Ok(Number(Integer(1))),
- (SInteger(a), SInteger(b)) if a % b == 0 => Ok(Number(Integer(a / b))),
- (SInteger(a), SInteger(b)) => Ok(Number(Rational(*a, *b))),
- (SInteger(1), b) => {
- let denom = CExpr::from_sexpr(b)?;
- Ok(Exponent(Box::new(denom), Box::new(Number(Integer(-1)))))
- }
- (a, b) => {
- let (numer, denom) = (CExpr::from_sexpr(a)?, CExpr::from_sexpr(b)?);
- CExpr::new_product(vec![
- numer,
- Exponent(Box::new(denom), Box::new(Number(Integer(-1)))),
- ])
- }
+ ("/", 2) => match (&rest[0], &rest[1]) {
+ (_, SInteger(0)) => Err("division by zero".to_string()),
+ (SInteger(0), _) => Ok(Number(Integer(0))),
+ (se, SInteger(1)) => CExpr::from_sexpr(se),
+ (SInteger(a), SInteger(b)) if a == b => Ok(Number(Integer(1))),
+ (SInteger(a), SInteger(b)) if a % b == 0 => Ok(Number(Integer(a / b))),
+ (SInteger(a), SInteger(b)) => Ok(Number(Rational(*a, *b))),
+ (SInteger(1), b) => {
+ let denom = CExpr::from_sexpr(b)?;
+ Ok(Exponent(Box::new(denom), Box::new(Number(Integer(-1)))))
}
- }
+ (a, b) => {
+ let (numer, denom) = (CExpr::from_sexpr(a)?, CExpr::from_sexpr(b)?);
+ CExpr::new_product(vec![
+ numer,
+ Exponent(Box::new(denom), Box::new(Number(Integer(-1)))),
+ ])
+ }
+ },
// TODO: how to make range unbounded? or less bounded?
("+", 2..=5000) => {
CExpr::new_sum(rest.iter().map(|v| CExpr::from_sexpr(v)).collect::<Result<
@@ -150,8 +217,6 @@ impl CExpr {
("-", 2) => {
let a = CExpr::from_sexpr(&rest[0])?;
let b = CExpr::from_sexpr(&rest[1])?;
- use CExpr::*;
- use CNumber::*;
match (a, b) {
(expr, Number(Integer(0))) => Ok(expr),
(Number(Integer(a)), Number(Integer(b))) => Ok(Number(Integer(a - b))),
@@ -171,27 +236,77 @@ impl CExpr {
}
}
- pub fn new_sum(mut list: Vec<CExpr>) -> Result<CExpr, String> {
+ pub fn new_sum(list: Vec<CExpr>) -> Result<CExpr, String> {
use CExpr::*;
use CNumber::*;
- list.sort_by(|a, b| a.partial_cmp(b).unwrap());
- match list.as_slice() {
- [Number(Integer(0)), e] => Ok(e.clone()), // XXX: remove clone()
- [Number(Integer(a)), Number(Integer(b))] => Ok(Number(Integer(a + b))),
- [Number(Integer(a)), Number(Rational(n, d))] => Ok(Number(Rational(n + a * d, *d))),
- _ => Ok(Sum(None, list)),
+ let (numeric, mut rest): (Vec<CExpr>, Vec<CExpr>) = list
+ .into_iter()
+ .flat_map(|e| match e {
+ Sum(None, l) => l,
+ Sum(Some(num), mut l) => {
+ l.push(Number(num));
+ l
+ }
+ e => vec![e],
+ })
+ .partition(|v| {
+ if let Number(Integer(_) | Rational(_, _)) = v {
+ true
+ } else {
+ false
+ }
+ });
+
+ let num: Option<CNumber> = numeric
+ .into_iter()
+ .map(|v| if let Number(n) = v { n } else { unreachable!() })
+ .reduce(|a, b| a.sum(&b));
+
+ rest.sort_by(|a, b| a.partial_cmp(b).unwrap());
+
+ match (num, rest) {
+ (None, mut rest) if rest.len() == 1 => Ok(rest.remove(0)),
+ (None, rest) if rest.is_empty() => unreachable!("empty list passed to new_product()"),
+ (Some(n), rest) if rest.is_empty() => Ok(Number(n)),
+ (Some(Integer(0)), rest) => Ok(Sum(None, rest)),
+ (n, r) => Ok(Sum(n, r)),
}
}
- pub fn new_product(mut list: Vec<CExpr>) -> Result<CExpr, String> {
+ pub fn new_product(list: Vec<CExpr>) -> Result<CExpr, String> {
use CExpr::*;
use CNumber::*;
- list.sort_by(|a, b| a.partial_cmp(b).unwrap());
- match list.as_slice() {
- [Number(Integer(1)), e] => Ok(e.clone()), // XXX: remove clone()
- [Number(Integer(a)), Number(Integer(b))] => Ok(Number(Integer(a * b))),
- [Number(Integer(a)), Number(Rational(n, d))] => Ok(Number(Rational(a * n, *d))),
- _ => Ok(Product(None, list)),
+ let (numeric, mut rest): (Vec<CExpr>, Vec<CExpr>) = list
+ .into_iter()
+ .flat_map(|e| match e {
+ Product(None, l) => l,
+ Product(Some(num), mut l) => {
+ l.push(Number(num));
+ l
+ }
+ e => vec![e],
+ })
+ .partition(|v| {
+ if let Number(Integer(_) | Rational(_, _)) = v {
+ true
+ } else {
+ false
+ }
+ });
+
+ let num: Option<CNumber> = numeric
+ .into_iter()
+ .map(|v| if let Number(n) = v { n } else { unreachable!() })
+ .reduce(|a, b| a.product(&b));
+
+ rest.sort_by(|a, b| a.partial_cmp(b).unwrap());
+
+ match (num, rest) {
+ (None, mut rest) if rest.len() == 1 => Ok(rest.remove(0)),
+ (None, rest) if rest.is_empty() => unreachable!("empty list passed to new_product()"),
+ (Some(n), rest) if rest.is_empty() => Ok(Number(n)),
+ (Some(Integer(1)), rest) => Ok(Product(None, rest)),
+ (n, r) => Ok(Product(n, r)),
}
}