← Back to branch summary

~ubuntu-branches/ubuntu/karmic/python-scipy/karmic

« back to all changes in this revision

Viewing changes to Lib/special/ufunc_extras.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T. Chen (new)
  • Date: 2005-03-16 02:15:29 UTC
  • Revision ID: james.westby@ubuntu.com-20050316021529-xrjlowsejs0cijig
Tags: upstream-0.3.2
Import upstream version 0.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/special/ufunc_extras.c
 
1
#include "ufunc_extras.h"
 
2
 
 
3
extern void PyUFunc_f_ff_As_d_dd(char **args, int *dimensions, int *steps, void *func) {
 
4
        int i, is1=steps[0],os1=steps[1],os2=steps[2];
 
5
        char *ip1=args[0], *op1=args[1], *op2=args[2];
 
6
        int n=dimensions[0];
 
7
        double to1, to2;
 
8
        
 
9
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2) {
 
10
                ((IntFunc_d_dd *)func)((double)*(float *)ip1, &to1, &to2);
 
11
                *(float *)op1 = (float)to1;
 
12
                *(float *)op2 = (float)to2;
 
13
        }
 
14
}
 
15
 
 
16
extern void PyUFunc_d_dd(char **args, int *dimensions, int *steps, void *func) {
 
17
        int i, is1=steps[0],os1=steps[1],os2=steps[2];
 
18
        char *ip1=args[0], *op1=args[1], *op2=args[2];
 
19
        int n=dimensions[0];
 
20
        
 
21
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2) {
 
22
                ((IntFunc_d_dd *)func)(*(double *)ip1, (double *)op1, (double *)op2);
 
23
        }
 
24
}
 
25
 
 
26
extern void PyUFunc_F_FF_As_D_DD(char **args, int *dimensions, int *steps, void *func) {
 
27
        int i, is1=steps[0],os1=steps[1],os2=steps[2];
 
28
        char *ip1=args[0], *op1=args[1], *op2=args[2];
 
29
        int n=dimensions[0];
 
30
        Py_complex from1;
 
31
        Py_complex to1, to2;
 
32
        
 
33
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2) {
 
34
                from1.real = ((float *)ip1)[0]; from1.imag = ((float *)ip1)[1];
 
35
                ((IntFunc_D_DD *)func)(from1, &to1, &to2);
 
36
                ((float *)op1)[0] = (float)to1.real;
 
37
                ((float *)op1)[1] = (float)to1.imag;
 
38
                ((float *)op2)[0] = (float)to2.real;
 
39
                ((float *)op2)[1] = (float)to2.imag;
 
40
        }
 
41
}
 
42
 
 
43
extern void PyUFunc_D_DD(char **args, int *dimensions, int *steps, void *func) {
 
44
        int i, is1=steps[0],os1=steps[1],os2=steps[2];
 
45
        char *ip1=args[0], *op1=args[1], *op2=args[2];
 
46
        int n=dimensions[0];
 
47
        Py_complex from1, to1, to2;
 
48
        
 
49
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2) {
 
50
                from1.real = ((double *)ip1)[0]; 
 
51
                from1.imag = ((double *)ip1)[1];
 
52
                ((IntFunc_D_DD *)func)(from1, &to1, &to2);
 
53
                ((double *)op1)[0] = to1.real;
 
54
                ((double *)op1)[1] = to1.imag;
 
55
                ((double *)op2)[0] = to2.real;
 
56
                ((double *)op2)[1] = to2.imag;
 
57
        }
 
58
 
 
59
}
 
60
 
 
61
extern void PyUFunc_f_FF_As_d_DD(char **args, int *dimensions, int *steps, void *func) {
 
62
        int i, is1=steps[0],os1=steps[1],os2=steps[2];
 
63
        char *ip1=args[0], *op1=args[1], *op2=args[2];
 
64
        int n=dimensions[0];
 
65
        Py_complex to1, to2;
 
66
        
 
67
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2) {
 
68
                ((IntFunc_d_DD *)func)((double)*(float *)ip1, &to1, &to2);
 
69
                ((float *)op1)[0] = (float)to1.real;
 
70
                ((float *)op1)[1] = (float)to1.imag;
 
71
                ((float *)op2)[0] = (float)to2.real;
 
72
                ((float *)op2)[1] = (float)to2.imag;
 
73
        }
 
