Mark
/
daisy
mirror of https://github.com/rm-dr/daisy
1
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Reorganized quantity

pull/2/head
Mark 2023-04-08 20:26:07 -07:00
parent 5b8dd2f703
commit fb9cc03bb9
Signed by: Mark
GPG Key ID: AD62BB059C2AAEE4
8 changed files with 655 additions and 610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/parser/mod.rs
View File

@ -98,13 +98,13 @@ impl PreToken {
// Units // Units
"m" => { "m" => {
let mut u = Quantity::new_rational(1, 1); let mut u = Quantity::new_rational_from_string("1").unwrap();
u.add_unit(BaseUnit::Meter, 1f64); u.add_unit(BaseUnit::Meter, 1f64);
Token::Number(u) Token::Number(u)
}, },
"s" => { "s" => {
let mut u = Quantity::new_rational(1, 1); let mut u = Quantity::new_rational_from_string("1").unwrap();
u.add_unit(BaseUnit::Second, 1f64); u.add_unit(BaseUnit::Second, 1f64);
Token::Number(u) Token::Number(u)
} }

88
src/quantity/mod.rs
View File

@ -1,12 +1,3 @@
use std::ops::{
Add, Sub, Mul, Div,
Neg, Rem,
AddAssign, SubAssign,
MulAssign, DivAssign
};
/* /*
Quantity: Quantity:
Represents a value with a unit attached to it. Represents a value with a unit attached to it.
@ -24,82 +15,13 @@ The cfg_if blocks here are a temporary hack to allow for
cross-compilation to other systems. RUG does not work on all systems. cross-compilation to other systems. RUG does not work on all systems.
*/ */
pub mod quantity; mod scalar;
pub(in crate::quantity) use crate::quantity::scalar::Scalar;
mod unit; mod unit;
pub use crate::quantity::unit::Unit; pub use crate::quantity::unit::Unit;
pub use crate::quantity::unit::BaseUnit; pub use crate::quantity::unit::BaseUnit;
cfg_if::cfg_if! { mod quantity;
if #[cfg(target_family = "unix")] {
mod rationalq;
mod floatq;
} else {
mod f64q;
}
}
macro_rules! wrap_rational {
( $x:expr, $y:expr ) => { Quantity::Rational{v: $x, u: $y} }
}
macro_rules! wrap_float {
( $x:expr, $y:expr ) => { Quantity::Float{v: $x, u: $y} }
}
pub use crate::quantity::quantity::Quantity; pub use crate::quantity::quantity::Quantity;
pub(in crate::quantity) use wrap_rational;
pub(in crate::quantity) use wrap_float;
const FLOAT_PRECISION: u32 = 1024;
const PRINT_LEN: usize = 5; // How many significant digits we will show in output
pub trait RationalBase: QuantBase {
fn from_frac(top: i64, bot: i64) -> Self;
fn from_f64(f: f64) -> Option<Self> where Self: Sized;
fn from_string(s: &str) -> Option<Self>where Self: Sized;
}
pub trait FloatBase: QuantBase {
fn from_f64(f: f64) -> Option<Self> where Self: Sized;
fn from_string(s: &str) -> Option<Self> where Self: Sized;
}
pub trait QuantBase:
Sized + ToString +
Add + AddAssign +
Sub + SubAssign +
Mul + MulAssign +
Div + DivAssign +
Neg + Rem +
PartialEq + PartialOrd
{
fn fract(&self) -> Option<Self>;
fn is_zero(&self) -> bool;
fn is_negative(&self) -> bool;
fn is_positive(&self) -> bool;
fn exp(&self) -> Option<Self>;
fn abs(&self) -> Option<Self>;
fn floor(&self) -> Option<Self>;
fn ceil(&self) -> Option<Self>;
fn round(&self) -> Option<Self>;
fn sin(&self) -> Option<Self>;
fn cos(&self) -> Option<Self>;
fn tan(&self) -> Option<Self>;
fn asin(&self) -> Option<Self>;
fn acos(&self) -> Option<Self>;
fn atan(&self) -> Option<Self>;
fn sinh(&self) -> Option<Self>;
fn cosh(&self) -> Option<Self>;
fn tanh(&self) -> Option<Self>;
fn asinh(&self) -> Option<Self>;
fn acosh(&self) -> Option<Self>;
fn atanh(&self) -> Option<Self>;
fn ln(&self) -> Option<Self>;
fn log10(&self) -> Option<Self>;
fn log2(&self) -> Option<Self>;
fn log(&self, base: Self) -> Option<Self>;
fn pow(&self, exp: Self) -> Option<Self>;
}

443
src/quantity/quantity.rs
View File

