objcomplex.c 4.75 KB
Newer Older
1
2
3
4
5
6
#include <stdlib.h>
#include <assert.h>

#include "nlr.h"
#include "misc.h"
#include "mpconfig.h"
7
#include "qstr.h"
8
#include "obj.h"
9
#include "parsenum.h"
10
11
12
13
14
15
16
17
18
19
20
21
22
#include "runtime0.h"
#include "map.h"

#if MICROPY_ENABLE_FLOAT

typedef struct _mp_obj_complex_t {
    mp_obj_base_t base;
    mp_float_t real;
    mp_float_t imag;
} mp_obj_complex_t;

mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag);

23
STATIC void complex_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o_in, mp_print_kind_t kind) {
24
25
    mp_obj_complex_t *o = o_in;
    if (o->real == 0) {
mux's avatar
mux committed
26
        print(env, "%.8gj",  (double) o->imag);
27
    } else {
mux's avatar
mux committed
28
        print(env, "(%.8g+%.8gj)", (double) o->real, (double) o->imag);
29
30
31
    }
}

32
STATIC mp_obj_t complex_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
33
34
    // TODO check n_kw == 0

35
36
37
38
39
    switch (n_args) {
        case 0:
            return mp_obj_new_complex(0, 0);

        case 1:
40
41
42
43
44
45
46
            if (MP_OBJ_IS_STR(args[0])) {
                // a string, parse it
                uint l;
                const char *s = mp_obj_str_get_data(args[0], &l);
                return mp_parse_num_decimal(s, l, true, true);
            } else if (MP_OBJ_IS_TYPE(args[0], &mp_type_complex)) {
                // a complex, just return it
47
48
                return args[0];
            } else {
49
                // something else, try to cast it to a complex
50
51
52
                return mp_obj_new_complex(mp_obj_get_float(args[0]), 0);
            }

53
        case 2: {
54
            mp_float_t real, imag;
55
            if (MP_OBJ_IS_TYPE(args[0], &mp_type_complex)) {
56
                mp_obj_complex_get(args[0], &real, &imag);
57
            } else {
58
                real = mp_obj_get_float(args[0]);
59
60
                imag = 0;
            }
61
            if (MP_OBJ_IS_TYPE(args[1], &mp_type_complex)) {
62
                mp_float_t real2, imag2;
63
                mp_obj_complex_get(args[1], &real2, &imag2);
64
65
66
                real -= imag2;
                imag += real2;
            } else {
67
                imag += mp_obj_get_float(args[1]);
68
69
70
71
72
            }
            return mp_obj_new_complex(real, imag);
        }

        default:
73
            nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "complex takes at most 2 arguments, %d given", n_args));
74
75
76
    }
}

77
STATIC mp_obj_t complex_unary_op(int op, mp_obj_t o_in) {
78
79
    mp_obj_complex_t *o = o_in;
    switch (op) {
80
        case RT_UNARY_OP_BOOL: return MP_BOOL(o->real != 0 || o->imag != 0);
81
82
83
84
85
86
        case RT_UNARY_OP_POSITIVE: return o_in;
        case RT_UNARY_OP_NEGATIVE: return mp_obj_new_complex(-o->real, -o->imag);
        default: return MP_OBJ_NULL; // op not supported
    }
}

87
STATIC mp_obj_t complex_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
88
89
90
91
    mp_obj_complex_t *lhs = lhs_in;
    return mp_obj_complex_binary_op(op, lhs->real, lhs->imag, rhs_in);
}

92
const mp_obj_type_t mp_type_complex = {
93
    { &mp_type_type },
94
    .name = MP_QSTR_complex,
95
96
97
98
    .print = complex_print,
    .make_new = complex_make_new,
    .unary_op = complex_unary_op,
    .binary_op = complex_binary_op,
99
100
101
102
};

mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag) {
    mp_obj_complex_t *o = m_new_obj(mp_obj_complex_t);
103
    o->base.type = &mp_type_complex;
104
105
106
107
108
109
    o->real = real;
    o->imag = imag;
    return o;
}

void mp_obj_complex_get(mp_obj_t self_in, mp_float_t *real, mp_float_t *imag) {
110
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_complex));
111
112
113
114
115
116
117
118
    mp_obj_complex_t *self = self_in;
    *real = self->real;
    *imag = self->imag;
}

mp_obj_t mp_obj_complex_binary_op(int op, mp_float_t lhs_real, mp_float_t lhs_imag, mp_obj_t rhs_in) {
    mp_float_t rhs_real, rhs_imag;
    mp_obj_get_complex(rhs_in, &rhs_real, &rhs_imag); // can be any type, this function will convert to float (if possible)
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
148
149
150
151
    switch (op) {
        case RT_BINARY_OP_ADD:
        case RT_BINARY_OP_INPLACE_ADD:
            lhs_real += rhs_real;
            lhs_imag += rhs_imag;
            break;
        case RT_BINARY_OP_SUBTRACT:
        case RT_BINARY_OP_INPLACE_SUBTRACT:
            lhs_real -= rhs_real;
            lhs_imag -= rhs_imag;
            break;
        case RT_BINARY_OP_MULTIPLY:
        case RT_BINARY_OP_INPLACE_MULTIPLY:
        {
            mp_float_t real = lhs_real * rhs_real - lhs_imag * rhs_imag;
            lhs_imag = lhs_real * rhs_imag + lhs_imag * rhs_real;
            lhs_real = real;
            break;
        }
        /* TODO floor(?) the value
        case RT_BINARY_OP_FLOOR_DIVIDE:
        case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE: val = lhs_val / rhs_val; break;
        */
        /* TODO
        case RT_BINARY_OP_TRUE_DIVIDE:
        case RT_BINARY_OP_INPLACE_TRUE_DIVIDE: val = lhs_val / rhs_val; break;
        */
        return NULL; // op not supported
    }
    return mp_obj_new_complex(lhs_real, lhs_imag);
}

#endif