74
}
 
75
 
 
76
extern void PyUFunc_d_DD(char **args, int *dimensions, int *steps, void *func) {
 
77
        int i, is1=steps[0],os1=steps[1],os2=steps[2];
 
78
        char *ip1=args[0], *op1=args[1], *op2=args[2];
 
79
        int n=dimensions[0];
 
80
        Py_complex to1, to2;
 
81
        
 
82
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2) {
 
83
                ((IntFunc_d_DD *)func)(*(double *)ip1, &to1, &to2);
 
84
                ((double *)op1)[0] = to1.real;
 
85
                ((double *)op1)[1] = to1.imag;
 
86
                ((double *)op2)[0] = to2.real;
 
87
                ((double *)op2)[1] = to2.imag;
 
88
        }
 
89
 
 
90
}
 
91
 
 
92
 
 
93
 
 
94
extern void PyUFunc_f_ffff_As_d_dddd(char **args, int *dimensions, int *steps, void *func) {
 
95
        int i, is1=steps[0],os1=steps[1],os2=steps[2],os3=steps[3],os4=steps[4];
 
96
        char *ip1=args[0], *op1=args[1], *op2=args[2], *op3=args[3], *op4=args[4];
 
97
        int n=dimensions[0];
 
98
        double to1, to2, to3, to4;
 
99
        
 
100
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
101
                ((IntFunc_d_dddd *)func)((double)*(float *)ip1, &to1, &to2, &to3, &to4);
 
102
                *(float *)op1 = (float)to1;
 
103
                *(float *)op2 = (float)to2;
 
104
                *(float *)op3 = (float)to3;
 
105
                *(float *)op4 = (float)to4;
 
106
        }
 
107
}
 
108
 
 
109
 
 
110
extern void PyUFunc_d_dddd(char **args, int *dimensions, int *steps, void *func) {
 
111
        int i, is1=steps[0],os1=steps[1],os2=steps[2],os3=steps[3],os4=steps[4];
 
112
        char *ip1=args[0], *op1=args[1], *op2=args[2], *op3=args[3], *op4=args[4];
 
113
        int n=dimensions[0];
 
114
        
 
115
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
116
                ((IntFunc_d_dddd *)func)(*(double *)ip1, (double *)op1, (double *)op2, (double *)op3, (double *)op4);
 
117
        }
 
118
}
 
119
 
 
120
extern void PyUFunc_F_FFFF_As_D_DDDD(char **args, int *dimensions, int *steps, void *func) {
 
121
        int i, is1=steps[0],os1=steps[1],os2=steps[2],os3=steps[3],os4=steps[4];
 
122
        char *ip1=args[0], *op1=args[1], *op2=args[2], *op3=args[3], *op4=args[4];
 
123
        int n=dimensions[0];
 
124
        Py_complex from1;
 
125
        Py_complex to1, to2, to3, to4;
 
126
        
 
127
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
128
                from1.real = ((float *)ip1)[0]; from1.imag = ((float *)ip1)[1];
 
129
                ((IntFunc_D_DDDD *)func)(from1, &to1, &to2, &to3, &to4);
 
130
                ((float *)op1)[0] = (float)to1.real;
 
131
                ((float *)op1)[1] = (float)to1.imag;
 
132
                ((float *)op2)[0] = (float)to2.real;
 
133
                ((float *)op2)[1] = (float)to2.imag;
 
134
                ((float *)op3)[0] = (float)to3.real;
 
135
                ((float *)op3)[1] = (float)to3.imag;
 
136
                ((float *)op4)[0] = (float)to4.real;
 
137
                ((float *)op4)[1] = (float)to4.imag;
 
138
        }
 
139
}
 
140
 
 
141
extern void PyUFunc_f_ffff_As_D_DDDD(char **args, int *dimensions, int *steps, void *func) {
 
142
        int i, is1=steps[0],os1=steps[1],os2=steps[2],os3=steps[3],os4=steps[4];
 
143
        char *ip1=args[0], *op1=args[1], *op2=args[2], *op3=args[3], *op4=args[4];
 
144
        int n=dimensions[0];
 
145
        Py_complex from1;
 
146
        Py_complex to1, to2, to3, to4;
 
147
        
 
148
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
149
                from1.real = ((float *)ip1)[0]; from1.imag = 0.0;
 
150
                ((IntFunc_D_DDDD *)func)(from1, &to1, &to2, &to3, &to4);
 
151
                ((float *)op1)[0] = (float)to1.real;
 
152
                ((float *)op2)[0] = (float)to2.real;
 
153
                ((float *)op3)[0] = (float)to3.real;
 
154
                ((float *)op4)[0] = (float)to4.real;
 
155
        }
 
