cython

1
# tag: cpp
2

3
import math
4
cimport libcpp.complex as cppcomplex
5
from libcpp.complex cimport complex as complex_class
6

7
def double_complex(complex_class[double] a):
8
    """
9
    >>> double_complex(1 + 2j)
10
    (1+2j)
11
    >>> double_complex(1.5 + 2.5j)
12
    (1.5+2.5j)
13
    """
14
    return a
15

16
def double_int(complex_class[int] a):
17
    """
18
    >>> double_int(1 + 2j)
19
    (1+2j)
20
    >>> double_int(1.5 + 2.5j)
21
    (1+2j)
22
    """
23
    return a
24

25
def double_addition_with_scalar(complex_class[double] a, double b):
26
    """
27
    >>> double_addition_with_scalar(1 + 1j, 1) + 1
28
    (3+1j)
29
    >>> 1 + double_addition_with_scalar(1 + 2j, -1)
30
    (1+2j)
31
    >>> 1j + double_addition_with_scalar(1 + 2j, 7)
32
    (8+3j)
33
    >>> double_addition_with_scalar(1 + 2j, 7) - 1j
34
    (8+1j)
35
    >>> double_addition_with_scalar(1.5 + 2.5j, -1) + 0
36
    (0.5+2.5j)
37
    >>> -0 + double_addition_with_scalar(1.5 + 2.5j, -1)
38
    (0.5+2.5j)
39
    """
40
    cdef complex_class[double] c = a + b
41
    cdef complex_class[double] d = b + a
42
    return b + a
43

44
def double_inplace_addition_with_scalar(complex_class[double] a, double b):
45
    """
46
    >>> double_inplace_addition_with_scalar(1 + 1j, 1)
47
    (2+1j)
48
    """
49
    a += b
50
    return a
51

52
def double_inplace_substraction_with_scalar(complex_class[double] a, double b):
53
    """
54
    >>> double_inplace_substraction_with_scalar(1 + 1j, 2)
55
    (-1+1j)
56
    """
57
    a -= b
58
    return a
59

60
def double_inplace_multiplication_with_scalar(complex_class[double] a, double b):
61
    """
62
    >>> double_inplace_multiplication_with_scalar(1 + 1j, 2)
63
    (2+2j)
64
    """
65
    a *= b
66
    return a
67

68
def double_inplace_division_with_scalar(complex_class[double] a, double b):
69
    """
70
    >>> double_inplace_division_with_scalar(3 + 3j, 2)
71
    (1.5+1.5j)
72
    """
73
    a /= b
74
    return a
75

76
def double_unary_negation(complex_class[double] a):
77
    """
78
    >>> double_unary_negation(2 + 2j)
79
    (-2-2j)
80
    """
81
    return -a
82

83
def double_unary_positive(complex_class[double] a):
84
    """
85
    >>> double_unary_positive(2 + 2j)
86
    (2+2j)
87
    """
88
    return +a
89

90
def double_real_imaginary_accessors(complex_class[double] a, double real, double imag):
91
    """
92
    >>> a = double_real_imaginary_accessors(2.1 + 2j, 7, 4)
93
    >>> a.real
94
    9.1
95
    >>> a.imag
96
    6.0
97
    """
98
    # checks the accessors
99
    cdef double b = a.real()
100
    a.real(b + real)
101

102
    cdef double c = a.imag()
103
    a.imag(c + imag)
104

105
    return a
106

107
def double_double_comparison_equal(complex_class[double] a, complex_class[double] b):
108
    """
109
    >>> double_double_comparison_equal(2.1 + 2j, 7)
110
    False
111
    >>> double_double_comparison_equal(2.1 + 2j, (1j + 1) * 2 + 0.1)
112
    True
113
    """
114
    return a == b
115

116
def double_scalar_double_comparison_equal(complex_class[double] a, double b):
117
    """
118
    >>> double_double_comparison_equal(2.1 + 2j, 7)
119
    False
120
    >>> double_double_comparison_equal(7 + 0j, 7)
121
    True
122
    """
