objcomplex.c 4.48 KB
Newer Older
1
2
3
4
5
6
7
8
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>

#include "nlr.h"
#include "misc.h"
#include "mpconfig.h"
9
#include "qstr.h"
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include "obj.h"
#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);

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

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

36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
    switch (n_args) {
        case 0:
            return mp_obj_new_complex(0, 0);

        case 1:
            // TODO allow string as first arg and parse it
            if (MP_OBJ_IS_TYPE(args[0], &complex_type)) {
                return args[0];
            } else {
                return mp_obj_new_complex(mp_obj_get_float(args[0]), 0);
            }

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

        default:
            nlr_jump(mp_obj_new_exception_msg_1_arg(MP_QSTR_TypeError, "complex takes at most 2 arguments, %d given", (void*)(machine_int_t)n_args));
    }
}

73
STATIC mp_obj_t complex_unary_op(int op, mp_obj_t o_in) {
74
75
    mp_obj_complex_t *o = o_in;
    switch (op) {
76
        case RT_UNARY_OP_BOOL: return MP_BOOL(o->real != 0 || o->imag != 0);
77
78
79
80
81
82
        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
    }
}

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

const mp_obj_type_t complex_type = {
    { &mp_const_type },
    "complex",
91
92
93
94
    .print = complex_print,
    .make_new = complex_make_new,
    .unary_op = complex_unary_op,
    .binary_op = complex_binary_op,
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
};

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);
    o->base.type = &complex_type;
    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) {
    assert(MP_OBJ_IS_TYPE(self_in, &complex_type));
    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)
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
    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