156
}
 
157
 
 
158
 
 
159
extern void PyUFunc_d_dddd_As_D_DDDD(char **args, int *dimensions, int *steps, void *func) {
 
160
        int i, is1=steps[0],os1=steps[1],os2=steps[2],os3=steps[3],os4=steps[4];
 
161
        char *ip1=args[0], *op1=args[1], *op2=args[2], *op3=args[3], *op4=args[4];
 
162
        int n=dimensions[0];
 
163
        Py_complex from1;
 
164
        Py_complex to1, to2, to3, to4;
 
165
        
 
166
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
167
                from1.real = ((double *)ip1)[0]; from1.imag = 0.0;
 
168
                ((IntFunc_D_DDDD *)func)(from1, &to1, &to2, &to3, &to4);
 
169
                ((double *)op1)[0] = (double)to1.real;
 
170
                ((double *)op2)[0] = (double)to2.real;
 
171
                ((double *)op3)[0] = (double)to3.real;
 
172
                ((double *)op4)[0] = (double)to4.real;
 
173
        }
 
174
}
 
175
 
 
176
extern void PyUFunc_D_DDDD(char **args, int *dimensions, int *steps, void *func) {
 
177
        int i, is1=steps[0],os1=steps[1],os2=steps[2],os3=steps[3],os4=steps[4];
 
178
        char *ip1=args[0], *op1=args[1], *op2=args[2], *op3=args[3], *op4=args[4];
 
179
        int n=dimensions[0];
 
180
        Py_complex from1;
 
181
        Py_complex to1, to2, to3, to4;
 
182
        
 
183
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
184
                from1.real = ((double *)ip1)[0]; from1.imag = ((double *)ip1)[1];
 
185
                ((IntFunc_D_DDDD *)func)(from1, &to1, &to2, &to3, &to4);
 
186
                ((double *)op1)[0] = (double)to1.real;
 
187
                ((double *)op1)[1] = (double)to1.imag;
 
188
                ((double *)op2)[0] = (double)to2.real;
 
189
                ((double *)op2)[1] = (double)to2.imag;
 
190
                ((double *)op3)[0] = (double)to3.real;
 
191
                ((double *)op3)[1] = (double)to3.imag;
 
192
                ((double *)op4)[0] = (double)to4.real;
 
193
                ((double *)op4)[1] = (double)to4.imag;
 
194
        }
 
195
}
 
196
 
 
197
 
 
198
extern void PyUFunc_f_FFFF_As_d_DDDD(char **args, int *dimensions, int *steps, void *func) {
 
199
        int i, is1=steps[0],os1=steps[1],os2=steps[2],os3=steps[3],os4=steps[4];
 
200
        char *ip1=args[0], *op1=args[1], *op2=args[2], *op3=args[3], *op4=args[4];
 
201
        int n=dimensions[0];
 
202
        Py_complex to1, to2, to3, to4;
 
203
        
 
204
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
205
                ((IntFunc_d_DDDD *)func)((double)(*((float *)ip1)), &to1, &to2, &to3, &to4);
 
206
                ((float *)op1)[0] = (float)to1.real;
 
207
                ((float *)op1)[1] = (float)to1.imag;
 
208
                ((float *)op2)[0] = (float)to2.real;
 
209
                ((float *)op2)[1] = (float)to2.imag;
 
210
                ((float *)op3)[0] = (float)to3.real;
 
211
                ((float *)op3)[1] = (float)to3.imag;
 
212
                ((float *)op4)[0] = (float)to4.real;
 
213
                ((float *)op4)[1] = (float)to4.imag;
 
214
        }
 
215
}
 