@ -7,171 +7,85 @@ use std::ops::{
}; };
use std::cmp::Ordering; use std::cmp::Ordering;
use crate::quantity::wrap_rational;
use crate::quantity::wrap_float;
use crate::quantity::QuantBase;
use crate::quantity::RationalBase;
use crate::quantity::FloatBase;
use crate::quantity::Unit; use crate::quantity::Unit;
use crate::quantity::BaseUnit; use crate::quantity::BaseUnit;
cfg_if::cfg_if! {
if #[cfg(target_family = "unix")] { use crate::quantity::Scalar;
use crate::quantity::rationalq::RationalQ;
use crate::quantity::floatq::FloatQ;
#[derive(Debug)] #[derive(Debug)]
#[derive(Clone)] #[derive(Clone)]
pub enum Quantity { pub struct Quantity {
Rational{ v: RationalQ, u: Unit }, v: Scalar,
Float{ v: FloatQ, u: Unit } u: Unit
}
} else {
use crate::quantity::f64q::F64Q;
#[derive(Debug)]
#[derive(Clone)]
pub enum Quantity {
Rational{ v: F64Q, u: Unit },
Float{ v: F64Q, u: Unit }
}
}
}
impl Quantity {
cfg_if::cfg_if! {
if #[cfg(target_family = "unix")] {
pub fn new_rational(top: i64, bottom: i64) -> Quantity {
return wrap_rational!(
RationalQ::from_frac(top, bottom),
Unit::new()
);
}
pub fn new_float(v: f64) -> Quantity {
return wrap_float!(
FloatQ::from_f64(v).unwrap(),
Unit::new()
)
}
pub fn new_rational_from_string(s: &str) -> Option<Quantity> {
let r = RationalQ::from_string(s);
if r.is_none() { return None; }
return Some(wrap_rational!(
r.unwrap(),
Unit::new()
));
}
pub fn new_float_from_string(s: &str) -> Option<Quantity> {
let v = FloatQ::from_string(s);
if v.is_none() { return None; }
return Some(wrap_float!(
v.unwrap(),
Unit::new()
))
}
pub fn float_from_rat(r: &Quantity) -> Quantity {
match &r {
Quantity::Float { .. } => r.clone(),
Quantity::Rational { v, u } => wrap_float!(
FloatQ::from(v.val.numer()).unwrap() /
FloatQ::from(v.val.denom()).unwrap(),
u.clone()
)
}
}
} else {
pub fn new_rational(top: i64, bottom: i64) -> Quantity {
return wrap_float!(F64Q::from_f64( (top as f64) / (bottom as f64)).unwrap())
}
pub fn new_float(v: f64) -> Quantity {
return wrap_float!(F64Q::from_f64(v).unwrap())
}
pub fn new_rational_from_string(s: &str) -> Option<Quantity> {
let r = F64Q::from_string(s);
if r.is_none() { return None; }
return Some(wrap_rational!(r.unwrap()));
}
pub fn new_float_from_string(s: &str) -> Option<Quantity> {
let v = F64Q::from_string(s);
if v.is_none() { return None; }
return Some(wrap_float!(v.unwrap()))
}
pub fn float_from_rat(r: &Quantity) -> Quantity {
match &r {
Quantity::Float { .. } => r.clone(),
Quantity::Rational { .. } => r.clone()
}
}
}
}
pub fn is_nan(&self) -> bool {
match self {
Quantity::Float { v, .. } => {v.val.is_nan()},
Quantity::Rational { .. } => {panic!()}
}
}
pub fn add_unit(&mut self, ui: BaseUnit, pi: f64) {
match self {
Quantity::Float { u, .. } => {u.insert(ui, pi)},
Quantity::Rational { u, .. } => {u.insert(ui, pi)}
}
}
} }
impl ToString for Quantity { impl ToString for Quantity {
fn to_string(&self) -> String { fn to_string(&self) -> String {
let mut n: String; let n = self.v.to_string();
let u: &Unit;
match self {
Quantity::Rational{u:un, ..} => {
n = Quantity::float_from_rat(self).to_string();
u = un
},
Quantity::Float{v, u:un} => {
n = v.to_string();
u = un;
},
};
//n.push(' '); //n.push(' ');
//n.push_str(&u.to_string()); //n.push_str(&u.to_string());
n n
} }
} }
impl Quantity {
pub fn new_float(f: f64) -> Option<Quantity> {
let v = Scalar::new_float(f);
if v.is_none() { return None; }
return Some(Quantity{
v: v.unwrap(),
u: Unit::new()
});
}
pub fn new_rational(f: f64) -> Option<Quantity> {
let v = Scalar::new_rational(f);
if v.is_none() { return None; }
return Some(Quantity{
v: v.unwrap(),
u: Unit::new()
});
}
pub fn new_float_from_string(s: &str) -> Option<Quantity> {
let v = Scalar::new_float_from_string(s);
if v.is_none() { return None; }
return Some(Quantity{
v: v.unwrap(),
u: Unit::new()
});
}
pub fn new_rational_from_string(s: &str) -> Option<Quantity> {
let v = Scalar::new_rational_from_string(s);
if v.is_none() { return None; }
return Some(Quantity{
v: v.unwrap(),
u: Unit::new()
});
}
pub fn add_unit(&mut self, ui: BaseUnit, pi: f64) {
self.u.insert(ui, pi)
}
}
macro_rules! quant_foward { macro_rules! quant_foward {
( $x:ident ) => { ( $x:ident ) => {
pub fn $x(&self) -> Quantity { pub fn $x(&self) -> Quantity {
match self { if !self.unitless() { panic!() }
Quantity::Rational{v, u} => { Quantity {
if !u.unitless() { panic!() } v: self.v.$x(),
let r = v.$x(); u: self.u.clone()
if r.is_none() {
let v = Quantity::float_from_rat(self);
return v.$x();
} else {wrap_rational!(r.unwrap(), u.clone())}
},
Quantity::Float{v, u} => {
if !u.unitless() { panic!() }
wrap_float!(v.$x().unwrap(), u.clone())
},
} }
} }
} }
@ -179,33 +93,11 @@ macro_rules! quant_foward {
impl Quantity { impl Quantity {
pub fn is_zero(&self) -> bool { pub fn is_zero(&self) -> bool { self.v.is_zero() }
match self { pub fn is_nan(&self) -> bool { self.v.is_nan() }
Quantity::Rational{v, .. } => v.is_zero(), pub fn is_negative(&self) -> bool { self.v.is_negative() }
Quantity::Float{v, .. } => v.is_zero(), pub fn is_positive(&self) -> bool { self.v.is_positive() }
} pub fn unitless(&self) -> bool { self.u.unitless() }
}
pub fn is_negative(&self) -> bool {
match self {
Quantity::Rational{v, .. } => v.is_negative(),
Quantity::Float{v, .. } => v.is_negative(),
}
}
pub fn is_positive(&self) -> bool {
match self {
Quantity::Rational{v, .. } => v.is_positive(),
Quantity::Float{v, .. } => v.is_positive(),
}
}
pub fn unitless(&self) -> bool {
match self {
Quantity::Rational{ u, .. } => u.unitless(),
Quantity::Float{ u, .. } => u.unitless(),
}
}
quant_foward!(fract); quant_foward!(fract);
quant_foward!(abs); quant_foward!(abs);
@ -230,67 +122,30 @@ impl Quantity {
quant_foward!(log2); quant_foward!(log2);
pub fn log(&self, base: Quantity) -> Quantity { pub fn log(&self, base: Quantity) -> Quantity {
if !self.unitless() { panic!() } if !self.unitless() { panic!() }
Quantity {
match self { v: self.v.log(base.v),
Quantity::Rational{u, .. } => { u: self.u.clone()
if !u.unitless() { panic!() }
Quantity::float_from_rat(self).log(Quantity::float_from_rat(&base))
},
Quantity::Float{u, .. } => {
if !u.unitless() { panic!() }
Quantity::float_from_rat(self).log(base)
},
} }
} }
pub fn pow(&self, base: Quantity) -> Quantity {
match self {
Quantity::Rational{u, .. } => {
let a = match Quantity::float_from_rat(self) {
Quantity::Rational{ .. } => panic!(),
Quantity::Float{v, .. } => v,
};
let b = match Quantity::float_from_rat(&base) { pub fn pow(&self, pwr: Quantity) -> Quantity {
Quantity::Rational{ .. } => panic!(), if !self.unitless() { panic!() }
Quantity::Float{v, .. } => v, Quantity {
}; v: self.v.pow(pwr.v),
u: self.u.clone()
let mut nu = u.clone();
nu.pow(2f64);
wrap_float!(a.pow(b).unwrap(), nu)
},
Quantity::Float{u, .. } => {
if !u.unitless() { panic!() }
let a = match Quantity::float_from_rat(self) {
Quantity::Rational{ .. } => panic!(),
Quantity::Float{v, .. } => v,
};
let b = match Quantity::float_from_rat(&base) {
Quantity::Rational{ .. } => panic!(),
Quantity::Float{v, .. } => v,
};
let mut nu = u.clone();
nu.pow(2f64);
wrap_float!(a.pow(b).unwrap(), nu)
},
} }
} }
} }
impl Neg for Quantity where { impl Neg for Quantity where {
type Output = Self; type Output = Self;
fn neg(self) -> Self::Output { fn neg(self) -> Self::Output {
match self { Quantity {
Quantity::Float { v, u } => {wrap_float!(-v, u)}, v: -self.v,
Quantity::Rational { v, u } => {wrap_rational!(-v, u)}, u: self.u
} }
} }
} }
@ -299,35 +154,19 @@ impl Add for Quantity {
type Output = Self; type Output = Self;
fn add(self, other: Self) -> Self::Output { fn add(self, other: Self) -> Self::Output {
match (&self, &other) { if self.u != other.u { panic!() }
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => {
if ua != ub { panic!() } Quantity {
wrap_float!(va.clone()+vb.clone(), ua.clone()) v: self.v + other.v,
}, u: self.u
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {self + Quantity::float_from_rat(&other)},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {Quantity::float_from_rat(&self) + other},
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
if ua != ub { panic!() }
wrap_rational!(va.clone()+vb.clone(), ua.clone())
},
} }
} }
} }
impl AddAssign for Quantity where { impl AddAssign for Quantity where {
fn add_assign(&mut self, other: Self) { fn add_assign(&mut self, other: Self) {
match (&mut *self, &other) { if self.u != other.u { panic!() }
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => { self.v += other.v
if ua != ub { panic!() }
*va += vb.clone()
},
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {*self += Quantity::float_from_rat(&other)},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {*self = Quantity::float_from_rat(self) + other },
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
if ua != ub { panic!() }
*va += vb.clone()
},
}
} }
} }
@ -335,35 +174,19 @@ impl Sub for Quantity {
type Output = Self; type Output = Self;
fn sub(self, other: Self) -> Self::Output { fn sub(self, other: Self) -> Self::Output {
match (&self, &other) { if self.u != other.u { panic!() }
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => {
if ua != ub { panic!() } Quantity {
wrap_float!(va.clone()-vb.clone(), ua.clone()) v: self.v - other.v,
}, u: self.u
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {self - Quantity::float_from_rat(&other)},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {Quantity::float_from_rat(&self) - other},
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
if ua != ub { panic!() }
wrap_rational!(va.clone()-vb.clone(), ua.clone())
},
} }
} }
} }
impl SubAssign for Quantity where { impl SubAssign for Quantity where {
fn sub_assign(&mut self, other: Self) { fn sub_assign(&mut self, other: Self) {
match (&mut *self, &other) { if self.u != other.u { panic!() }
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => { self.v -= other.v
if ua != ub { panic!() }
*va -= vb.clone()
},
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {*self -= Quantity::float_from_rat(&other)},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {*self = Quantity::float_from_rat(self) - other },
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
if ua != ub { panic!() }
*va -= vb.clone()
},
}
} }
} }
@ -371,35 +194,17 @@ impl Mul for Quantity {
type Output = Self; type Output = Self;
fn mul(self, other: Self) -> Self::Output { fn mul(self, other: Self) -> Self::Output {
match (&self, &other) { Quantity {
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => { v: self.v * other.v,
let u = ua.clone()*ub.clone(); u: self.u * other.u
wrap_float!(va.clone()*vb.clone(), u)
},
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {self * Quantity::float_from_rat(&other)},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {Quantity::float_from_rat(&self) * self},
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
let u = ua.clone()*ub.clone();
wrap_rational!(va.clone()*vb.clone(), u)
},
} }
} }
} }
impl MulAssign for Quantity where { impl MulAssign for Quantity where {
fn mul_assign(&mut self, other: Self) { fn mul_assign(&mut self, other: Self) {
match (&mut *self, &other) { self.v *= other.v;
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => { self.u *= other.u;
*ua *= ub.clone();
*va *= vb.clone()
},
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {*self *= Quantity::float_from_rat(&other)},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {*self = Quantity::float_from_rat(self) * other },
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
*ua *= ub.clone();
*va *= vb.clone()
},
}
} }
} }
@ -407,35 +212,17 @@ impl Div for Quantity {
type Output = Self; type Output = Self;
fn div(self, other: Self) -> Self::Output { fn div(self, other: Self) -> Self::Output {
match (&self, &other) { Quantity {
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => { v: self.v / other.v,
let u = ua.clone()/ub.clone(); u: self.u / other.u
wrap_float!(va.clone()/vb.clone(), u)
},
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {self / Quantity::float_from_rat(&other)},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {Quantity::float_from_rat(&self) / other},
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
let u = ua.clone()/ub.clone();
wrap_rational!(va.clone()/vb.clone(), u)
},
} }
} }
} }
impl DivAssign for Quantity where { impl DivAssign for Quantity where {
fn div_assign(&mut self, other: Self) { fn div_assign(&mut self, other: Self) {
match (&mut *self, &other) { self.v /= other.v;
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => { self.u /= other.u;
*ua /= ub.clone();
*va /= vb.clone()
},
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {*self /= Quantity::float_from_rat(&other)},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {*self = Quantity::float_from_rat(self) / other },
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
*ua /= ub.clone();
*va /= vb.clone()
}
}
} }
} }
@ -443,45 +230,27 @@ impl Rem<Quantity> for Quantity {
type Output = Self; type Output = Self;
fn rem(self, other: Quantity) -> Self::Output { fn rem(self, other: Quantity) -> Self::Output {
match (&self, &other) { if !self.u.unitless() { panic!() }
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => { if !other.u.unitless() { panic!() }
if ua != ub { panic!() }
wrap_float!(va.clone()%vb.clone(), ua.clone()) Quantity {
}, v: self.v % other.v,
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {self % Quantity::float_from_rat(&other)}, u: self.u
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {Quantity::float_from_rat(&self) % other},
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
if ua != ub { panic!() }
wrap_rational!(va.clone()%vb.clone(), ua.clone())
},
} }
} }
} }
impl PartialEq for Quantity { impl PartialEq for Quantity {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
match (self, other) { if self.u != other.u {false} else {
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => { if ua!=ub {false} else {va == vb} }, self.v == other.v
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {*self == Quantity::float_from_rat(other)},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {Quantity::float_from_rat(self) == *other},
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => { if ua!=ub {false} else {va == vb} },
} }
} }
} }
impl PartialOrd for Quantity { impl PartialOrd for Quantity {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> { fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
match (self, other) { if self.u != other.u { panic!() }
(Quantity::Float{v:va,u:ua}, Quantity::Float{v:vb,u:ub}) => { self.v.partial_cmp(&other.v)
if ua != ub { panic!() }
va.partial_cmp(vb)
},
(Quantity::Float{ .. }, Quantity::Rational{ .. }) => {(*self).partial_cmp(&Quantity::float_from_rat(other))},
(Quantity::Rational{ .. }, Quantity::Float{ .. }) => {Quantity::float_from_rat(self).partial_cmp(other)},
(Quantity::Rational{v:va,u:ua}, Quantity::Rational{v:vb,u:ub}) => {
if ua != ub { panic!() }
va.partial_cmp(vb)
},
}
} }
} }

