Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 1 | #include <stdlib.h> |
Paul Sokolovsky | 864038d | 2014-03-31 02:12:40 +0300 | [diff] [blame] | 2 | #include <stdio.h> |
| 3 | #include <string.h> |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 4 | #include <assert.h> |
Rachel Dowdall | 300c8bd | 2014-03-20 22:40:38 +0000 | [diff] [blame] | 5 | #include <math.h> |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 6 | |
| 7 | #include "nlr.h" |
| 8 | #include "misc.h" |
| 9 | #include "mpconfig.h" |
Damien George | 55baff4 | 2014-01-21 21:40:13 +0000 | [diff] [blame] | 10 | #include "qstr.h" |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 11 | #include "obj.h" |
Damien George | 2077397 | 2014-02-22 18:12:43 +0000 | [diff] [blame] | 12 | #include "parsenum.h" |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 13 | #include "runtime0.h" |
| 14 | |
| 15 | #if MICROPY_ENABLE_FLOAT |
Damien George | 8bfec2b | 2014-03-10 13:27:02 +0000 | [diff] [blame] | 16 | |
Dave Hylands | ca5a241 | 2014-03-10 00:10:01 -0700 | [diff] [blame] | 17 | #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT |
Damien George | 8bfec2b | 2014-03-10 13:27:02 +0000 | [diff] [blame] | 18 | #include "formatfloat.h" |
Dave Hylands | ca5a241 | 2014-03-10 00:10:01 -0700 | [diff] [blame] | 19 | #endif |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 20 | |
Paul Sokolovsky | d5df6cd | 2014-02-12 18:15:40 +0200 | [diff] [blame] | 21 | STATIC void float_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o_in, mp_print_kind_t kind) { |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 22 | mp_obj_float_t *o = o_in; |
Dave Hylands | ca5a241 | 2014-03-10 00:10:01 -0700 | [diff] [blame] | 23 | #if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT |
| 24 | char buf[32]; |
| 25 | format_float(o->value, buf, sizeof(buf), 'g', 6, '\0'); |
| 26 | print(env, "%s", buf); |
Damien George | 60be1cf | 2014-04-05 20:51:29 +0100 | [diff] [blame] | 27 | if (strchr(buf, '.') == NULL) { |
| 28 | // Python floats always have decimal point |
| 29 | print(env, ".0"); |
| 30 | } |
Dave Hylands | ca5a241 | 2014-03-10 00:10:01 -0700 | [diff] [blame] | 31 | #else |
Paul Sokolovsky | 864038d | 2014-03-31 02:12:40 +0300 | [diff] [blame] | 32 | char buf[32]; |
Paul Sokolovsky | 7de5377 | 2014-04-18 21:12:52 +0300 | [diff] [blame] | 33 | sprintf(buf, "%.17g", (double) o->value); |
Paul Sokolovsky | 864038d | 2014-03-31 02:12:40 +0300 | [diff] [blame] | 34 | print(env, buf); |
| 35 | if (strchr(buf, '.') == NULL) { |
| 36 | // Python floats always have decimal point |
| 37 | print(env, ".0"); |
| 38 | } |
Dave Hylands | ca5a241 | 2014-03-10 00:10:01 -0700 | [diff] [blame] | 39 | #endif |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 40 | } |
| 41 | |
Paul Sokolovsky | d5df6cd | 2014-02-12 18:15:40 +0200 | [diff] [blame] | 42 | STATIC mp_obj_t float_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) { |
Damien George | 20006db | 2014-01-18 14:10:48 +0000 | [diff] [blame] | 43 | // TODO check n_kw == 0 |
| 44 | |
Damien George | 71c5181 | 2014-01-04 20:21:15 +0000 | [diff] [blame] | 45 | switch (n_args) { |
| 46 | case 0: |
| 47 | return mp_obj_new_float(0); |
| 48 | |
| 49 | case 1: |
Damien George | 2077397 | 2014-02-22 18:12:43 +0000 | [diff] [blame] | 50 | if (MP_OBJ_IS_STR(args[0])) { |
| 51 | // a string, parse it |
| 52 | uint l; |
| 53 | const char *s = mp_obj_str_get_data(args[0], &l); |
Damien George | 6e48f7f | 2014-03-21 11:45:46 +0000 | [diff] [blame] | 54 | return mp_parse_num_decimal(s, l, false, false); |
Damien George | 0c36da0 | 2014-03-08 15:24:39 +0000 | [diff] [blame] | 55 | } else if (MP_OBJ_IS_TYPE(args[0], &mp_type_float)) { |
Damien George | 6e48f7f | 2014-03-21 11:45:46 +0000 | [diff] [blame] | 56 | // a float, just return it |
Damien George | 71c5181 | 2014-01-04 20:21:15 +0000 | [diff] [blame] | 57 | return args[0]; |
| 58 | } else { |
Damien George | 6e48f7f | 2014-03-21 11:45:46 +0000 | [diff] [blame] | 59 | // something else, try to cast it to a float |
Damien George | 71c5181 | 2014-01-04 20:21:15 +0000 | [diff] [blame] | 60 | return mp_obj_new_float(mp_obj_get_float(args[0])); |
| 61 | } |
| 62 | |
| 63 | default: |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 64 | nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "float takes at most 1 argument, %d given", n_args)); |
Damien George | 71c5181 | 2014-01-04 20:21:15 +0000 | [diff] [blame] | 65 | } |
| 66 | } |
| 67 | |
Paul Sokolovsky | d5df6cd | 2014-02-12 18:15:40 +0200 | [diff] [blame] | 68 | STATIC mp_obj_t float_unary_op(int op, mp_obj_t o_in) { |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 69 | mp_obj_float_t *o = o_in; |
| 70 | switch (op) { |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 71 | case MP_UNARY_OP_BOOL: return MP_BOOL(o->value != 0); |
| 72 | case MP_UNARY_OP_POSITIVE: return o_in; |
| 73 | case MP_UNARY_OP_NEGATIVE: return mp_obj_new_float(-o->value); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 74 | default: return NULL; // op not supported |
| 75 | } |
| 76 | } |
| 77 | |
Paul Sokolovsky | d5df6cd | 2014-02-12 18:15:40 +0200 | [diff] [blame] | 78 | STATIC mp_obj_t float_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) { |
Damien George | e2e3d11 | 2014-01-06 22:13:00 +0000 | [diff] [blame] | 79 | mp_obj_float_t *lhs = lhs_in; |
Damien George | 0c36da0 | 2014-03-08 15:24:39 +0000 | [diff] [blame] | 80 | if (MP_OBJ_IS_TYPE(rhs_in, &mp_type_complex)) { |
Damien George | e2e3d11 | 2014-01-06 22:13:00 +0000 | [diff] [blame] | 81 | return mp_obj_complex_binary_op(op, lhs->value, 0, rhs_in); |
| 82 | } else { |
| 83 | return mp_obj_float_binary_op(op, lhs->value, rhs_in); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 84 | } |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 85 | } |
| 86 | |
Damien George | 0c36da0 | 2014-03-08 15:24:39 +0000 | [diff] [blame] | 87 | const mp_obj_type_t mp_type_float = { |
Damien George | c596612 | 2014-02-15 16:10:44 +0000 | [diff] [blame] | 88 | { &mp_type_type }, |
Damien George | a71c83a | 2014-02-15 11:34:50 +0000 | [diff] [blame] | 89 | .name = MP_QSTR_float, |
Paul Sokolovsky | 860ffb0 | 2014-01-05 22:34:09 +0200 | [diff] [blame] | 90 | .print = float_print, |
| 91 | .make_new = float_make_new, |
| 92 | .unary_op = float_unary_op, |
| 93 | .binary_op = float_binary_op, |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 94 | }; |
| 95 | |
| 96 | mp_obj_t mp_obj_new_float(mp_float_t value) { |
| 97 | mp_obj_float_t *o = m_new(mp_obj_float_t, 1); |
Damien George | 0c36da0 | 2014-03-08 15:24:39 +0000 | [diff] [blame] | 98 | o->base.type = &mp_type_float; |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 99 | o->value = value; |
| 100 | return (mp_obj_t)o; |
| 101 | } |
| 102 | |
| 103 | mp_float_t mp_obj_float_get(mp_obj_t self_in) { |
Damien George | 0c36da0 | 2014-03-08 15:24:39 +0000 | [diff] [blame] | 104 | assert(MP_OBJ_IS_TYPE(self_in, &mp_type_float)); |
Damien | d99b052 | 2013-12-21 18:17:45 +0000 | [diff] [blame] | 105 | mp_obj_float_t *self = self_in; |
| 106 | return self->value; |
| 107 | } |
| 108 | |
Damien George | e2e3d11 | 2014-01-06 22:13:00 +0000 | [diff] [blame] | 109 | mp_obj_t mp_obj_float_binary_op(int op, mp_float_t lhs_val, mp_obj_t rhs_in) { |
| 110 | mp_float_t rhs_val = mp_obj_get_float(rhs_in); // can be any type, this function will convert to float (if possible) |
| 111 | switch (op) { |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 112 | case MP_BINARY_OP_ADD: |
| 113 | case MP_BINARY_OP_INPLACE_ADD: lhs_val += rhs_val; break; |
| 114 | case MP_BINARY_OP_SUBTRACT: |
| 115 | case MP_BINARY_OP_INPLACE_SUBTRACT: lhs_val -= rhs_val; break; |
| 116 | case MP_BINARY_OP_MULTIPLY: |
| 117 | case MP_BINARY_OP_INPLACE_MULTIPLY: lhs_val *= rhs_val; break; |
Paul Sokolovsky | 96ed213 | 2014-03-31 02:18:09 +0300 | [diff] [blame] | 118 | // TODO: verify that C floor matches Python semantics |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 119 | case MP_BINARY_OP_FLOOR_DIVIDE: |
Paul Sokolovsky | 96ed213 | 2014-03-31 02:18:09 +0300 | [diff] [blame] | 120 | case MP_BINARY_OP_INPLACE_FLOOR_DIVIDE: |
Damien George | 9dcc60d | 2014-04-13 17:45:30 +0100 | [diff] [blame] | 121 | if (rhs_val == 0) { |
| 122 | zero_division_error: |
Damien George | ea13f40 | 2014-04-05 18:32:08 +0100 | [diff] [blame] | 123 | nlr_raise(mp_obj_new_exception_msg(&mp_type_ZeroDivisionError, "float division by zero")); |
Rachel Dowdall | 300c8bd | 2014-03-20 22:40:38 +0000 | [diff] [blame] | 124 | } |
Damien George | 9dcc60d | 2014-04-13 17:45:30 +0100 | [diff] [blame] | 125 | lhs_val = MICROPY_FLOAT_C_FUN(floor)(lhs_val / rhs_val); |
| 126 | break; |
| 127 | case MP_BINARY_OP_TRUE_DIVIDE: |
| 128 | case MP_BINARY_OP_INPLACE_TRUE_DIVIDE: |
| 129 | if (rhs_val == 0) { |
| 130 | goto zero_division_error; |
| 131 | } |
| 132 | lhs_val /= rhs_val; |
Rachel Dowdall | 300c8bd | 2014-03-20 22:40:38 +0000 | [diff] [blame] | 133 | break; |
Damien George | b23fbb3 | 2014-04-02 12:26:49 +0100 | [diff] [blame] | 134 | case MP_BINARY_OP_POWER: |
| 135 | case MP_BINARY_OP_INPLACE_POWER: lhs_val = MICROPY_FLOAT_C_FUN(pow)(lhs_val, rhs_val); break; |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 136 | case MP_BINARY_OP_LESS: return MP_BOOL(lhs_val < rhs_val); |
| 137 | case MP_BINARY_OP_MORE: return MP_BOOL(lhs_val > rhs_val); |
Damien George | b8a053a | 2014-04-11 10:10:37 +0100 | [diff] [blame] | 138 | case MP_BINARY_OP_EQUAL: return MP_BOOL(lhs_val == rhs_val); |
Damien George | d17926d | 2014-03-30 13:35:08 +0100 | [diff] [blame] | 139 | case MP_BINARY_OP_LESS_EQUAL: return MP_BOOL(lhs_val <= rhs_val); |
| 140 | case MP_BINARY_OP_MORE_EQUAL: return MP_BOOL(lhs_val >= rhs_val); |
John R. Lenton | b8698fc | 2014-01-11 00:58:59 +0000 | [diff] [blame] | 141 | |
Paul Sokolovsky | a8e60c1 | 2014-03-31 01:38:25 +0300 | [diff] [blame] | 142 | default: |
Damien George | ea8d06c | 2014-04-17 23:19:36 +0100 | [diff] [blame] | 143 | return MP_OBJ_NOT_SUPPORTED; |
Damien George | e2e3d11 | 2014-01-06 22:13:00 +0000 | [diff] [blame] | 144 | } |
| 145 | return mp_obj_new_float(lhs_val); |
| 146 | } |
| 147 | |
Damien George | 8bfec2b | 2014-03-10 13:27:02 +0000 | [diff] [blame] | 148 | #endif // MICROPY_ENABLE_FLOAT |