216
 
 
217
extern void PyUFunc_d_DDDD(char **args, int *dimensions, int *steps, void *func) {
 
218
        int i, is1=steps[0],os1=steps[1],os2=steps[2],os3=steps[3],os4=steps[4];
 
219
        char *ip1=args[0], *op1=args[1], *op2=args[2], *op3=args[3], *op4=args[4];
 
220
        int n=dimensions[0];
 
221
        Py_complex to1, to2, to3, to4;
 
222
        
 
223
        for(i=0; i<n; i++, ip1+=is1, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
224
                ((IntFunc_d_DDDD *)func)(*((double *)ip1), &to1, &to2, &to3, &to4);
 
225
                ((double *)op1)[0] = (double)to1.real;
 
226
                ((double *)op1)[1] = (double)to1.imag;
 
227
                ((double *)op2)[0] = (double)to2.real;
 
228
                ((double *)op2)[1] = (double)to2.imag;
 
229
                ((double *)op3)[0] = (double)to3.real;
 
230
                ((double *)op3)[1] = (double)to3.imag;
 
231
                ((double *)op4)[0] = (double)to4.real;
 
232
                ((double *)op4)[1] = (double)to4.imag;
 
233
        }
 
234
}
 
235
 
 
236
extern void PyUFunc_ff_ff_As_dd_dd(char **args, int *dimensions, int *steps, void *func) {
 
237
        int i, is1=steps[0],is2=steps[1],os1=steps[2],os2=steps[3];
 
238
        char *ip1=args[0], *ip2=args[1], *op1=args[2], *op2=args[3];
 
239
        int n=dimensions[0];
 
240
        double to1, to2;
 
241
        
 
242
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op1+=os1, op2+=os2) {
 
243
                ((IntFunc_dd_dd *)func)((double)*(float *)ip1, (double)*(float *)ip2, &to1, &to2);
 
244
                *(float *)op1 = (float)to1;
 
245
                *(float *)op2 = (float)to2;
 
246
        }
 
247
}
 
248
 
 
249
extern void PyUFunc_dd_dd(char **args, int *dimensions, int *steps, void *func) {
 
250
        int i, is1=steps[0],is2=steps[1],os1=steps[2],os2=steps[3];
 
251
        char *ip1=args[0], *ip2=args[1], *op1=args[2], *op2=args[3];
 
252
        int n=dimensions[0];
 
253
        
 
254
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op1+=os1, op2+=os2) {
 
255
                ((IntFunc_dd_dd *)func)(*(double *)ip1, *(double *)ip2, (double *)op1, (double *)op2);
 
256
        }
 
257
}
 
258
 
 
259
 
 
260
extern void PyUFunc_ff_ffff_As_dd_dddd(char **args, int *dimensions, int *steps, void *func) {
 
261
        int i, is1=steps[0],is2=steps[1],os1=steps[2],os2=steps[3],os3=steps[4],os4=steps[5];
 
262
        char *ip1=args[0], *ip2=args[1], *op1=args[2], *op2=args[3], *op3=args[4], *op4=args[5];
 
263
        int n=dimensions[0];
 
264
        double to1, to2, to3, to4;
 
265
        
 
266
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
267
                ((IntFunc_dd_dddd *)func)((double)*(float *)ip1, (double)*(float *)ip2, &to1, &to2, &to3, &to4);
 
268
                *(float *)op1 = (float)to1;
 
269
                *(float *)op2 = (float)to2;
 
270
                *(float *)op3 = (float)to3;
 
271
                *(float *)op4 = (float)to4;
 
272
        }
 
273
}
 
274
 
 
275
extern void PyUFunc_dd_dddd(char **args, int *dimensions, int *steps, void *func) {
 
276
        int i, is1=steps[0],is2=steps[1],os1=steps[2],os2=steps[3],os3=steps[4],os4=steps[5];
 
277
        char *ip1=args[0], *ip2=args[1], *op1=args[2], *op2=args[3], *op3=args[4], *op4=args[5];
 
278
        int n=dimensions[0];
 
279
        
 
280
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op1+=os1, op2+=os2, op3+=os3, op4+=os4) {
 
281
                ((IntFunc_dd_dddd *)func)(*(double *)ip1, *(double *)ip2, (double *)op1, (double *)op2, (double *)op3, (double *)op4);
 
282
        }
 
283
}
 