93
src/quantity/f64q.rs → src/quantity/scalar/f64base.rs
View File

@ -7,33 +7,43 @@ use std::ops::{
}; };
use std::cmp::Ordering; use std::cmp::Ordering;
use super::ScalarBase;
use crate::quantity::wrap_float;
use crate::quantity::Quantity;
use crate::quantity::QuantBase;
use crate::quantity::FloatBase;
macro_rules! foward { macro_rules! foward {
( $x:ident ) => { ( $x:ident ) => {
fn $x(&self) -> Quantity { fn $x(&self) -> Option<F64Base> {
wrap_float!(F64Q{ val: self.val.clone().$x() }) Some(F64Base{ val: self.val.clone().$x() })
} }
} }
} }
#[derive(Debug)] #[derive(Debug)]
#[derive(Clone)] #[derive(Clone)]
pub struct F64Q where { pub struct F64Base where {
pub val: f64 pub val: f64
} }
impl ToString for F64Q { impl ToString for F64Base {
fn to_string(&self) -> String { self.val.to_string() } fn to_string(&self) -> String { self.val.to_string() }
} }
impl QuantBase for F64Q { impl ScalarBase for F64Base {
fn from_f64(f: f64) -> Option<F64Base> {
return Some(F64Base{ val: f });
}
fn from_string(s: &str) -> Option<F64Base> {
let v = s.parse::<f64>();
let v = match v {
Ok(x) => x,
Err(_) => return None
};
return Some(F64Base{ val: v });
}
foward!(fract); foward!(fract);
@ -65,40 +75,17 @@ impl QuantBase for F64Q {
foward!(log10); foward!(log10);
foward!(log2); foward!(log2);
fn log(&self, base: Quantity) -> Quantity { fn log(&self, base: Self) -> Option<Self> {
wrap_float!(F64Q{ val: self.val.clone().log10() }) / Some(F64Base{ val: self.val.clone().log10() } / base.log10().unwrap())
Quantity::float_from_rat(&base).log10()
} }
fn pow(&self, base: Quantity) -> Quantity { fn pow(&self, base: Self) -> Option<Self> {
match base { Some(F64Base{ val: self.val.clone().powf(base.val)})
Quantity::Rational { .. } => self.pow(Quantity::float_from_rat(&base)),
Quantity::Float { v } => wrap_float!(F64Q{ val: self.val.clone().powf(v.val) })
} }
} }
} impl Add for F64Base where {
impl FloatBase for F64Q {
fn from_f64(f: f64) -> Option<F64Q> {
return Some(F64Q{ val: f });
}
fn from_string(s: &str) -> Option<F64Q> {
let v = s.parse::<f64>();
let v = match v {
Ok(x) => x,
Err(_) => return None
};
return Some(F64Q{ val: v });
}
}
impl Add for F64Q where {
type Output = Self; type Output = Self;
fn add(self, other: Self) -> Self::Output { fn add(self, other: Self) -> Self::Output {
@ -106,13 +93,13 @@ impl Add for F64Q where {
} }
} }
impl AddAssign for F64Q where { impl AddAssign for F64Base where {
fn add_assign(&mut self, other: Self) { fn add_assign(&mut self, other: Self) {
self.val += other.val; self.val += other.val;
} }
} }
impl Sub for F64Q { impl Sub for F64Base {
type Output = Self; type Output = Self;
fn sub(self, other: Self) -> Self::Output { fn sub(self, other: Self) -> Self::Output {
@ -120,13 +107,13 @@ impl Sub for F64Q {
} }
} }
impl SubAssign for F64Q where { impl SubAssign for F64Base where {
fn sub_assign(&mut self, other: Self) { fn sub_assign(&mut self, other: Self) {
self.val -= other.val; self.val -= other.val;
} }
} }
impl Mul for F64Q { impl Mul for F64Base {
type Output = Self; type Output = Self;
fn mul(self, other: Self) -> Self::Output { fn mul(self, other: Self) -> Self::Output {
@ -134,13 +121,13 @@ impl Mul for F64Q {
} }
} }
impl MulAssign for F64Q where { impl MulAssign for F64Base where {
fn mul_assign(&mut self, other: Self) { fn mul_assign(&mut self, other: Self) {
self.val *= other.val; self.val *= other.val;
} }
} }
impl Div for F64Q { impl Div for F64Base {
type Output = Self; type Output = Self;
fn div(self, other: Self) -> Self::Output { fn div(self, other: Self) -> Self::Output {
@ -148,13 +135,13 @@ impl Div for F64Q {
} }
} }
impl DivAssign for F64Q where { impl DivAssign for F64Base where {
fn div_assign(&mut self, other: Self) { fn div_assign(&mut self, other: Self) {
self.val /= other.val; self.val /= other.val;
} }
} }
impl Neg for F64Q where { impl Neg for F64Base where {
type Output = Self; type Output = Self;
fn neg(self) -> Self::Output { fn neg(self) -> Self::Output {
@ -162,26 +149,26 @@ impl Neg for F64Q where {
} }
} }
impl Rem<F64Q> for F64Q { impl Rem<F64Base> for F64Base {
type Output = Self; type Output = Self;
fn rem(self, modulus: F64Q) -> Self::Output { fn rem(self, modulus: F64Base) -> Self::Output {
if { if {
(!self.fract().is_zero()) || (!self.fract().unwrap().is_zero()) ||
(!modulus.fract().is_zero()) (!modulus.fract().unwrap().is_zero())
} { panic!() } } { panic!() }
F64Q{val : self.val.fract() % modulus.val.fract()} F64Base{val : self.val.fract() % modulus.val.fract()}
} }
} }
impl PartialEq for F64Q { impl PartialEq for F64Base {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
self.val == other.val self.val == other.val
} }
} }
impl PartialOrd for F64Q { impl PartialOrd for F64Base {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> { fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
self.val.partial_cmp(&other.val) self.val.partial_cmp(&other.val)
} }

99
src/quantity/floatq.rs → src/quantity/scalar/floatbase.rs
View File

@ -13,37 +13,35 @@ use std::ops::{
use std::cmp::Ordering; use std::cmp::Ordering;
use crate::quantity::QuantBase; use super::ScalarBase;
use crate::quantity::FloatBase; use super::PRINT_LEN;
use crate::quantity::PRINT_LEN;
use super::FLOAT_PRECISION; use super::FLOAT_PRECISION;
macro_rules! foward { macro_rules! foward {
( $x:ident ) => { ( $x:ident ) => {
fn $x(&self) -> Option<FloatQ> { fn $x(&self) -> Option<FloatBase> {
Some(FloatQ{ val: self.val.clone().$x()}) Some(FloatBase{ val: self.val.clone().$x()})
} }
} }
} }
#[derive(Debug)] #[derive(Debug)]
#[derive(Clone)] #[derive(Clone)]
pub struct FloatQ where { pub struct FloatBase where {
pub val: Float pub val: Float
} }
impl FloatQ { impl FloatBase {
pub fn from<T>(a: T) -> Option<FloatQ> where pub fn from<T>(a: T) -> Option<FloatBase> where
Float: Assign<T> + AssignRound<T> Float: Assign<T> + AssignRound<T>
{ {
let v = Float::with_val(FLOAT_PRECISION, a); let v = Float::with_val(FLOAT_PRECISION, a);
return Some(FloatQ{ val: v }); return Some(FloatBase{ val: v });
} }
} }
impl ToString for FloatQ { impl ToString for FloatBase {
fn to_string(&self) -> String { fn to_string(&self) -> String {
let (sign, mut string, exp) = self.val.to_sign_string_exp(10, Some(PRINT_LEN)); let (sign, mut string, exp) = self.val.to_sign_string_exp(10, Some(PRINT_LEN));
@ -101,7 +99,26 @@ impl ToString for FloatQ {
} }
impl QuantBase for FloatQ { impl ScalarBase for FloatBase {
fn from_f64(f: f64) -> Option<FloatBase> {
let v = Float::with_val(FLOAT_PRECISION, f);
return Some(FloatBase{ val: v });
}
fn from_string(s: &str) -> Option<FloatBase> {
let v = Float::parse(s);
let v = match v {
Ok(x) => x,
Err(_) => return None
};
return Some(
FloatBase{ val:
Float::with_val(FLOAT_PRECISION, v)
}
);
}
foward!(fract); foward!(fract);
@ -133,40 +150,18 @@ impl QuantBase for FloatQ {
foward!(log10); foward!(log10);
foward!(log2); foward!(log2);
fn log(&self, base: FloatQ) -> Option<FloatQ> { fn log(&self, base: FloatBase) -> Option<FloatBase> {
Some(FloatQ{ val: self.val.clone().log10() } / base.log10().unwrap()) Some(FloatBase{ val: self.val.clone().log10() } / base.log10().unwrap())
} }
fn pow(&self, base: FloatQ) -> Option<FloatQ> { fn pow(&self, base: FloatBase) -> Option<FloatBase> {
Some(FloatQ{ val: self.val.clone().pow(base.val)}) Some(FloatBase{ val: self.val.clone().pow(base.val)})
} }
} }
impl FloatBase for FloatQ {
fn from_f64(f: f64) -> Option<FloatQ> {
let v = Float::with_val(FLOAT_PRECISION, f);
return Some(FloatQ{ val: v });
}
fn from_string(s: &str) -> Option<FloatQ> { impl Add for FloatBase where {
let v = Float::parse(s);
let v = match v {
Ok(x) => x,
Err(_) => return None
};
return Some(
FloatQ{ val:
Float::with_val(FLOAT_PRECISION, v)
}
);
}
}
impl Add for FloatQ where {
type Output = Self; type Output = Self;
fn add(self, other: Self) -> Self::Output { fn add(self, other: Self) -> Self::Output {
@ -174,13 +169,13 @@ impl Add for FloatQ where {
} }
} }
impl AddAssign for FloatQ where { impl AddAssign for FloatBase where {
fn add_assign(&mut self, other: Self) { fn add_assign(&mut self, other: Self) {
self.val += other.val; self.val += other.val;
} }
} }
impl Sub for FloatQ { impl Sub for FloatBase {
type Output = Self; type Output = Self;
fn sub(self, other: Self) -> Self::Output { fn sub(self, other: Self) -> Self::Output {
@ -188,13 +183,13 @@ impl Sub for FloatQ {
} }
} }
impl SubAssign for FloatQ where { impl SubAssign for FloatBase where {
fn sub_assign(&mut self, other: Self) { fn sub_assign(&mut self, other: Self) {
self.val -= other.val; self.val -= other.val;
} }
} }
impl Mul for FloatQ { impl Mul for FloatBase {
type Output = Self; type Output = Self;
fn mul(self, other: Self) -> Self::Output { fn mul(self, other: Self) -> Self::Output {
@ -202,13 +197,13 @@ impl Mul for FloatQ {
} }
} }
impl MulAssign for FloatQ where { impl MulAssign for FloatBase where {
fn mul_assign(&mut self, other: Self) { fn mul_assign(&mut self, other: Self) {
self.val *= other.val; self.val *= other.val;
} }
} }
impl Div for FloatQ { impl Div for FloatBase {
type Output = Self; type Output = Self;
fn div(self, other: Self) -> Self::Output { fn div(self, other: Self) -> Self::Output {
@ -216,13 +211,13 @@ impl Div for FloatQ {
} }
} }
impl DivAssign for FloatQ where { impl DivAssign for FloatBase where {
fn div_assign(&mut self, other: Self) { fn div_assign(&mut self, other: Self) {
self.val /= other.val; self.val /= other.val;
} }
} }
impl Neg for FloatQ where { impl Neg for FloatBase where {
type Output = Self; type Output = Self;
fn neg(self) -> Self::Output { fn neg(self) -> Self::Output {
@ -230,26 +225,26 @@ impl Neg for FloatQ where {
} }
} }
impl Rem<FloatQ> for FloatQ { impl Rem<FloatBase> for FloatBase {
type Output = Self; type Output = Self;
fn rem(self, modulus: FloatQ) -> Self::Output { fn rem(self, modulus: FloatBase) -> Self::Output {
if { if {
(!self.fract().unwrap().is_zero()) || (!self.fract().unwrap().is_zero()) ||
(!modulus.fract().unwrap().is_zero()) (!modulus.fract().unwrap().is_zero())
} { panic!() } } { panic!() }
FloatQ{val : self.val.fract() % modulus.val.fract()} FloatBase{val : self.val.fract() % modulus.val.fract()}
} }
} }
impl PartialEq for FloatQ { impl PartialEq for FloatBase {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
self.val == other.val self.val == other.val
} }
} }
impl PartialOrd for FloatQ { impl PartialOrd for FloatBase {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> { fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
self.val.partial_cmp(&other.val) self.val.partial_cmp(&other.val)
} }

382
src/quantity/scalar/mod.rs Normal file
View File

@ -0,0 +1,382 @@
use std::ops::{
Add, Sub, Mul, Div,
Neg, Rem,
AddAssign, SubAssign,
MulAssign, DivAssign
};
use std::cmp::Ordering;
pub trait ScalarBase:
Sized + ToString +
Add + AddAssign +
Sub + SubAssign +
Mul + MulAssign +
Div + DivAssign +
Neg + Rem +
PartialEq + PartialOrd
{
// Creation
fn from_f64(f: f64) -> Option<Self>;
fn from_string(s: &str) -> Option<Self>;
// Utility
fn fract(&self) -> Option<Self>;
fn is_zero(&self) -> bool;
fn is_negative(&self) -> bool;
fn is_positive(&self) -> bool;
// Mathematical
fn exp(&self) -> Option<Self>;
fn abs(&self) -> Option<Self>;
fn floor(&self) -> Option<Self>;
fn ceil(&self) -> Option<Self>;
fn round(&self) -> Option<Self>;
fn sin(&self) -> Option<Self>;
fn cos(&self) -> Option<Self>;
fn tan(&self) -> Option<Self>;
fn asin(&self) -> Option<Self>;
fn acos(&self) -> Option<Self>;
fn atan(&self) -> Option<Self>;
fn sinh(&self) -> Option<Self>;
fn cosh(&self) -> Option<Self>;
fn tanh(&self) -> Option<Self>;
fn asinh(&self) -> Option<Self>;
fn acosh(&self) -> Option<Self>;
fn atanh(&self) -> Option<Self>;
fn ln(&self) -> Option<Self>;
fn log10(&self) -> Option<Self>;
fn log2(&self) -> Option<Self>;
fn log(&self, base: Self) -> Option<Self>;
fn pow(&self, exp: Self) -> Option<Self>;
}
const FLOAT_PRECISION: u32 = 1024;
const PRINT_LEN: usize = 5; // How many significant digits we will show in output
mod rationalbase;
mod floatbase;
//mod f64base;
use self::rationalbase::RationalBase;
use self::floatbase::FloatBase as FloatBase;
#[derive(Debug)]
#[derive(Clone)]
pub enum Scalar {
Rational{ v: RationalBase },
Float{ v: FloatBase }
}
macro_rules! wrap_rational {
( $x:expr) => { Scalar::Rational{v: $x} }
}
macro_rules! wrap_float {
( $x:expr) => { Scalar::Float{v: $x} }
}
fn to_float(r: Scalar) -> Scalar {
match &r {
Scalar::Float {..} => r,
Scalar::Rational {v} => wrap_float!(
FloatBase::from(v.val.numer()).unwrap() /
FloatBase::from(v.val.denom()).unwrap()
)
}
}
impl ToString for Scalar {
fn to_string(&self) -> String {
match self {
Scalar::Rational{..} => to_float(self.clone()).to_string(),
Scalar::Float{v} => v.to_string()
}
}
}
// Creation methods
impl Scalar {
pub fn new_float(f: f64) -> Option<Self> {
let v = FloatBase::from_f64(f);
if v.is_none() { return None; }
return Some(wrap_float!(v.unwrap()));
}
pub fn new_rational(f: f64) -> Option<Self> {
let r = RationalBase::from_f64(f);
if r.is_none() { return None; }
return Some(wrap_rational!(r.unwrap()));
}
pub fn new_rational_from_string(s: &str) -> Option<Self> {
let r = RationalBase::from_string(s);
if r.is_none() { return None; }
return Some(wrap_rational!(r.unwrap()));
}
pub fn new_float_from_string(s: &str) -> Option<Self> {
let v = FloatBase::from_string(s);
if v.is_none() { return None; }
return Some(wrap_float!(v.unwrap()))
}
}
impl Scalar {
pub fn is_nan(&self) -> bool {
match self {
Scalar::Float {v} => {v.val.is_nan()},
Scalar::Rational {..} => {panic!()}
}
}
}
// Forwarded functions
macro_rules! scalar_foward {
( $x:ident ) => {
pub fn $x(&self) -> Scalar {
match self {
Scalar::Rational{v} => {
let r = v.$x();
if r.is_none() {
let v = to_float(self.clone());
return v.$x();
} else {wrap_rational!(r.unwrap())}
},
Scalar::Float{v} => {wrap_float!(v.$x().unwrap())},
}
}
}
}
impl Scalar {
pub fn is_zero(&self) -> bool {
match self {
Scalar::Rational{v} => v.is_zero(),
Scalar::Float{v} => v.is_zero(),
}
}
pub fn is_negative(&self) -> bool {
match self {
Scalar::Rational{v} => v.is_negative(),
Scalar::Float{v} => v.is_negative(),
}
}
pub fn is_positive(&self) -> bool {
match self {
Scalar::Rational{v} => v.is_positive(),
Scalar::Float{v} => v.is_positive(),
}
}
scalar_foward!(fract);
scalar_foward!(abs);
scalar_foward!(floor);
scalar_foward!(ceil);
scalar_foward!(round);
scalar_foward!(sin);
scalar_foward!(cos);
scalar_foward!(tan);
scalar_foward!(asin);
scalar_foward!(acos);
scalar_foward!(atan);
scalar_foward!(sinh);
scalar_foward!(cosh);
scalar_foward!(tanh);
scalar_foward!(asinh);
scalar_foward!(acosh);
scalar_foward!(atanh);
scalar_foward!(exp);
scalar_foward!(ln);
scalar_foward!(log10);
scalar_foward!(log2);
pub fn log(&self, base: Scalar) -> Scalar {
match self {
Scalar::Rational{..} => { to_float(self.clone()).log(to_float(base)) },
Scalar::Float{..} => { to_float(self.clone()).log(to_float(base)) },
}
}
pub fn pow(&self, base: Scalar) -> Scalar {
match self {
Scalar::Rational{..} => {
let a = match to_float(self.clone()) {
Scalar::Rational{..} => panic!(),
Scalar::Float{v} => v,
};
let b = match to_float(base) {
Scalar::Rational{..} => panic!(),
Scalar::Float{v} => v,
};
wrap_float!(a.pow(b).unwrap())
},
Scalar::Float{..} => {
let a = match to_float(self.clone()) {
Scalar::Rational{..} => panic!(),
Scalar::Float{v} => v,
};
let b = match to_float(base) {
Scalar::Rational{..} => panic!(),
Scalar::Float{v} => v,
};
wrap_float!(a.pow(b).unwrap())
},
}
}
}
impl Neg for Scalar where {
type Output = Self;
fn neg(self) -> Self::Output {
match self {
Scalar::Float { v } => {wrap_float!(-v)},
Scalar::Rational { v } => {wrap_rational!(-v)},
}
}
}
impl Add for Scalar {
type Output = Self;
fn add(self, other: Self) -> Self::Output {
match (&self, &other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {wrap_float!(va.clone()+vb.clone())},
(Scalar::Float{..}, Scalar::Rational{..}) => {self + to_float(other)},
(Scalar::Rational{..}, Scalar::Float{..}) => {to_float(self) + other},
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {wrap_rational!(va.clone()+vb.clone())},
}
}
}
impl AddAssign for Scalar where {
fn add_assign(&mut self, other: Self) {
match (&mut *self, &other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {*va += vb.clone()},
(Scalar::Float{..}, Scalar::Rational{..}) => {*self += to_float(other)},
(Scalar::Rational{..}, Scalar::Float{..}) => {*self = to_float(self.clone()) + other },
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {*va += vb.clone()},
}
}
}
impl Sub for Scalar {
type Output = Self;
fn sub(self, other: Self) -> Self::Output {
match (&self, &other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {wrap_float!(va.clone()-vb.clone())},
(Scalar::Float{..}, Scalar::Rational{..}) => {self - to_float(other)},
(Scalar::Rational{..}, Scalar::Float{..}) => {to_float(self) - other},
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {wrap_rational!(va.clone()-vb.clone())},
}
}
}
impl SubAssign for Scalar where {
fn sub_assign(&mut self, other: Self) {
match (&mut *self, &other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {*va -= vb.clone()},
(Scalar::Float{..}, Scalar::Rational{..}) => {*self -= to_float(other)},
(Scalar::Rational{..}, Scalar::Float{..}) => {*self = to_float(self.clone()) - other },
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {*va -= vb.clone()},
}
}
}
impl Mul for Scalar {
type Output = Self;
fn mul(self, other: Self) -> Self::Output {
match (&self, &other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {wrap_float!(va.clone()*vb.clone())},
(Scalar::Float{..}, Scalar::Rational{..}) => {self * to_float(other)},
(Scalar::Rational{..}, Scalar::Float{..}) => {to_float(self) * other},
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {wrap_rational!(va.clone()*vb.clone())},
}
}
}
impl MulAssign for Scalar where {
fn mul_assign(&mut self, other: Self) {
match (&mut *self, &other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {*va *= vb.clone()},
(Scalar::Float{..}, Scalar::Rational{..}) => {*self *= to_float(other)},
(Scalar::Rational{..}, Scalar::Float{..}) => {*self = to_float(self.clone()) * other },
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {*va *= vb.clone()},
}
}
}
impl Div for Scalar {
type Output = Self;
fn div(self, other: Self) -> Self::Output {
match (&self, &other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {wrap_float!(va.clone()/vb.clone())},
(Scalar::Float{..}, Scalar::Rational{..}) => {self / to_float(other)},
(Scalar::Rational{..}, Scalar::Float{..}) => {to_float(self) / other},
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {wrap_rational!(va.clone()/vb.clone())},
}
}
}
impl DivAssign for Scalar where {
fn div_assign(&mut self, other: Self) {
match (&mut *self, &other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {*va /= vb.clone()},
(Scalar::Float{..}, Scalar::Rational{..}) => {*self /= to_float(other)},
(Scalar::Rational{..}, Scalar::Float{..}) => {*self = to_float(self.clone()) / other },
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {*va /= vb.clone()},
}
}
}
impl Rem<Scalar> for Scalar {
type Output = Self;
fn rem(self, other: Scalar) -> Self::Output {
match (&self, &other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {wrap_float!(va.clone()%vb.clone())},
(Scalar::Float{..}, Scalar::Rational{..}) => {self % to_float(other)},
(Scalar::Rational{..}, Scalar::Float{..}) => {to_float(self) % other},
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {wrap_rational!(va.clone()%vb.clone())},
}
}
}
impl PartialEq for Scalar {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => { va == vb },
(Scalar::Float{..}, Scalar::Rational{..}) => {*self == to_float(other.clone())},
(Scalar::Rational{..}, Scalar::Float{..}) => {to_float(self.clone()) == *other},
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => { va == vb },
}
}
}
impl PartialOrd for Scalar {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
match (self, other) {
(Scalar::Float{v:va}, Scalar::Float{v:vb}) => {va.partial_cmp(vb)},
(Scalar::Float{..}, Scalar::Rational{..}) => {(*self).partial_cmp(&to_float(other.clone()))},
(Scalar::Rational{..}, Scalar::Float{..}) => {to_float(self.clone()).partial_cmp(other)},
(Scalar::Rational{v:va}, Scalar::Rational{v:vb}) => {va.partial_cmp(vb)},
}
}
}

128
src/quantity/rationalq.rs → src/quantity/scalar/rationalbase.rs
View File

@ -10,20 +10,18 @@ use std::ops::{
}; };
use std::cmp::Ordering; use std::cmp::Ordering;
use super::ScalarBase;
use crate::quantity::QuantBase;
use crate::quantity::RationalBase;
macro_rules! cant_do { macro_rules! cant_do {
( $x:ident ) => { ( $x:ident ) => {
fn $x(&self) -> Option<RationalQ> { None } fn $x(&self) -> Option<RationalBase> { None }
} }
} }
#[derive(Debug)] #[derive(Debug)]
#[derive(Clone)] #[derive(Clone)]
pub struct RationalQ where { pub struct RationalBase where {
pub val: Rational pub val: Rational
} }
@ -37,65 +35,22 @@ fn to_sign_string_exp(&self, radix: i32, num_digits: Option<usize>) -> (bool, St
} }
*/ */
impl ToString for RationalQ{ impl ToString for RationalBase{
fn to_string(&self) -> String { fn to_string(&self) -> String {
return self.val.to_string(); return self.val.to_string();
} }
} }
impl QuantBase for RationalQ { impl ScalarBase for RationalBase {
fn fract(&self) -> Option<RationalQ> {
Some(RationalQ{val: self.val.clone().fract_floor(Integer::new()).0})
}
fn is_zero(&self) -> bool {self.val == Rational::from((0,1))} fn from_f64(f: f64) -> Option<RationalBase> {
fn is_negative(&self) -> bool { self.val.clone().signum() == -1 }
fn is_positive(&self) -> bool { self.val.clone().signum() == 1 }
fn abs(&self) -> Option<RationalQ> {Some(RationalQ{val: self.val.clone().abs()})}
fn floor(&self) -> Option<RationalQ> {Some(RationalQ{val: self.val.clone().floor()})}
fn ceil(&self) -> Option<RationalQ> {Some(RationalQ{val: self.val.clone().ceil()})}
fn round(&self) -> Option<RationalQ> {Some(RationalQ{val: self.val.clone().round()})}
cant_do!(sin);
cant_do!(cos);
cant_do!(tan);
cant_do!(asin);
cant_do!(acos);
cant_do!(atan);
cant_do!(sinh);
cant_do!(cosh);
cant_do!(tanh);
cant_do!(asinh);
cant_do!(acosh);
cant_do!(atanh);
cant_do!(exp);
cant_do!(ln);
cant_do!(log10);
cant_do!(log2);
fn log(&self, _base: RationalQ) -> Option<RationalQ> { None }
fn pow(&self, _base: RationalQ) -> Option<RationalQ> { None }
}
impl RationalBase for RationalQ {
fn from_frac(top: i64, bot: i64) -> RationalQ {
return RationalQ {
val: Rational::from((top, bot))
}
}
fn from_f64(f: f64) -> Option<RationalQ> {
let v = Rational::from_f64(f); let v = Rational::from_f64(f);
if v.is_none() { return None } if v.is_none() { return None }
return Some(RationalQ{ val: v.unwrap() }); return Some(RationalBase{ val: v.unwrap() });
} }
fn from_string(s: &str) -> Option<RationalQ> { fn from_string(s: &str) -> Option<RationalBase> {
// Scientific notation // Scientific notation
let mut sci = s.split("e"); let mut sci = s.split("e");
let num = sci.next().unwrap(); let num = sci.next().unwrap();
@ -145,15 +100,50 @@ impl RationalBase for RationalQ {
Err(_) => return None Err(_) => return None
}; };
return Some(RationalQ{val: r}); return Some(RationalBase{val: r});
} }
fn fract(&self) -> Option<RationalBase> {
Some(RationalBase{val: self.val.clone().fract_floor(Integer::new()).0})
}
fn is_zero(&self) -> bool {self.val == Rational::from((0,1))}
fn is_negative(&self) -> bool { self.val.clone().signum() == -1 }
fn is_positive(&self) -> bool { self.val.clone().signum() == 1 }
fn abs(&self) -> Option<RationalBase> {Some(RationalBase{val: self.val.clone().abs()})}
fn floor(&self) -> Option<RationalBase> {Some(RationalBase{val: self.val.clone().floor()})}
fn ceil(&self) -> Option<RationalBase> {Some(RationalBase{val: self.val.clone().ceil()})}
fn round(&self) -> Option<RationalBase> {Some(RationalBase{val: self.val.clone().round()})}
cant_do!(sin);
cant_do!(cos);
cant_do!(tan);
cant_do!(asin);
cant_do!(acos);
cant_do!(atan);
cant_do!(sinh);
cant_do!(cosh);
cant_do!(tanh);
cant_do!(asinh);
cant_do!(acosh);
cant_do!(atanh);
cant_do!(exp);
cant_do!(ln);
cant_do!(log10);
cant_do!(log2);
fn log(&self, _base: RationalBase) -> Option<RationalBase> { None }
fn pow(&self, _base: RationalBase) -> Option<RationalBase> { None }
} }
impl Add for RationalBase where {
impl Add for RationalQ where {
type Output = Self; type Output = Self;
fn add(self, other: Self) -> Self::Output { fn add(self, other: Self) -> Self::Output {
@ -163,13 +153,13 @@ impl Add for RationalQ where {
} }
} }
impl AddAssign for RationalQ where { impl AddAssign for RationalBase where {
fn add_assign(&mut self, other: Self) { fn add_assign(&mut self, other: Self) {
self.val += other.val; self.val += other.val;
} }
} }
impl Sub for RationalQ { impl Sub for RationalBase {
type Output = Self; type Output = Self;
fn sub(self, other: Self) -> Self::Output { fn sub(self, other: Self) -> Self::Output {
@ -179,13 +169,13 @@ impl Sub for RationalQ {
} }
} }
impl SubAssign for RationalQ where { impl SubAssign for RationalBase where {
fn sub_assign(&mut self, other: Self) { fn sub_assign(&mut self, other: Self) {
self.val -= other.val; self.val -= other.val;
} }
} }
impl Mul for RationalQ { impl Mul for RationalBase {
type Output = Self; type Output = Self;
fn mul(self, other: Self) -> Self::Output { fn mul(self, other: Self) -> Self::Output {
@ -195,13 +185,13 @@ impl Mul for RationalQ {
} }
} }
impl MulAssign for RationalQ where { impl MulAssign for RationalBase where {
fn mul_assign(&mut self, other: Self) { fn mul_assign(&mut self, other: Self) {
self.val *= other.val; self.val *= other.val;
} }
} }
impl Div for RationalQ { impl Div for RationalBase {
type Output = Self; type Output = Self;
fn div(self, other: Self) -> Self::Output { fn div(self, other: Self) -> Self::Output {
@ -211,13 +201,13 @@ impl Div for RationalQ {
} }
} }
impl DivAssign for RationalQ where { impl DivAssign for RationalBase where {
fn div_assign(&mut self, other: Self) { fn div_assign(&mut self, other: Self) {
self.val /= other.val; self.val /= other.val;
} }
} }
impl Neg for RationalQ where { impl Neg for RationalBase where {
type Output = Self; type Output = Self;
fn neg(self) -> Self::Output { fn neg(self) -> Self::Output {
@ -227,16 +217,16 @@ impl Neg for RationalQ where {
} }
} }
impl Rem<RationalQ> for RationalQ { impl Rem<RationalBase> for RationalBase {
type Output = Self; type Output = Self;
fn rem(self, modulus: RationalQ) -> Self::Output { fn rem(self, modulus: RationalBase) -> Self::Output {
if { if {
*self.val.denom() != 1 || *self.val.denom() != 1 ||
*modulus.val.denom() != 1 *modulus.val.denom() != 1
} { panic!() } } { panic!() }
RationalQ{ RationalBase{
val : Rational::from(( val : Rational::from((
self.val.numer() % modulus.val.numer(), self.val.numer() % modulus.val.numer(),
1 1
@ -245,13 +235,13 @@ impl Rem<RationalQ> for RationalQ {
} }
} }
impl PartialEq for RationalQ { impl PartialEq for RationalBase {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
self.val == other.val self.val == other.val
} }
} }
impl PartialOrd for RationalQ { impl PartialOrd for RationalBase {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> { fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
self.val.partial_cmp(&other.val) self.val.partial_cmp(&other.val)
} }

22
src/tokens/operator.rs
View File

@ -284,7 +284,7 @@ impl Operator {
Token::Operator( Token::Operator(
Operator::Power, Operator::Power,
VecDeque::from(vec!(a, Token::Number(Quantity::new_rational(1,2)))) VecDeque::from(vec!(a, Token::Number(Quantity::new_rational(0.5).unwrap())))
) )
}, },
@ -328,12 +328,12 @@ impl Operator{
if let Token::Number(v) = args { if let Token::Number(v) = args {
if v.is_zero() { return Err(()); } if v.is_zero() { return Err(()); }
return Ok(Token::Number(Quantity::new_rational(1,1)/v)); return Ok(Token::Number(Quantity::new_rational(1f64).unwrap()/v));
} else { panic!(); } } else { panic!(); }
}, },
Operator::Add => { Operator::Add => {
let mut sum = Quantity::new_rational(0,1); let mut sum = Quantity::new_rational(0f64).unwrap();
for i in args.iter() { for i in args.iter() {
let j = i.as_number(); let j = i.as_number();
if let Token::Number(v) = j { if let Token::Number(v) = j {
@ -346,7 +346,7 @@ impl Operator{
}, },
Operator::Multiply => { Operator::Multiply => {
let mut prod = Quantity::new_rational(1,1); let mut prod = Quantity::new_rational(1f64).unwrap();
for i in args.iter() { for i in args.iter() {
let j = i.as_number(); let j = i.as_number();
if let Token::Number(v) = j { if let Token::Number(v) = j {
@ -366,9 +366,9 @@ impl Operator{
if let Token::Number(va) = a { if let Token::Number(va) = a {
if let Token::Number(vb) = b { if let Token::Number(vb) = b {
if vb <= Quantity::new_rational(1,1) { return Err(()); } if vb <= Quantity::new_rational(1f64).unwrap() { return Err(()); }
if va.fract() != Quantity::new_rational(0,1) { return Err(()); } if va.fract() != Quantity::new_rational(0f64).unwrap() { return Err(()); }
if vb.fract() != Quantity::new_rational(0,1) { return Err(()); } if vb.fract() != Quantity::new_rational(0f64).unwrap() { return Err(()); }
return Ok(Token::Number(va%vb)); return Ok(Token::Number(va%vb));
} else { panic!(); } } else { panic!(); }
@ -395,13 +395,13 @@ impl Operator{
if let Token::Number(v) = args { if let Token::Number(v) = args {
if !v.fract().is_zero() { return Err(()); } if !v.fract().is_zero() { return Err(()); }
if v > Quantity::new_rational(50_000, 1) { return Err(()); } if v > Quantity::new_rational(50_000f64).unwrap() { return Err(()); }
let mut prod = Quantity::new_rational(1, 1); let mut prod = Quantity::new_rational(1f64).unwrap();
let mut u = v.clone(); let mut u = v.clone();
while u > Quantity::new_rational(0, 1) { while u > Quantity::new_rational(0f64).unwrap() {
prod *= u.clone(); prod *= u.clone();
u = u - Quantity::new_rational(1, 1); u = u - Quantity::new_rational(1f64).unwrap();
} }
return Ok(Token::Number(prod)); return Ok(Token::Number(prod));