123
    return a == b
124

125
def scalar_double_double_comparison_equal(complex_class[double] a, double b):
126
    """
127
    >>> double_double_comparison_equal(2.1 + 2j, 7)
128
    False
129
    >>> double_double_comparison_equal(7 + 0j, 7)
130
    True
131
    """
132
    return b == a
133

134
def double_real_imaginary_accessors_free_function(complex_class[double] a, bint real_part):
135
    """
136
    >>> double_real_imaginary_accessors_free_function(2.1 + 2.7j, True)
137
    2.1
138
    >>> double_real_imaginary_accessors_free_function(2.1 + 2.7j, False)
139
    2.7
140
    """
141

142
    cdef double e = cppcomplex.real(a)
143
    cdef double f = cppcomplex.imag(a)
144
    if real_part:
145
        return e
146
    return f
147

148
def scalar_double_real_imaginary_accessors_free_function(double a, bint real_part):
149
    """
150
    >>> scalar_double_real_imaginary_accessors_free_function(2.1, True)
151
    2.1
152
    >>> scalar_double_real_imaginary_accessors_free_function(2.1, False)
153
    0.0
154
    """
155
    cdef double e = cppcomplex.real(a)
156
    cdef double f = cppcomplex.imag(a)
157
    if real_part:
158
        return e
159
    return f
160

161
def scalar_long_double_real_imaginary_accessors_free_function(long double a, bint real_part):
162
    """
163
    >>> scalar_long_double_real_imaginary_accessors_free_function(2.1, True)
164
    2.1
165
    >>> scalar_long_double_real_imaginary_accessors_free_function(2.1, False)
166
    0.0
167
    """
168
    cdef double e = cppcomplex.real(a)
169
    cdef double f = cppcomplex.imag(a)
170
    if real_part:
171
        return e
172
    return f
173

174
def double_abs(complex_class[double] a):
175
    """
176
    >>> double_abs(5)
177
    5.0
178
    >>> double_abs(5j)
179
    5.0
180
    >>> double_abs(2 + 5j) == math.sqrt(29)
181
    True
182
    """
183
    return cppcomplex.abs(a)
184

185
def double_norm(complex_class[double] a):
186
    """
187
    >>> double_norm(5)
188
    25.0
189
    >>> double_norm(5j)
190
    25.0
191
    >>> abs(double_norm(2 + 5j) - double_abs(2 + 5j)*double_abs(2 + 5j)) < 1e-13
192
    True
193
    """
194
    return cppcomplex.norm(a)
195

196
def scalar_double_norm(double a):
197
    """
198
    >>> scalar_double_norm(5)
199
    25.0
200
    """
201
    return cppcomplex.norm(a)
202

203
def scalar_float_norm(float a):
204
    """
205
    >>> scalar_float_norm(5)
206
    25.0
207
    """
208
    return cppcomplex.norm(a)
209

210
def double_conjugate(complex_class[double] a):
211
    """
212
    >>> double_conjugate(5)
213
    (5-0j)
214
    >>> double_conjugate(5j)
215
    -5j
216
    >>> double_conjugate(1 + 2j)
217
    (1-2j)
218
    """
219
    return cppcomplex.conj(a)
220

221
def scalar_double_conjugate(double a):
222
    """
223
    >>> a = scalar_double_conjugate(5)
224
    >>> a.real
225
    5.0
226
    >>> # abs to prevent -0 or 0 issue
227
    >>> abs(a.imag)
228
    0.0
229
    """
230
    # always return complex
231
    return cppcomplex.conj(a)
232

233
def double_proj(complex_class[double] a):
234
    """
235
    >>> double_proj(5 + 4j)
236
    (5+4j)
237
    >>> double_proj(-float("infinity") + 4j)
238
    (inf+0j)
239
    >>> double_proj(5 - float("infinity")*1j)
240
    (inf-0j)
241
    """