284
 
 
285
 
 
286
extern void PyUFunc_fff_f_As_ddd_d(char **args, int *dimensions, int *steps, void *func) {
 
287
        int i, is1=steps[0],is2=steps[1],is3=steps[2],os=steps[3];
 
288
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *op=args[3];
 
289
        int n=dimensions[0];
 
290
        
 
291
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, op+=os) {
 
292
                *(float *)op = (float)((DoubleFunc_ddd_d *)func)((double)*(float *)ip1, (double)*(float *)ip2, (double)*(float *)ip3);
 
293
        }
 
294
}
 
295
 
 
296
extern void PyUFunc_ddd_d(char **args, int *dimensions, int *steps, void *func) {
 
297
        int i, is1=steps[0],is2=steps[1],is3=steps[2],os=steps[3];
 
298
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *op=args[3];
 
299
        int n=dimensions[0];
 
300
        
 
301
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, op+=os) {
 
302
                *(double *)op = ((DoubleFunc_ddd_d *)func)(*(double *)ip1, *(double *)ip2, *(double *)ip3);
 
303
        }
 
304
}
 
305
 
 
306
extern void PyUFunc_fff_ff_As_ddd_dd(char **args, int *dimensions, int *steps, void *func) {
 
307
        int i, is1=steps[0],is2=steps[1],is3=steps[2],os1=steps[3],os2=steps[4];
 
308
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *op1=args[3], *op2=args[4];
 
309
        int n=dimensions[0];
 
310
        double to1, to2;
 
311
        
 
312
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, op1+=os1, op2+=os2) {
 
313
                ((IntFunc_ddd_dd *)func)((double)*(float *)ip1, (double)*(float *)ip2, (double)*(float *)ip3, &to1, &to2);
 
314
                *(float *)op1 = (float)to1;
 
315
                *(float *)op2 = (float)to2;
 
316
        }
 
317
}
 
318
 
 
319
extern void PyUFunc_ddd_dd(char **args, int *dimensions, int *steps, void *func) {
 
320
        int i, is1=steps[0],is2=steps[1],is3=steps[2],os1=steps[3],os2=steps[4];
 
321
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *op1=args[3], *op2=args[4];
 
322
        int n=dimensions[0];
 
323
        
 
324
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, op1+=os1, op2+=os2) {
 
325
          ((IntFunc_ddd_dd *)func)(*(double *)ip1, *(double *)ip2, *(double *)ip3, (double *)op1, (double *)op2);
 
326
        }
 
327
}
 
328
 
 
329
 
 
330
extern void PyUFunc_ff_f_As_id_d(char **args, int *dimensions, int *steps, void *func) {
 
331
        int i, is1=steps[0],is2=steps[1],os=steps[2];
 
332
        char *ip1=args[0], *ip2=args[1], *op=args[2];
 
333
        int n=dimensions[0];
 
334
 
 
335
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op+=os) {
 
336
                *(float *)op = (float)((DoubleFunc_id_d *)func)((int)*(float *)ip1, (double)*(float *)ip2);
 
337
        }
 
338
}
 
339
 
 
340
extern void PyUFunc_dd_d_As_id_d(char **args, int *dimensions, int *steps, void *func) {
 
341
        int i, is1=steps[0],is2=steps[1],os=steps[2];
 
342
        char *ip1=args[0], *ip2=args[1], *op=args[2];
 
343
        int n=dimensions[0];
 
344
 
 
345
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op+=os) {
 
346
                *(double *)op = ((DoubleFunc_id_d *)func)((int)*(double *)ip1, *(double *)ip2);
 
347
        }
 
348
}
 
349
 
 
350
 
 
351
extern void PyUFunc_ff_f_As_dD_D(char **args, int *dimensions, int *steps, void *func) {
 
352
        int i, is1=steps[0],is2=steps[1],os=steps[2];
 
353
        char *ip1=args[0], *ip2=args[1], *op=args[2];
 
354
        int n=dimensions[0];
 
355
        Py_complex from1;
 
356
        Py_complex to1;
 
357
 
 
358
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op+=os) {
 
359
                from1.real = *((float*)ip2); from1.imag = 0.0;
 
360
                to1 = ((CmplxFunc_dD_D *)func)((double)*(float *)ip1, from1);
 
361
                ((float *)op)[0] = (float)to1.real;
 
362
        }
 
363
}
 
