mexprp 0.3.1

A math expression parsing and evaluation library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use std::cmp::Ordering;


use rug::Complex;
use rug::ops::Pow;
use crate::opers::Calculation;
use crate::errors::MathError;
use crate::answer::Answer;
use crate::num::Num;
use crate::context::Context;

impl Num for Complex {
	fn from_f64(t: f64, ctx: &Context<Self>) -> Calculation<Self> {
		Ok(Answer::Single(Complex::with_val(ctx.cfg.precision, t)))
	}

	fn from_f64_complex(val: (f64, f64), ctx: &Context<Self>) -> Calculation<Self> {
		Ok(Answer::Single(Complex::with_val(ctx.cfg.precision, val)))
	}

	fn typename() -> String {
		String::from("Complex")
	}

	fn tryord(&self, other: &Self, _ctx: &Context<Self>) -> Result<Ordering, MathError> {
		if let Some(ord) = self.real().partial_cmp(other.real()) {
			Ok(ord)
		} else {
			Err(MathError::CmpError)
		}
	}

	fn add(&self, other: &Self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, self + other);

		Ok(Answer::Single(r))
	}

	fn sub(&self, other: &Self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, self - other);

		Ok(Answer::Single(r))
	}

	fn mul(&self, other: &Self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, self * other);

		Ok(Answer::Single(r))
	}

	fn div(&self, other: &Self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, self / other);

		Ok(Answer::Single(r))
	}

	fn pow(&self, other: &Self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, Pow::pow(self, other));

		Ok(Answer::Single(r))
	}

	fn sqrt(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, Complex::sqrt_ref(self));

		Ok(if ctx.cfg.sqrt_both {
			Answer::Multiple(vec![r.clone(), -r])
		} else {
			Answer::Single(r)
		})
	}

	fn abs(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, Complex::abs_ref(self));

		Ok(Answer::Single(r))
	}

	fn sin(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, Complex::sin_ref(self));

		Ok(Answer::Single(r))
	}

	fn cos(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, Complex::cos_ref(self));

		Ok(Answer::Single(r))
	}

	fn tan(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, Complex::tan_ref(self));

		Ok(Answer::Single(r))
	}

	fn asin(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, Complex::asin_ref(self));

		Ok(Answer::Single(r))
	}

	fn acos(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, Complex::acos_ref(self));

		Ok(Answer::Single(r))
	}

	fn atan(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::with_val(ctx.cfg.precision, Complex::atan_ref(self));

		Ok(Answer::Single(r))
	}

	fn floor(&self, ctx: &Context<Self>) -> Calculation<Self> {
		// Floor definition for complex numbers as defined by WolframAlpha https://mathworld.wolfram.com/FloorFunction.html
		let r = Complex::real(self).floor_ref();
		let i = Complex::imag(self).floor_ref();
		let a = Complex::with_val(ctx.cfg.precision, (r, i));

		Ok(Answer::Single(a))
	}
	
	fn ceil(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::real(self).ceil_ref();
		let i = Complex::imag(self).ceil_ref();
		let a = Complex::with_val(ctx.cfg.precision, (r, i));
		
		Ok(Answer::Single(a))
	}
	
	fn round(&self, ctx: &Context<Self>) -> Calculation<Self> {
		let r = Complex::real(self).round_ref();
		let i = Complex::imag(self).round_ref();
		let a = Complex::with_val(ctx.cfg.precision, (r, i));
		
		Ok(Answer::Single(a))
	}

	fn log(&self, other: &Self, ctx: &Context<Self>) -> Calculation<Self> {
		let n = Complex::with_val(ctx.cfg.precision, Complex::log10_ref(self));
		let d = Complex::with_val(ctx.cfg.precision, Complex::log10_ref(other));
		let r = Complex::with_val(ctx.cfg.precision, n / d);

		Ok(Answer::Single(r))
	}
}