242
    return cppcomplex.proj(a)
243

244
def double_arg(complex_class[double] a):
245
    """
246
    >>> a = math.pi / 4
247
    >>> round(a, 10)
248
    0.7853981634
249
    >>> round(double_arg(math.cos(a) + math.sin(a)*1j), 10)
250
    0.7853981634
251
    """
252
    return cppcomplex.arg(a)
253

254
def scalar_double_arg(double a):
255
    """
256
    >>> scalar_double_arg(13)
257
    0.0
258
    >>> round(scalar_double_arg(-1), 10)
259
    3.1415926536
260
    """
261
    return cppcomplex.arg(a)
262

263
def double_polar(double r, double theta):
264
    """
265
    >>> c1 = double_polar(3, math.pi / 2)
266
    >>> c1.imag
267
    3.0
268
    >>> abs(c1.real) < 1e-10
269
    True
270
    >>> c2 = double_polar(4, math.pi)
271
    >>> c2.real
272
    -4.0
273
    >>> abs(c2.imag) < 1e-10
274
    True
275
    """
276
    return cppcomplex.polar(r, theta)
277

278
def double_polar_scalar(double r):
279
    """
280
    >>> c1 = double_polar_scalar(3)
281
    >>> c1.real
282
    3.0
283
    >>> c1.imag
284
    0.0
285
    >>> c2 = double_polar_scalar(0)
286
    >>> c2.real
287
    0.0
288
    >>> c2.imag
289
    0.0
290
    """
291
    return cppcomplex.polar(r)
292

293
def double_pow(complex_class[double] a, complex_class[double] b):
294
    """
295
    >>> double_pow(3, 3)
296
    (27+0j)
297
    >>> a = double_pow(1j, 1j)
298
    >>> round(a.real, 5)
299
    0.20788
300
    >>> round(a.imag, 2)
301
    0.0
302
    """
303
    return cppcomplex.pow(a, b)
304

305
def double_scalar_double_pow(complex_class[double] a, double b):
306
    """
307
    >>> double_pow(3, 3)
308
    (27+0j)
309
    >>> a = double_pow(1+2j, 2)
310
    >>> round(a.real, 2)
311
    -3.0
312
    >>> round(a.imag, 2)
313
    4.0
314
    """
315
    return cppcomplex.pow(a, b)
316

317
def scalar_double_double_pow(double a, complex_class[double] b):
318
    """
319
    >>> scalar_double_double_pow(3, 3)
320
    (27+0j)
321
    >>> a = scalar_double_double_pow(2, 2j)
322
    >>> round(a.real, 2)
323
    0.18
324
    >>> round(a.imag, 2)
325
    0.98
326
    """
327
    return cppcomplex.pow(a, b)
328

329
def double_sin(complex_class[double] a):
330
    """
331
    >>> round(abs(double_sin(math.pi)), 2)
332
    0.0
333
    >>> round(double_sin(-math.pi/4).real, 3)
334
    -0.707
335
    >>> round(abs(double_sin(-math.pi/4).imag), 3)
336
    0.0
337
    >>> round(abs(double_sin(4j).real), 3)
338
    0.0
339
    >>> round(abs(double_sin(4j).imag - math.sinh(4)), 3)
340
    0.0
341
    """
342
    return cppcomplex.sin(a)
343

344
def double_cos(complex_class[double] a):
345
    """
346
    >>> round(double_cos(math.pi).real, 2)
347
    -1.0
348
    >>> round(abs(double_cos(math.pi).imag), 2)
349
    0.0
350
    >>> round(double_cos(-math.pi/4 + math.pi).real, 3)
351
    -0.707
352
    >>> round(abs(double_cos(-math.pi/4).imag), 3)
353
    0.0
354
    >>> round(abs(double_cos(4j).imag), 3)
355
    0.0
356
    >>> round(abs(double_cos(5j).real - math.cosh(5)), 3)
357
    0.0
358
    """
359
    return cppcomplex.cos(a)
360