364
 
 
365
extern void PyUFunc_dd_d_As_dD_D(char **args, int *dimensions, int *steps, void *func) {
 
366
        int i, is1=steps[0],is2=steps[1],os=steps[2];
 
367
        char *ip1=args[0], *ip2=args[1], *op=args[2];
 
368
        int n=dimensions[0];
 
369
        Py_complex from1;
 
370
        Py_complex to1;
 
371
 
 
372
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op+=os) {
 
373
                from1.real = *((double*)ip2); from1.imag = 0.0;
 
374
                to1 = ((CmplxFunc_dD_D *)func)(*(double *)ip1, from1);
 
375
                ((double *)op)[0] = to1.real;
 
376
        }
 
377
}
 
378
 
 
379
 
 
380
extern void PyUFunc_fF_F_As_dD_D(char **args, int *dimensions, int *steps, void *func) {
 
381
        int i, is1=steps[0],is2=steps[1],os=steps[2];
 
382
        char *ip1=args[0], *ip2=args[1], *op=args[2];
 
383
        int n=dimensions[0];
 
384
        Py_complex from1;
 
385
        Py_complex to1;
 
386
 
 
387
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op+=os) {
 
388
                from1.real = ((float*)ip2)[0]; from1.imag = ((float *)ip2)[1];
 
389
                to1 = ((CmplxFunc_dD_D *)func)((double)*(float *)ip1, from1);
 
390
                ((float *)op)[0] = (float)to1.real;
 
391
                ((float *)op)[1] = (float)to1.imag;
 
392
        }
 
393
}
 
394
 
 
395
extern void PyUFunc_dD_D(char **args, int *dimensions, int *steps, void *func) {
 
396
        int i, is1=steps[0],is2=steps[1],os=steps[2];
 
397
        char *ip1=args[0], *ip2=args[1], *op=args[2];
 
398
        int n=dimensions[0];
 
399
        Py_complex from1;
 
400
        Py_complex to1;
 
401
 
 
402
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, op+=os) {
 
403
                from1.real = ((double*)ip2)[0]; from1.imag = ((double *)ip2)[1];
 
404
                to1 = ((CmplxFunc_dD_D *)func)(*(double *)ip1, from1);
 
405
                ((double *)op)[0] = (double)to1.real;
 
406
                ((double *)op)[1] = (double)to1.imag;
 
407
        }
 
408
}
 
409
 
 
410
 
 
411
extern void PyUFunc_ffF_F_As_ddD_D(char **args, int *dimensions, int *steps, void *func) {
 
412
        int i, is1=steps[0],is2=steps[1],is3=steps[2],os=steps[3];
 
413
        char *ip1=args[0],*ip2=args[1],*ip3=args[2],*op=args[3];
 
414
        int n=dimensions[0];
 
415
        Py_complex from1;
 
416
        Py_complex to1;
 
417
 
 
418
        for(i=0; i<n; i++, ip1+=is1,ip2+=is2,ip3+=is3,op+=os) {
 
419
                from1.real = ((float*)ip3)[0]; from1.imag = ((float *)ip3)[1];
 
420
                to1 = ((CmplxFunc_ddD_D *)func)((double)*(float *)ip1, (double)*(float *)ip2, from1);
 
421
                ((float *)op)[0] = (float)to1.real;
 
422
                ((float *)op)[1] = (float)to1.imag;
 
423
        }
 
424
}
 
425
 
 
426
extern void PyUFunc_ddD_D(char **args, int *dimensions, int *steps, void *func) {
 
427
        int i, is1=steps[0],is2=steps[1],is3=steps[2],os=steps[3];
 
428
        char *ip1=args[0],*ip2=args[1],*ip3=args[2],*op=args[3];
 
429
        int n=dimensions[0];
 
430
        Py_complex from1;
 
431
        Py_complex to1;
 
432
 
 
433
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, op+=os) {
 
434
                from1.real = ((double*)ip3)[0]; from1.imag = ((double *)ip3)[1];
 
435
                to1 = ((CmplxFunc_ddD_D *)func)(*(double *)ip1, *(double *)ip2, from1);
 
436
                ((double *)op)[0] = (double)to1.real;
 
437
                ((double *)op)[1] = (double)to1.imag;
 
438
        }
 
439
}
 
440
 
 
441
 
 
442
extern void PyUFunc_fffF_F_As_dddD_D(char **args, int *dimensions, int *steps, void *func) {
 
443
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],os=steps[4];
 
