| ... | ... | @@ -5,16 +5,12 @@ |
| 5 | 5 | * See http://opensource.org/licenses/MIT |
| 6 | 6 | */ |
| 7 | 7 | |
| 8 | | // TODO in this file we cast between __float128 and double |
| 9 | | // and lose precision. for now this is going to be a bug in |
| 10 | | // the compiler because I don't want to add a dependency on libquadmath. |
| 11 | | // when we self host we can use zig's f128 and the problem is fixed. |
| 12 | | |
| 13 | 8 | #include "bigfloat.hpp" |
| 14 | 9 | #include "bigint.hpp" |
| 15 | 10 | #include "buffer.hpp" |
| 16 | 11 | #include <math.h> |
| 17 | 12 | #include <errno.h> |
| 13 | #include <quadmath.h> |
| 18 | 14 | |
| 19 | 15 | void bigfloat_init_float(BigFloat *dest, __float128 x) { |
| 20 | 16 | dest->value = x; |
| ... | ... | @@ -51,7 +47,7 @@ int bigfloat_init_buf_base10(BigFloat *dest, const uint8_t *buf_ptr, size_t buf_ |
| 51 | 47 | char *str_begin = (char *)buf_ptr; |
| 52 | 48 | char *str_end; |
| 53 | 49 | errno = 0; |
| 54 | | dest->value = (__float128)strtod(str_begin, &str_end); |
| 50 | dest->value = strtoflt128(str_begin, &str_end); |
| 55 | 51 | if (errno) { |
| 56 | 52 | return ErrorOverflow; |
| 57 | 53 | } |
| ... | ... | @@ -82,26 +78,29 @@ void bigfloat_div(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { |
| 82 | 78 | void bigfloat_div_trunc(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { |
| 83 | 79 | dest->value = op1->value / op2->value; |
| 84 | 80 | if (dest->value >= 0.0) { |
| 85 | | dest->value = (__float128)floor((double)dest->value); |
| 81 | dest->value = floorq(dest->value); |
| 86 | 82 | } else { |
| 87 | | dest->value = (__float128)ceil((double)dest->value); |
| 83 | dest->value = ceilq(dest->value); |
| 88 | 84 | } |
| 89 | 85 | } |
| 90 | 86 | |
| 91 | 87 | void bigfloat_div_floor(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { |
| 92 | | dest->value = (__float128)floor((double)(op1->value / op2->value)); |
| 88 | dest->value = floorq(op1->value / op2->value); |
| 93 | 89 | } |
| 94 | 90 | |
| 95 | 91 | void bigfloat_rem(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { |
| 96 | | dest->value = (__float128)fmod((double)op1->value, (double)op2->value); |
| 92 | dest->value = fmodq(op1->value, op2->value); |
| 97 | 93 | } |
| 98 | 94 | |
| 99 | 95 | void bigfloat_mod(BigFloat *dest, const BigFloat *op1, const BigFloat *op2) { |
| 100 | | dest->value = (__float128)fmod(fmod((double)op1->value, (double)op2->value) + (double)op2->value, (double)op2->value); |
| 96 | dest->value = fmodq(fmodq(op1->value, op2->value) + op2->value, op2->value); |
| 101 | 97 | } |
| 102 | 98 | |
| 103 | 99 | void bigfloat_write_buf(Buf *buf, const BigFloat *op) { |
| 104 | | buf_appendf(buf, "%f", (double)op->value); |
| 100 | buf_resize(buf, 256); |
| 101 | int len = quadmath_snprintf(buf_ptr(buf), buf_len(buf), "%Qf", op->value); |
| 102 | assert(len > 0); |
| 103 | buf_resize(buf, len); |
| 105 | 104 | } |
| 106 | 105 | |
| 107 | 106 | Cmp bigfloat_cmp(const BigFloat *op1, const BigFloat *op2) { |
| ... | ... | @@ -164,5 +163,5 @@ Cmp bigfloat_cmp_zero(const BigFloat *bigfloat) { |
| 164 | 163 | } |
| 165 | 164 | |
| 166 | 165 | bool bigfloat_has_fraction(const BigFloat *bigfloat) { |
| 167 | | return ((__float128)floor((double)bigfloat->value)) != bigfloat->value; |
| 166 | return floorq(bigfloat->value) != bigfloat->value; |
| 168 | 167 | } |
Andrew Kelley <andrew@ziglang.org> 2017-08-18 13:13:03-04:00