?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Actually call on_reset callback
[lsnes.git] / src / library / mathexpr-ntype.cpp
blob166a90e9efd8656317515f64e59a919834acd301
1 #include "mathexpr-ntype.hpp"
2 #include "mathexpr-error.hpp"
3 #include "mathexpr-format.hpp"
4 #include "string.hpp"
5 #include <functional>
6 #include <iostream>
7 #include <map>
8
9 namespace mathexpr
10 {
11 namespace
12 {
13 void throw_domain(const std::string& err)
14 {
15 throw error(error::WDOMAIN, err);
16 }
17
18 template<typename T> int _cmp_values(T a, T b)
19 {
20 if(a < b)
21 return -1;
22 if(a > b)
23 return 1;
24 return 0;
25 }
26
27 class expr_val;
28
29 class expr_val_numeric
30 {
31 enum _type
32 {
33 T_UNSIGNED,
34 T_SIGNED,
35 T_FLOAT,
36 T_COMPLEX,
37 };
38 public:
39 struct unsigned_tag {};
40 struct signed_tag {};
41 struct float_tag {};
42 struct complex_tag {};
43 expr_val_numeric()
44 {
45 type = T_SIGNED;
46 v_signed = 0;
47 v_imag = 0;
48 }
49 expr_val_numeric(unsigned_tag, uint64_t v)
50 {
51 type = T_UNSIGNED;
52 v_unsigned = v;
53 v_imag = 0;
54 }
55 expr_val_numeric(signed_tag, int64_t v)
56 {
57 type = T_SIGNED;
58 v_signed = v;
59 v_imag = 0;
60 }
61 expr_val_numeric(float_tag, double v)
62 {
63 type = T_FLOAT;
64 v_float = v;
65 v_imag = 0;
66 }
67 expr_val_numeric(complex_tag, double re, double im)
68 {
69 type = T_COMPLEX;
70 v_float = re;
71 v_imag = im;
72 }
73 expr_val_numeric(const std::string& str)
74 {
75 if(str == "i") {
76 type = T_COMPLEX;
77 v_float = 0;
78 v_imag = 1;
79 } else if(regex("[0-9]+|0x[0-9a-fA-F]+", str)) {
80 //UNSIGNED.
81 v_unsigned = parse_value<uint64_t>(str);
82 v_imag = 0;
83 type = T_UNSIGNED;
84 } else if(regex("[+-][0-9]+|[+-]0x[0-9a-fA-F]+", str)) {
85 //SIGNED.
86 v_signed = parse_value<int64_t>(str);
87 v_imag = 0;
88 type = T_SIGNED;
89 } else if(regex("[+-]?([0-9]+|[0-9]*\\.[0-9]+)([eE][0-9]+)?", str)) {
90 //FLOAT.
91 v_float = parse_value<double>(str);
92 v_imag = 0;
93 type = T_FLOAT;
94 } else
95 throw std::runtime_error("Bad number '" + str + "'");
96 }
97 double as_float() const
98 {
99 switch(type) {
100 case T_UNSIGNED: return v_unsigned;
101 case T_SIGNED: return v_signed;
102 case T_FLOAT: return v_float;
103 case T_COMPLEX: return v_float;
104 }
105 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
106 }
107 int64_t as_signed() const
108 {
109 switch(type) {
110 case T_UNSIGNED: return v_unsigned;
111 case T_SIGNED: return v_signed;
112 case T_FLOAT: return v_float;
113 case T_COMPLEX: return v_float;
114 }
115 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
116 }
117 uint64_t as_unsigned() const
118 {
119 switch(type) {
120 case T_UNSIGNED: return v_unsigned;
121 case T_SIGNED: return v_signed;
122 case T_FLOAT: return v_float;
123 case T_COMPLEX: return v_float;
124 }
125 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
126 }
127 std::string tostring()
128 {
129 switch(type) {
130 case T_UNSIGNED:
131 return (stringfmt() << v_unsigned).str();
132 case T_SIGNED:
133 return (stringfmt() << v_signed).str();
134 case T_FLOAT:
135 //FIXME: Saner formatting.
136 return (stringfmt() << v_float).str();
137 case T_COMPLEX:
138 //FIXME: Saner formatting.
139 if(v_imag < 0)
140 return (stringfmt() << v_float << v_imag << "*i").str();
141 if(v_imag > 0)
142 return (stringfmt() << v_float << "+" << v_imag << "*i").str();
143 return (stringfmt() << v_float).str();
144 }
145 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
146 }
147 uint64_t tounsigned()
148 {
149 return as_unsigned();
150 }
151 int64_t tosigned()
152 {
153 return as_signed();
154 }
155 void scale(uint64_t scale)
156 {
157 switch(type) {
158 case T_UNSIGNED:
159 type = T_FLOAT;
160 v_float = (1.0 * v_unsigned / scale);
161 break;
162 case T_SIGNED:
163 type = T_FLOAT;
164 v_float = (1.0 * v_signed / scale);
165 break;
166 case T_COMPLEX:
167 v_imag /= scale;
168 case T_FLOAT:
169 v_float /= scale;
170 break;
171 }
172 }
173 bool toboolean()
174 {
175 switch(type) {
176 case T_UNSIGNED: return (v_unsigned != 0);
177 case T_SIGNED: return (v_signed != 0);
178 case T_FLOAT: return (v_float != 0);
179 case T_COMPLEX: return (v_float != 0) || (v_imag != 0);
180 }
181 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
182 }
183 std::string format(_format fmt)
184 {
185 switch(type) {
186 case T_UNSIGNED: return format_unsigned(v_unsigned, fmt);
187 case T_SIGNED: return format_signed(v_signed, fmt);
188 case T_FLOAT: return format_float(v_float, fmt);
189 case T_COMPLEX: return format_complex(v_float, v_imag, fmt);
190 }
191 throw error(error::INTERNAL, "Don't know how to print numeric type");
192 }
193 expr_val_numeric operator~() const
194 {
195 switch(type) {
196 case T_UNSIGNED: return expr_val_numeric(unsigned_tag(), ~v_unsigned);
197 case T_SIGNED: return expr_val_numeric(signed_tag(), ~v_signed);
198 case T_FLOAT: throw_domain("Bit operations are only for integers");
199 case T_COMPLEX: throw_domain("Bit operations are only for integers");
200 }
201 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
202 }
203 expr_val_numeric operator&(const expr_val_numeric& b) const
204 {
205 if(type == T_COMPLEX || b.type == T_COMPLEX)
206 throw_domain("Bit operations are only for integers");
207 if(type == T_FLOAT || b.type == T_FLOAT)
208 throw_domain("Bit operations are only for integers");
209 if(type == T_SIGNED || b.type == T_SIGNED)
210 return expr_val_numeric(signed_tag(), as_signed() & b.as_signed());
211 return expr_val_numeric(unsigned_tag(), as_unsigned() & b.as_unsigned());
212 }
213 expr_val_numeric operator|(const expr_val_numeric& b) const
214 {
215 if(type == T_COMPLEX || b.type == T_COMPLEX)
216 throw_domain("Bit operations are only for integers");
217 if(type == T_FLOAT || b.type == T_FLOAT)
218 throw_domain("Bit operations are only for integers");
219 if(type == T_SIGNED || b.type == T_SIGNED)
220 return expr_val_numeric(signed_tag(), as_signed() | b.as_signed());
221 return expr_val_numeric(unsigned_tag(), as_unsigned() | b.as_unsigned());
222 }
223 expr_val_numeric operator^(const expr_val_numeric& b) const
224 {
225 if(type == T_COMPLEX || b.type == T_COMPLEX)
226 throw_domain("Bit operations are only for integers");
227 if(type == T_FLOAT || b.type == T_FLOAT)
228 throw_domain("Bit operations are only for integers");
229 if(type == T_SIGNED || b.type == T_SIGNED)
230 return expr_val_numeric(signed_tag(), as_signed() ^ b.as_signed());
231 return expr_val_numeric(unsigned_tag(), as_unsigned() ^ b.as_unsigned());
232 }
233 expr_val_numeric operator-() const
234 {
235 switch(type) {
236 case T_COMPLEX: return expr_val_numeric(complex_tag(), -v_float, -v_imag);
237 case T_UNSIGNED: return expr_val_numeric(signed_tag(), -(int64_t)v_unsigned);
238 case T_SIGNED: return expr_val_numeric(signed_tag(), -v_signed);
239 case T_FLOAT: return expr_val_numeric(float_tag(), -v_float);
240 }
241 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
242 }
243 expr_val_numeric operator+(const expr_val_numeric& b) const
244 {
245 if(type == T_COMPLEX || b.type == T_COMPLEX)
246 return expr_val_numeric(complex_tag(), as_float() + b.as_float(),
247 v_imag + b.v_imag);
248 if(type == T_FLOAT || b.type == T_FLOAT)
249 return expr_val_numeric(float_tag(), as_float() + b.as_float());
250 if(type == T_SIGNED || b.type == T_SIGNED)
251 return expr_val_numeric(signed_tag(), as_signed() + b.as_signed());
252 return expr_val_numeric(unsigned_tag(), as_unsigned() + b.as_unsigned());
253 }
254 expr_val_numeric operator-(const expr_val_numeric& b) const
255 {
256 if(type == T_COMPLEX || b.type == T_COMPLEX)
257 return expr_val_numeric(complex_tag(), as_float() - b.as_float(),
258 v_imag - b.v_imag);
259 if(type == T_FLOAT || b.type == T_FLOAT)
260 return expr_val_numeric(float_tag(), as_float() - b.as_float());
261 if(type == T_SIGNED || b.type == T_SIGNED)
262 return expr_val_numeric(signed_tag(), as_signed() - b.as_signed());
263 return expr_val_numeric(unsigned_tag(), as_unsigned() - b.as_unsigned());
264 }
265 expr_val_numeric operator*(const expr_val_numeric& b) const
266 {
267 if(type == T_COMPLEX || b.type == T_COMPLEX)
268 return expr_val_numeric(complex_tag(), as_float() * b.as_float() - v_imag * b.v_imag,
269 as_float() * b.v_imag + b.as_float() * v_imag);
270 if(type == T_FLOAT || b.type == T_FLOAT)
271 return expr_val_numeric(float_tag(), as_float() * b.as_float());
272 if(type == T_SIGNED || b.type == T_SIGNED)
273 return expr_val_numeric(signed_tag(), as_signed() * b.as_signed());
274 return expr_val_numeric(unsigned_tag(), as_unsigned() * b.as_unsigned());
275 }
276 expr_val_numeric operator/(const expr_val_numeric& b) const
277 {
278 if(type == T_COMPLEX || b.type == T_COMPLEX) {
279 double div = b.as_float() * b.as_float() + b.v_imag * b.v_imag;
280 if(div == 0)
281 throw error(error::DIV_BY_0, "Division by 0");
282 return expr_val_numeric(complex_tag(),
283 (as_float() * b.as_float() + v_imag * b.v_imag) / div,
284 (v_imag * b.as_float() - as_float() * b.v_imag) / div);
285 }
286 if(type == T_FLOAT || b.type == T_FLOAT) {
287 if(b.as_float() == 0)
288 throw error(error::DIV_BY_0, "Division by 0");
289 return expr_val_numeric(float_tag(), as_float() / b.as_float());
290 }
291 if(type == T_SIGNED || b.type == T_SIGNED) {
292 if(b.as_signed() == 0)
293 throw error(error::DIV_BY_0, "Division by 0");
294 return expr_val_numeric(signed_tag(), as_signed() / b.as_signed());
295 }
296 if(b.as_unsigned() == 0)
297 throw error(error::DIV_BY_0, "Division by 0");
298 return expr_val_numeric(unsigned_tag(), as_unsigned() / b.as_unsigned());
299 }
300 expr_val_numeric operator%(const expr_val_numeric& b) const
301 {
302 if(type == T_COMPLEX || b.type == T_COMPLEX)
303 throw_domain("Remainder is only for integers");
304 if(type == T_FLOAT || b.type == T_FLOAT)
305 throw_domain("Remainder is only for integers");
306 if(type == T_SIGNED || b.type == T_SIGNED) {
307 if(b.as_signed() == 0)
308 throw error(error::DIV_BY_0, "Division by 0");
309 return expr_val_numeric(signed_tag(), as_signed() / b.as_signed());
310 }
311 if(b.as_unsigned() == 0)
312 throw error(error::DIV_BY_0, "Division by 0");
313 return expr_val_numeric(unsigned_tag(), as_unsigned() / b.as_unsigned());
314 }
315 expr_val_numeric log() const
316 {
317 if(type == T_COMPLEX) {
318 double mag = as_float() * as_float() + v_imag * v_imag;
319 if(mag == 0)
320 throw error(error::LOG_BY_0, "Can't take logarithm of 0");
321 double r = 0.5 * ::log(mag);
322 double i = ::atan2(v_imag, as_float());
323 return expr_val_numeric(complex_tag(), r, i);
324 }
325 if(as_float() == 0)
326 throw error(error::LOG_BY_0, "Can't take logarithm of 0");
327 if(as_float() <= 0)
328 return expr_val_numeric(complex_tag(), ::log(std::abs(as_float())), 4 * ::atan(1));
329 return expr_val_numeric(float_tag(), ::log(as_float()));
330 }
331 static expr_val_numeric log2(expr_val_numeric a, expr_val_numeric b)
332 {
333 return b.log() / a.log();
334 }
335 expr_val_numeric exp() const
336 {
337 if(type == T_COMPLEX) {
338 double mag = ::exp(as_float());
339 return expr_val_numeric(complex_tag(), mag * ::cos(v_imag),
340 mag * ::sin(v_imag));
341 }
342 return expr_val_numeric(float_tag(), ::exp(as_float()));
343 }
344 static expr_val_numeric exp2(expr_val_numeric a, expr_val_numeric b)
345 {
346 expr_val_numeric tmp = b * a.log();
347 return tmp.exp();
348 }
349 expr_val_numeric sqrt() const
350 {
351 if(as_float() < 0 && type != T_COMPLEX)
352 return expr_val_numeric(complex_tag(), 0, ::sqrt(-as_float()));
353 if(type == T_COMPLEX) {
354 double mag = ::sqrt(::sqrt(as_float() * as_float() + v_imag * v_imag));
355 double ar = 0.5 * ::atan2(v_imag, as_float());
356 return expr_val_numeric(complex_tag(), mag * ::cos(ar), mag * ::sin(ar));
357 }
358 return expr_val_numeric(float_tag(), ::sqrt(as_float()));
359 }
360 expr_val_numeric sin() const
361 {
362 if(type == T_COMPLEX) {
363 return expr_val_numeric(complex_tag(), ::sin(as_float()) * ::cosh(v_imag),
364 ::cos(as_float()) * ::sinh(v_imag));
365 }
366 return expr_val_numeric(float_tag(), ::sin(as_float()));
367 }
368 expr_val_numeric cos() const
369 {
370 if(type == T_COMPLEX) {
371 return expr_val_numeric(complex_tag(), ::cos(as_float()) * ::cosh(v_imag),
372 -::sin(as_float()) * ::sinh(v_imag));
373 }
374 return expr_val_numeric(float_tag(), ::cos(as_float()));
375 }
376 expr_val_numeric tan() const
377 {
378 return sin()/cos();
379 }
380 expr_val_numeric atan() const
381 {
382 if(type == T_COMPLEX) {
383 expr_val_numeric x = expr_val_numeric(complex_tag(), 0, 1) * *this;
384 expr_val_numeric n = expr_val_numeric(complex_tag(), 1, 0) + x;
385 expr_val_numeric d = expr_val_numeric(complex_tag(), 1, 0) - x;
386 expr_val_numeric y = n / d;
387 expr_val_numeric w = y.log();
388 return w / expr_val_numeric(complex_tag(), 0, 2);
389 }
390 return expr_val_numeric(float_tag(), ::atan(as_float()));
391 }
392 expr_val_numeric acos() const
393 {
394 expr_val_numeric sinesqr = (expr_val_numeric(float_tag(), 1) - *this * *this);
395 expr_val_numeric sine = sinesqr.sqrt();
396 expr_val_numeric tangent = sine / *this;
397 return tangent.atan();
398 }
399 expr_val_numeric asin() const
400 {
401 expr_val_numeric cosinesqr = (expr_val_numeric(float_tag(), 1) - *this * *this);
402 expr_val_numeric cosine = cosinesqr.sqrt();
403 expr_val_numeric tangent = *this / cosine;
404 return tangent.atan();
405 }
406 expr_val_numeric sinh() const
407 {
408 return (exp() - (-*this).exp()) / expr_val_numeric(float_tag(), 2);
409 }
410 expr_val_numeric cosh() const
411 {
412 return (exp() + (-*this).exp()) / expr_val_numeric(float_tag(), 2);
413 }
414 expr_val_numeric tanh() const
415 {
416 return sinh() / cosh();
417 }
418 expr_val_numeric arsinh() const
419 {
420 //x - 1/x = 2u
421 //x^2 - 2ux - 1 = 0
422 //(x-u)^2 - x^2 + 2ux - u^2 + x^2 - 2ux - 1 = 0
423 //(x-u)^2 = u^2 + 1
424 expr_val_numeric xmu = (*this * *this) + expr_val_numeric(float_tag(), 1);
425 expr_val_numeric x = xmu.sqrt() + *this;
426 return x.log();
427 }
428 expr_val_numeric arcosh() const
429 {
430 expr_val_numeric xmu = (*this * *this) - expr_val_numeric(float_tag(), 1);
431 expr_val_numeric x = xmu.sqrt() + *this;
432 return x.log();
433 }
434 expr_val_numeric artanh() const
435 {
436 //(x-1/x)/(x+1/x)=u
437 //x^2=u+1/(1-u)
438 expr_val_numeric t(float_tag(), 1);
439 return ((t + *this) / (t - *this)).sqrt().log();
440 }
441 static expr_val_numeric atan2(expr_val_numeric a, expr_val_numeric b)
442 {
443 if(a.type == T_COMPLEX || b.type == T_COMPLEX)
444 throw_domain("atan2 is only for reals");
445 return expr_val_numeric(float_tag(), ::atan2(a.as_float(), b.as_float()));
446 }
447 expr_val_numeric torad() const
448 {
449 return expr_val_numeric(float_tag(), ::atan(1) / 45 * as_float());
450 }
451 expr_val_numeric todeg() const
452 {
453 return expr_val_numeric(float_tag(), 45 / ::atan(1) * as_float());
454 }
455 static expr_val_numeric shift(expr_val_numeric a, expr_val_numeric b, bool inv)
456 {
457 int64_t s = b.as_signed();
458 if(inv)
459 s = -s;
460 if(a.type == T_SIGNED) {
461 int64_t _a = a.v_signed;
462 if(s < -63)
463 return expr_val_numeric(signed_tag(), -1);
464 if(s > 63)
465 return expr_val_numeric(signed_tag(), 0);
466 if(s < 0) {
467 uint64_t r = _a;
468 uint64_t r2 = r >> -s;
469 uint64_t m = 0xFFFFFFFFFFFFFFFFULL - ((1ULL << (64 - s)) - 1);
470 return expr_val_numeric(signed_tag(), m | r2);
471 } else if(s > 0)
472 return expr_val_numeric(signed_tag(), _a << s);
473 else
474 return expr_val_numeric(signed_tag(), _a);
475 } else if(a.type == T_UNSIGNED) {
476 uint64_t _a = a.v_unsigned;
477 if(s < -63 || s > 63)
478 return expr_val_numeric(unsigned_tag(), 0);
479 if(s < 0)
480 return expr_val_numeric(unsigned_tag(), _a >> -s);
481 else if(s > 0)
482 return expr_val_numeric(unsigned_tag(), _a << s);
483 else
484 return expr_val_numeric(unsigned_tag(), _a);
485 } else
486 throw_domain("Bit operations are only for integers");
487 return expr_val_numeric(unsigned_tag(), 0); //NOTREACHED
488 }
489 static expr_val_numeric op_pi()
490 {
491 return expr_val_numeric(float_tag(), 4 * ::atan(1));
492 }
493 static expr_val_numeric op_e()
494 {
495 return expr_val_numeric(float_tag(), ::exp(1));
496 }
497 bool operator==(const expr_val_numeric& b) const
498 {
499 if(type == T_COMPLEX || b.type == T_COMPLEX)
500 return as_float() == b.as_float() && v_imag == b.v_imag;
501 return (_cmp(*this, b) == 0);
502 }
503 static int _cmp_float_unsigned(uint64_t a, float b)
504 {
505 if(b < 0)
506 return 1;
507 //TODO: Handle values too large for exact integer representation.
508 if((double)a < b)
509 return -1;
510 if((double)a > b)
511 return 1;
512 return 0;
513 }
514 static int _cmp_float_signed(int64_t a, float b)
515 {
516 //TODO: Handle values too large for exact integer representation.
517 if((double)a < b)
518 return -1;
519 if((double)a > b)
520 return 1;
521 return 0;
522 }
523 static int _cmp(expr_val_numeric a, expr_val_numeric b)
524 {
525 if(a.type == T_COMPLEX || b.type == T_COMPLEX)
526 throw_domain("Can't compare complex numbers");
527 switch(a.type) {
528 case T_UNSIGNED:
529 switch(b.type) {
530 case T_UNSIGNED:
531 return _cmp_values(a.v_unsigned, b.v_unsigned);
532 case T_SIGNED:
533 if(b.v_signed < 0)
534 return 1;
535 if((int64_t)a.v_unsigned < 0)
536 return 1;
537 return _cmp_values((int64_t)a.v_unsigned, b.v_signed);
538 case T_FLOAT:
539 return _cmp_float_unsigned(a.v_unsigned, b.v_float);
540 case T_COMPLEX:
541 throw error(error::INTERNAL,
542 "Internal error (shouldn't be here)");
543 }
544 case T_SIGNED:
545 switch(b.type) {
546 case T_UNSIGNED:
547 if(a.v_signed < 0)
548 return -1;
549 if((int64_t)b.v_unsigned < 0)
550 return -1;
551 return _cmp_values(a.v_signed, (int64_t)b.v_unsigned);
552 case T_SIGNED:
553 return _cmp_values(a.v_signed, b.v_signed);
554 case T_FLOAT:
555 return _cmp_float_signed(a.v_signed, b.v_float);
556 case T_COMPLEX:
557 throw error(error::INTERNAL,
558 "Internal error (shouldn't be here)");
559 }
560 case T_FLOAT:
561 switch(b.type) {
562 case T_UNSIGNED:
563 return -_cmp_float_unsigned(b.v_unsigned, a.v_float);
564 case T_SIGNED:
565 return -_cmp_float_signed(b.v_signed, a.v_float);
566 case T_FLOAT:
567 if(a.v_float < b.v_float)
568 return -1;
569 if(a.v_float > b.v_float)
570 return 1;
571 return 0;
572 case T_COMPLEX:
573 throw error(error::INTERNAL,
574 "Internal error (shouldn't be here)");
575 }
576 case T_COMPLEX:
577 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
578 }
579 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
580 }
581 static expr_val_numeric x_unsigned(expr_val_numeric a)
582 {
583 switch(a.type) {
584 case T_UNSIGNED: return expr_val_numeric(unsigned_tag(), a.v_unsigned);
585 case T_SIGNED: return expr_val_numeric(unsigned_tag(), a.v_signed);
586 case T_FLOAT: return expr_val_numeric(unsigned_tag(), a.v_float);
587 default: throw_domain("Can't convert non-real into unsigned");
588 }
589 return expr_val_numeric(unsigned_tag(), 0); //NOTREACHED.
590 }
591 static expr_val_numeric x_signed(expr_val_numeric a)
592 {
593 switch(a.type) {
594 case T_UNSIGNED: return expr_val_numeric(signed_tag(), a.v_unsigned);
595 case T_SIGNED: return expr_val_numeric(signed_tag(), a.v_signed);
596 case T_FLOAT: return expr_val_numeric(signed_tag(), a.v_float);
597 default: throw_domain("Can't convert non-real into signed");
598 }
599 return expr_val_numeric(signed_tag(), 0); //NOTREACHED.
600 }
601 static expr_val_numeric x_float(expr_val_numeric a)
602 {
603 switch(a.type) {
604 case T_UNSIGNED: return expr_val_numeric(float_tag(), a.v_unsigned);
605 case T_SIGNED: return expr_val_numeric(float_tag(), a.v_signed);
606 case T_FLOAT: return expr_val_numeric(float_tag(), a.v_float);
607 default: throw_domain("Can't convert non-real into float");
608 }
609 return expr_val_numeric(float_tag(), 0); //NOTREACHED.
610 }
611 expr_val_numeric re() const
612 {
613 if(type == T_COMPLEX)
614 return expr_val_numeric(float_tag(), v_float);
615 return expr_val_numeric(float_tag(), as_float());
616 }
617 expr_val_numeric im() const
618 {
619 if(type == T_COMPLEX)
620 return expr_val_numeric(float_tag(), v_imag);
621 return expr_val_numeric(float_tag(), 0);
622 }
623 expr_val_numeric conj() const
624 {
625 if(type == T_COMPLEX)
626 return expr_val_numeric(complex_tag(), v_float, -v_imag);
627 return expr_val_numeric(float_tag(), as_float());
628 }
629 expr_val_numeric abs() const
630 {
631 switch(type) {
632 case T_COMPLEX: return expr_val_numeric(float_tag(), v_float * v_float + v_imag * v_imag);
633 case T_FLOAT: return expr_val_numeric(float_tag(), ::fabs(v_float));
634 case T_SIGNED: return expr_val_numeric(signed_tag(), ::abs(v_signed));
635 case T_UNSIGNED: return expr_val_numeric(unsigned_tag(), v_unsigned);
636 }
637 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
638 }
639 expr_val_numeric arg() const
640 {
641 switch(type) {
642 case T_COMPLEX: return expr_val_numeric(float_tag(), ::atan2(v_imag, v_float));
643 default:
644 if(as_float() < 0)
645 return expr_val_numeric(float_tag(), 4 * ::atan(1));
646 else
647 return expr_val_numeric(float_tag(), 0);
648 }
649 }
650 private:
651 enum _type type;
652 union {
653 uint64_t v_unsigned;
654 int64_t v_signed;
655 double v_float;
656 };
657 double v_imag;
658 };
659
660 class expr_val
661 {
662 struct number_tag {};
663 struct string_tag {};
664 struct boolean_tag {};
665 enum _type
666 {
667 T_BOOLEAN,
668 T_NUMERIC,
669 T_STRING,
670 };
671 expr_val_numeric& as_numeric()
672 {
673 if(type != T_NUMERIC)
674 throw_domain("Can't operate with non-numbers");
675 return v_numeric;
676 }
677 public:
678 expr_val()
679 {
680 type = T_NUMERIC;
681 v_boolean = false;
682 }
683 expr_val(const std::string& str, bool string)
684 {
685 v_boolean = false;
686 if(string) {
687 v_string = str;
688 type = T_STRING;
689 } else if(str == "false") {
690 v_boolean = false;
691 type = T_BOOLEAN;
692 } else if(str == "true") {
693 v_boolean = true;
694 type = T_BOOLEAN;
695 } else if(str == "e") {
696 v_numeric = expr_val_numeric::op_e();
697 type = T_NUMERIC;
698 } else if(str == "pi") {
699 v_numeric = expr_val_numeric::op_pi();
700 type = T_NUMERIC;
701 } else {
702 v_numeric = expr_val_numeric(str);
703 type = T_NUMERIC;
704 }
705 }
706 expr_val(typeinfo_wrapper<expr_val>::unsigned_tag t, uint64_t v)
707 : type(T_NUMERIC), v_boolean(false), v_numeric(expr_val_numeric::unsigned_tag(), v)
708 {
709 }
710 expr_val(typeinfo_wrapper<expr_val>::signed_tag t, int64_t v)
711 : type(T_NUMERIC), v_boolean(false), v_numeric(expr_val_numeric::signed_tag(), v)
712 {
713 }
714 expr_val(typeinfo_wrapper<expr_val>::float_tag t, double v)
715 : type(T_NUMERIC), v_boolean(false), v_numeric(expr_val_numeric::float_tag(), v)
716 {
717 }
718 expr_val(typeinfo_wrapper<expr_val>::boolean_tag, bool b)
719 : type(T_BOOLEAN), v_boolean(b)
720 {
721 }
722 expr_val(expr_val_numeric v)
723 : type(T_NUMERIC), v_boolean(false), v_numeric(v)
724 {
725 }
726 expr_val(string_tag, std::string s)
727 : type(T_STRING), v_boolean(false), v_string(s)
728 {
729 }
730 expr_val(boolean_tag, bool b)
731 : type(T_BOOLEAN), v_boolean(b)
732 {
733 }
734 std::string tostring()
735 {
736 switch(type) {
737 case T_BOOLEAN:
738 if(v_boolean)
739 return "true";
740 else
741 return "false";
742 case T_NUMERIC:
743 return v_numeric.tostring();
744 case T_STRING:
745 return v_string;
746 }
747 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
748 }
749 uint64_t tounsigned()
750 {
751 if(type != T_NUMERIC)
752 throw_domain("Can't convert non-number into unsigned");
753 return v_numeric.tounsigned();
754 }
755 int64_t tosigned()
756 {
757 if(type != T_NUMERIC)
758 throw_domain("Can't convert non-number into signed");
759 return v_numeric.tosigned();
760 }
761 void scale(uint64_t _scale)
762 {
763 if(type != T_NUMERIC)
764 throw_domain("Can't scale non-number");
765 v_numeric.scale(_scale);
766 }
767 bool toboolean()
768 {
769 switch(type) {
770 case T_BOOLEAN:
771 return v_boolean;
772 case T_NUMERIC:
773 return v_numeric.toboolean();
774 case T_STRING:
775 return (v_string.length() != 0);
776 }
777 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
778 }
779 static expr_val op_lnot(std::vector<std::function<expr_val&()>> promises)
780 {
781 if(promises.size() != 1)
782 throw error(error::ARGCOUNT, "logical not takes 1 argument");
783 return expr_val(boolean_tag(), !(promises[0]().toboolean()));
784 }
785 static expr_val op_lor(std::vector<std::function<expr_val&()>> promises)
786 {
787 if(promises.size() != 2)
788 throw error(error::ARGCOUNT, "logical or takes 2 arguments");
789 if(promises[0]().toboolean())
790 return expr_val(boolean_tag(), true);
791 return expr_val(boolean_tag(), promises[1]().toboolean());
792 }
793 static expr_val op_land(std::vector<std::function<expr_val&()>> promises)
794 {
795 if(promises.size() != 2)
796 throw error(error::ARGCOUNT, "logical and takes 2 arguments");
797 if(!(promises[0]().toboolean()))
798 return expr_val(boolean_tag(), false);
799 return expr_val(boolean_tag(), promises[1]().toboolean());
800 }
801 static expr_val fun_if(std::vector<std::function<expr_val&()>> promises)
802 {
803 if(promises.size() == 2) {
804 if((promises[0]().toboolean()))
805 return promises[1]();
806 else
807 return expr_val(boolean_tag(), false);
808 } else if(promises.size() == 3) {
809 if((promises[0]().toboolean()))
810 return promises[1]();
811 else
812 return promises[2]();
813 } else
814 throw error(error::ARGCOUNT, "if takes 2 or 3 arguments");
815 }
816 static expr_val fun_select(std::vector<std::function<expr_val&()>> promises)
817 {
818 for(auto& i : promises) {
819 expr_val v = i();
820 if(v.type != T_BOOLEAN || v.v_boolean)
821 return v;
822 }
823 return expr_val(boolean_tag(), false);
824 }
825 static expr_val fun_pyth(std::vector<std::function<expr_val&()>> promises)
826 {
827 std::vector<expr_val> v;
828 for(auto& i : promises)
829 v.push_back(i());
830 expr_val_numeric n(expr_val_numeric::float_tag(), 0);
831 expr_val_numeric one(expr_val_numeric::float_tag(), 1);
832 for(auto& i : v) {
833 if(i.type != T_NUMERIC)
834 throw error(error::WDOMAIN, "pyth requires numeric args");
835 n = n + one * i.v_numeric * i.v_numeric;
836 }
837 return n.sqrt();
838 }
839 template<expr_val (*T)(expr_val& a, expr_val& b)>
840 static expr_val fun_fold(std::vector<std::function<expr_val&()>> promises)
841 {
842 if(!promises.size())
843 return expr_val(boolean_tag(), false);
844 expr_val v = promises[0]();
845 for(size_t i = 1; i < promises.size(); i++)
846 v = T(v, promises[i]());
847 return v;
848 }
849 static expr_val fold_min(expr_val& a, expr_val& b)
850 {
851 int t = _cmp_values(a.type, b.type);
852 if(t < 0)
853 return a;
854 if(t > 0)
855 return b;
856 return (_cmp(a, b) < 0) ? a : b;
857 }
858 static expr_val fold_max(expr_val& a, expr_val& b)
859 {
860 int t = _cmp_values(a.type, b.type);
861 if(t < 0)
862 return a;
863 if(t > 0)
864 return b;
865 return (_cmp(a, b) > 0) ? a : b;
866 }
867 static expr_val fold_sum(expr_val& a, expr_val& b)
868 {
869 return add(a, b);
870 }
871 static expr_val fold_prod(expr_val& a, expr_val& b)
872 {
873 return mul(a, b);
874 }
875 template<expr_val (*T)(expr_val a, expr_val b)>
876 static expr_val op_binary(std::vector<std::function<expr_val&()>> promises)
877 {
878 if(promises.size() != 2)
879 throw error(error::ARGCOUNT, "Operation takes 2 arguments");
880 expr_val a = promises[0]();
881 expr_val b = promises[1]();
882 return T(a, b);
883 }
884 template<expr_val (*T)(expr_val a)>
885 static expr_val op_unary(std::vector<std::function<expr_val&()>> promises)
886 {
887 if(promises.size() != 1)
888 throw error(error::ARGCOUNT, "Operation takes 1 argument");
889 expr_val a = promises[0]();
890 return T(a);
891 }
892 template<expr_val (*T)(expr_val a),expr_val (*U)(expr_val a, expr_val b)>
893 static expr_val op_unary_binary(std::vector<std::function<expr_val&()>> promises)
894 {
895 if(promises.size() == 1)
896 return T(promises[0]());
897 if(promises.size() == 2)
898 return U(promises[0](), promises[1]());
899 throw error(error::ARGCOUNT, "Operation takes 1 or 2 arguments");
900 }
901 static expr_val bnot(expr_val a)
902 {
903 return ~a.as_numeric();
904 }
905 static expr_val band(expr_val a, expr_val b)
906 {
907 return a.as_numeric() & b.as_numeric();
908 }
909 static expr_val bor(expr_val a, expr_val b)
910 {
911 return a.as_numeric() | b.as_numeric();
912 }
913 static expr_val bxor(expr_val a, expr_val b)
914 {
915 return a.as_numeric() ^ b.as_numeric();
916 }
917 static expr_val neg(expr_val a)
918 {
919 return -a.as_numeric();
920 }
921 template<expr_val_numeric (expr_val_numeric::*T)() const>
922 static expr_val f_n_fn(expr_val a)
923 {
924 return (a.as_numeric().*T)();
925 }
926 template<expr_val_numeric (*T)(expr_val_numeric x, expr_val_numeric y)>
927 static expr_val f_n_fn2(expr_val a, expr_val b)
928 {
929 return T(a.as_numeric(), b.as_numeric());
930 }
931 static expr_val lshift(expr_val a, expr_val b)
932 {
933 return expr_val_numeric::shift(a.as_numeric(), b.as_numeric(), false);
934 }
935 static expr_val rshift(expr_val a, expr_val b)
936 {
937 return expr_val_numeric::shift(a.as_numeric(), b.as_numeric(), true);
938 }
939 static expr_val op_pi(std::vector<std::function<expr_val&()>> promises)
940 {
941 return expr_val_numeric::op_pi();
942 }
943 static expr_val add(expr_val a, expr_val b)
944 {
945 if(a.type == T_STRING && b.type == T_STRING)
946 return expr_val(string_tag(), a.v_string + b.v_string);
947 return a.as_numeric() + b.as_numeric();
948 }
949 static expr_val sub(expr_val a, expr_val b)
950 {
951 return a.as_numeric() - b.as_numeric();
952 }
953 static expr_val mul(expr_val a, expr_val b)
954 {
955 return a.as_numeric() * b.as_numeric();
956 }
957 static expr_val div(expr_val a, expr_val b)
958 {
959 return a.as_numeric() / b.as_numeric();
960 }
961 static expr_val rem(expr_val a, expr_val b)
962 {
963 return a.as_numeric() % b.as_numeric();
964 }
965 static bool _eq(const expr_val& a, const expr_val& b)
966 {
967 if(a.type != b.type)
968 return false;
969 switch(a.type) {
970 case T_BOOLEAN: return (a.v_boolean == b.v_boolean);
971 case T_STRING: return (a.v_string == b.v_string);
972 case T_NUMERIC: return (a.v_numeric == b.v_numeric);
973 }
974 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
975 }
976 static expr_val eq(expr_val a, expr_val b)
977 {
978 return expr_val(boolean_tag(), _eq(a, b));
979 }
980 static expr_val ne(expr_val a, expr_val b)
981 {
982 return expr_val(boolean_tag(), !_eq(a, b));
983 }
984 static int _cmp(expr_val a, expr_val b)
985 {
986 if(a.type != b.type)
987 throw_domain("Can't compare distinct value types");
988 switch(a.type) {
989 case T_BOOLEAN: return _cmp_values(a.v_boolean, b.v_boolean);
990 case T_STRING: return _cmp_values(a.v_string, b.v_string);
991 case T_NUMERIC: return expr_val_numeric::_cmp(a.v_numeric, b.v_numeric);
992 }
993 throw error(error::INTERNAL, "Internal error (shouldn't be here)");
994 }
995 template<expr_val_numeric(*T)(expr_val_numeric v)>
996 static expr_val x_nconv(expr_val a)
997 {
998 return T(a.as_numeric());
999 }
1000 static expr_val lt(expr_val a, expr_val b)
1001 {
1002 return expr_val(boolean_tag(), _cmp(a, b) < 0);
1003 }
1004 static expr_val le(expr_val a, expr_val b)
1005 {
1006 return expr_val(boolean_tag(), _cmp(a, b) <= 0);
1007 }
1008 static expr_val ge(expr_val a, expr_val b)
1009 {
1010 return expr_val(boolean_tag(), _cmp(a, b) >= 0);
1011 }
1012 static expr_val gt(expr_val a, expr_val b)
1013 {
1014 return expr_val(boolean_tag(), _cmp(a, b) > 0);
1015 }
1016 std::string format_string(std::string val, _format fmt)
1017 {
1018 if((int)val.length() > fmt.precision && fmt.precision >= 0)
1019 val = val.substr(0, fmt.precision);
1020 while((int)val.length() < fmt.width)
1021 val = " " + val;
1022 return val;
1023 }
1024 std::string print_bool_numeric(bool val, _format fmt)
1025 {
1026 std::string out = val ? "1" : "0";
1027 if(fmt.precision > 0) {
1028 out += ".";
1029 for(int i = 0; i < fmt.precision; i++)
1030 out += "0";
1031 }
1032 while((int)out.length() < fmt.width)
1033 out = ((fmt.fillzeros) ? "0" : " ") + out;
1034 return out;
1035 }
1036 std::string format(_format fmt)
1037 {
1038 switch(type) {
1039 case T_BOOLEAN: return format_bool(v_boolean, fmt);
1040 case T_NUMERIC: return v_numeric.format(fmt);
1041 case T_STRING: return format_string(v_string, fmt);
1042 default:
1043 return "#Notprintable";
1044 }
1045 }
1046 static std::set<operinfo*> operations()
1047 {
1048 static operinfo_set<expr_val> x({
1049 {"-", expr_val::op_unary<expr_val::neg>, true, 1, -3, true},
1050 {"!", expr_val::op_lnot, true, 1, -3, true},
1051 {"~", expr_val::op_unary<expr_val::bnot>, true, 1, -3, true},
1052 {"*", expr_val::op_binary<expr_val::mul>, true, 2, -5, false},
1053 {"/", expr_val::op_binary<expr_val::div>, true, 2, -5, false},
1054 {"%", expr_val::op_binary<expr_val::rem>, true, 2, -5, false},
1055 {"+", expr_val::op_binary<expr_val::add>, true, 2, -6, false},
1056 {"-", expr_val::op_binary<expr_val::sub>, true, 2, -6, false},
1057 {"<<", expr_val::op_binary<expr_val::lshift>, true, 2, -7, false},
1058 {">>", expr_val::op_binary<expr_val::rshift>, true, 2, -7, false},
1059 {"<", expr_val::op_binary<expr_val::lt>, true, 2, -8, false},
1060 {"<=", expr_val::op_binary<expr_val::le>, true, 2, -8, false},
1061 {">", expr_val::op_binary<expr_val::gt>, true, 2, -8, false},
1062 {">=", expr_val::op_binary<expr_val::ge>, true, 2, -8, false},
1063 {"==", expr_val::op_binary<expr_val::eq>, true, 2, -9, false},
1064 {"!=", expr_val::op_binary<expr_val::ne>, true, 2, -9, false},
1065 {"&", expr_val::op_binary<expr_val::band>, true, 2, -10, false},
1066 {"^", expr_val::op_binary<expr_val::bxor>, true, 2, -11, false},
1067 {"|", expr_val::op_binary<expr_val::bor>, true, 2, -12, false},
1068 {"&&", expr_val::op_land, true, 2, -13, false},
1069 {"||", expr_val::op_lor, true, 2, -14, false},
1070 {"π", expr_val::op_pi, true, 0, 0, false},
1071 {"if", expr_val::fun_if},
1072 {"select", expr_val::fun_select},
1073 {"unsigned", expr_val::op_unary<expr_val::x_nconv<expr_val_numeric::x_unsigned>>},
1074 {"signed", expr_val::op_unary<expr_val::x_nconv<expr_val_numeric::x_signed>>},
1075 {"float", expr_val::op_unary<expr_val::x_nconv<expr_val_numeric::x_float>>},
1076 {"min", expr_val::fun_fold<expr_val::fold_min>},
1077 {"max", expr_val::fun_fold<expr_val::fold_max>},
1078 {"sum", expr_val::fun_fold<expr_val::fold_sum>},
1079 {"prod", expr_val::fun_fold<expr_val::fold_prod>},
1080 {"sqrt", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::sqrt>>},
1081 {"log", expr_val::op_unary_binary<expr_val::f_n_fn<&expr_val_numeric::log>,
1082 expr_val::f_n_fn2<expr_val_numeric::log2>>},
1083 {"exp", expr_val::op_unary_binary<expr_val::f_n_fn<&expr_val_numeric::exp>,
1084 expr_val::f_n_fn2<expr_val_numeric::exp2>>},
1085 {"sin", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::sin>>},
1086 {"cos", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::cos>>},
1087 {"tan", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::tan>>},
1088 {"atan", expr_val::op_unary_binary<expr_val::f_n_fn<&expr_val_numeric::atan>,
1089 expr_val::f_n_fn2<expr_val_numeric::atan2>>},
1090 {"asin", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::asin>>},
1091 {"acos", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::acos>>},
1092 {"sinh", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::sinh>>},
1093 {"cosh", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::cosh>>},
1094 {"tanh", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::tanh>>},
1095 {"artanh", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::artanh>>},
1096 {"arsinh", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::arsinh>>},
1097 {"arcosh", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::arcosh>>},
1098 {"torad", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::torad>>},
1099 {"todeg", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::todeg>>},
1100 {"re", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::re>>},
1101 {"im", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::im>>},
1102 {"conj", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::conj>>},
1103 {"abs", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::abs>>},
1104 {"arg", expr_val::op_unary<expr_val::f_n_fn<&expr_val_numeric::arg>>},
1105 {"pyth", expr_val::fun_pyth},
1106 });
1107 return x.get_set();
1108 }
1109 private:
1110 _type type;
1111 bool v_boolean;
1112 expr_val_numeric v_numeric;
1113 std::string v_string;
1114 };
1115 }
1116
1117 struct typeinfo* expression_value()
1118 {
1119 static typeinfo_wrapper<expr_val> expession_value_obj;
1120 return &expession_value_obj;
1121 }
1122 }
Rerecording SNES/GB(C) emulator based on bsnes / gambatte core