444
        char *ip1=args[0],*ip2=args[1],*ip3=args[2],*ip4=args[3],*op=args[4];
 
445
        int n=dimensions[0];
 
446
        Py_complex from1;
 
447
        Py_complex to1;
 
448
 
 
449
        for(i=0; i<n; i++, ip1+=is1,ip2+=is2,ip3+=is3,ip4+=is4,op+=os) {
 
450
                from1.real = ((float*)ip4)[0]; from1.imag = ((float *)ip4)[1];
 
451
                to1 = ((CmplxFunc_dddD_D *)func)((double)*(float *)ip1, (double)*(float *)ip2, (double)*(float *)ip3, from1);
 
452
                ((float *)op)[0] = (float)to1.real;
 
453
                ((float *)op)[1] = (float)to1.imag;
 
454
        }
 
455
}
 
456
 
 
457
extern void PyUFunc_dddD_D(char **args, int *dimensions, int *steps, void *func) {
 
458
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],os=steps[4];
 
459
        char *ip1=args[0],*ip2=args[1],*ip3=args[2],*ip4=args[3],*op=args[4];
 
460
        int n=dimensions[0];
 
461
        Py_complex from1;
 
462
        Py_complex to1;
 
463
 
 
464
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, ip4+=is4, op+=os) {
 
465
                from1.real = ((double*)ip4)[0]; from1.imag = ((double *)ip4)[1];
 
466
                to1 = ((CmplxFunc_dddD_D *)func)(*(double *)ip1, *(double *)ip2, *(double *)ip3, from1);
 
467
                ((double *)op)[0] = (double)to1.real;
 
468
                ((double *)op)[1] = (double)to1.imag;
 
469
        }
 
470
}
 
471
 
 
472
 
 
473
extern void PyUFunc_fff_f_As_iid_d(char **args, int *dimensions, int *steps, void *func) {
 
474
        int i, is1=steps[0],is2=steps[1],is3=steps[2],os=steps[3];
 
475
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *op=args[3];
 
476
        int n=dimensions[0];
 
477
        
 
478
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, op+=os) {
 
479
                *(float *)op = (float)((DoubleFunc_iid_d *)func)((int)*(float *)ip1, (int)*(float *)ip2, (double)*(float *)ip3);
 
480
        }
 
481
}
 
482
 
 
483
extern void PyUFunc_ddd_d_As_iid_d(char **args, int *dimensions, int *steps, void *func) {
 
484
        int i, is1=steps[0],is2=steps[1],is3=steps[2],os=steps[3];
 
485
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *op=args[3];
 
486
        int n=dimensions[0];
 
487
        
 
488
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, op+=os) {
 
489
                *(double *)op = ((DoubleFunc_iid_d *)func)((int)*(double *)ip1, (int)*(double *)ip2, *(double *)ip3);
 
490
        }
 
491
}
 
492
 
 
493
extern void PyUFunc_ffff_f_As_dddd_d(char **args, int *dimensions, int *steps, void *func) {
 
494
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],os=steps[4];
 
495
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3], *op=args[4];
 
496
        int n=dimensions[0];
 
497
        
 
498
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, ip4+=is4, op+=os) {
 
499
                *(float *)op = (float)((DoubleFunc_dddd_d *)func)((double)*(float *)ip1, (double)*(float *)ip2, (double)*(float *)ip3, (double)*(float *)ip4);
 
500
        }
 
501
}
 
502
 
 
503
extern void PyUFunc_dddd_d(char **args, int *dimensions, int *steps, void *func) {
 
504
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],os=steps[4];
 
505
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3],*op=args[4];
 
506
        int n=dimensions[0];
 
507
        
 
508
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, ip4+=is4, op+=os) {
 
509
                *(double *)op = ((DoubleFunc_dddd_d *)func)(*(double *)ip1, *(double *)ip2, *(double *)ip3, *(double *)ip4);
 
510
        }
 
511
}
 
512
 
 
513
extern void PyUFunc_ffff_ff_As_dddd_dd(char **args, int *dimensions, int *steps, void *func) {
 
514
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],os1=steps[4],os2=steps[5];
 
515
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3], *op1=args[4], *op2=args[5];
 
516
        int n=dimensions[0];
 
517
        double to1;
 
518
        
 
519
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, ip4+=is4, op1+=os1, op2+=os2) {
 
520
                *(float *)op1 = (float)((DoubleFunc_dddd_dd *)func)((double)*(float *)ip1, (double)*(float *)ip2, (double)*(float *)ip3, (double)*(float *)ip4, &to1);
 
521
                *(float *)op2 = (float)to1;
 
522
        }
 
523
}
 
524
 
 
525
extern void PyUFunc_dddd_dd(char **args, int *dimensions, int *steps, void *func) {
 
526
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],os1=steps[4],os2=steps[5];
 
527
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3], *op1=args[4], *op2=args[5];
 
528
        int n=dimensions[0];
 
529
        
 
530
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, ip4+=is4, op1+=os1, op2+=os2) {
 
531
                *(double *)op1 = ((DoubleFunc_dddd_dd *)func)(*(double *)ip1, *(double *)ip2, *(double *)ip3, *(double *)ip4, (double *)op2);
 
532
        }
 
533
}
 
534
 
 
535
extern void PyUFunc_fffff_ff_As_ddddd_dd(char **args, int *dimensions, int *steps, void *func) {
 
536
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],is5=steps[4], os1=steps[5],os2=steps[6];
 
537
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3], *ip5=args[4], *op1=args[5], *op2=args[6];
 
538
        int n=dimensions[0];
 
539
        double to1, to2;
 
540
        
 
541
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, ip4+=is4, ip5+=is5, op1+=os1, op2+=os2) {
 
542
                ((IntFunc_ddddd_dd *)func)((double)*(float *)ip1, (double)*(float *)ip2, (double)*(float *)ip3, (double)*(float *)ip4, (double)*(float *)ip5, &to1, &to2);
 
543
                *(float *)op1 = (float)to1;
 
544
                *(float *)op2 = (float)to2;
 
545
        }
 
546
}
 
547
 
 
548
extern void PyUFunc_ddddd_dd(char **args, int *dimensions, int *steps, void *func) {
 
549
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],is5=steps[4],os1=steps[5],os2=steps[6];
 
550
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3], *ip5=args[4], *op1=args[5], *op2=args[6];
 
551
        int n=dimensions[0];
 
552
        
 
553
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, ip4+=is4, ip5+=is5, op1+=os1, op2+=os2) {
 
554
                ((IntFunc_ddddd_dd *)func)(*(double *)ip1, *(double *)ip2, *(double *)ip3, *(double *)ip4, *(double *)ip5, (double *)op1, (double *)op2);
 
555
        }
 
556
}
 
557
 
 
558
 
 
559
extern void PyUFunc_ffff_ff_As_dddi_dd(char **args, int *dimensions, int *steps, void *func) {
 
560
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],os1=steps[4],os2=steps[5];
 
561
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3], *op1=args[4], *op2=args[5];
 
562
        int n=dimensions[0];
 
563
        double to1;
 
564
        
 
565
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, ip4+=is4, op1+=os1, op2+=os2) {
 
566
                *(float *)op1 = (float)((DoubleFunc_dddi_dd *)func)((double)*(float *)ip1, (double)*(float *)ip2, (double)*(float *)ip3, (int)*(float *)ip4, &to1);
 
567
                *(float *)op2 = (float)to1;
 
568
        }
 
569
}
 
570
 
 
571
extern void PyUFunc_dddd_dd_As_dddi_dd(char **args, int *dimensions, int *steps, void *func) {
 
572
        int i, is1=steps[0],is2=steps[1],is3=steps[2],is4=steps[3],os1=steps[4],os2=steps[5];
 
573
        char *ip1=args[0], *ip2=args[1], *ip3=args[2], *ip4=args[3], *op1=args[4], *op2=args[5];
 
574
        int n=dimensions[0];
 
575
        
 
576
        for(i=0; i<n; i++, ip1+=is1, ip2+=is2, ip3+=is3, ip4+=is4, op1+=os1, op2+=os2) {
 
577
                *(double *)op1 = ((DoubleFunc_dddi_dd *)func)(*(double *)ip1, *(double *)ip2, *(double *)ip3, (int)*(double *)ip4, (double *)op2);
 
578
        }
 
579
}
 
580
 
 
581
 
 
582
 
 
583
 
 
584
 
 
585
 
 
586
 
 
587
 
 
588
 
 
589
 
 
590
 
 
591
 
 
592