|
3
|
1 // Helper functions for matrix classes. -*- C++ -*- |
|
|
2 /* |
|
|
3 |
|
461
|
4 Copyright (C) 1992, 1993, 1994 John W. Eaton |
|
3
|
5 |
|
|
6 This file is part of Octave. |
|
|
7 |
|
|
8 Octave is free software; you can redistribute it and/or modify it |
|
|
9 under the terms of the GNU General Public License as published by the |
|
|
10 Free Software Foundation; either version 2, or (at your option) any |
|
|
11 later version. |
|
|
12 |
|
|
13 Octave is distributed in the hope that it will be useful, but WITHOUT |
|
|
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
16 for more details. |
|
|
17 |
|
|
18 You should have received a copy of the GNU General Public License |
|
|
19 along with Octave; see the file COPYING. If not, write to the Free |
|
|
20 Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. |
|
|
21 |
|
|
22 */ |
|
|
23 |
|
461
|
24 #include <Complex.h> |
|
|
25 |
|
3
|
26 // But first, some helper functions... |
|
|
27 |
|
|
28 static inline double * |
|
238
|
29 add (const double *d, int len, double s) |
|
3
|
30 { |
|
|
31 double *result = 0; |
|
|
32 if (len > 0) |
|
|
33 { |
|
|
34 result = new double [len]; |
|
|
35 for (int i = 0; i < len; i++) |
|
|
36 result[i] = d[i] + s; |
|
|
37 } |
|
|
38 return result; |
|
|
39 } |
|
|
40 |
|
|
41 static inline double * |
|
238
|
42 subtract (const double *d, int len, double s) |
|
3
|
43 { |
|
|
44 double *result = 0; |
|
|
45 if (len > 0) |
|
|
46 { |
|
|
47 result = new double [len]; |
|
|
48 for (int i = 0; i < len; i++) |
|
|
49 result[i] = d[i] - s; |
|
|
50 } |
|
|
51 return result; |
|
|
52 } |
|
|
53 |
|
|
54 static inline double * |
|
238
|
55 subtract (double s, const double *d, int len) |
|
3
|
56 { |
|
|
57 double *result = 0; |
|
|
58 if (len > 0) |
|
|
59 { |
|
|
60 result = new double [len]; |
|
|
61 for (int i = 0; i < len; i++) |
|
|
62 result[i] = s - d[i]; |
|
|
63 } |
|
|
64 return result; |
|
|
65 } |
|
|
66 |
|
|
67 static inline double * |
|
238
|
68 multiply (const double *d, int len, double s) |
|
3
|
69 { |
|
|
70 double *result = 0; |
|
|
71 if (len > 0) |
|
|
72 { |
|
|
73 result = new double [len]; |
|
|
74 for (int i = 0; i < len; i++) |
|
|
75 result[i] = d[i] * s; |
|
|
76 } |
|
|
77 return result; |
|
|
78 } |
|
|
79 |
|
|
80 static inline double * |
|
238
|
81 divide (const double *d, int len, double s) |
|
3
|
82 { |
|
|
83 double *result = 0; |
|
|
84 if (len > 0) |
|
|
85 { |
|
|
86 result = new double [len]; |
|
|
87 for (int i = 0; i < len; i++) |
|
|
88 result[i] = d[i] / s; |
|
|
89 } |
|
|
90 return result; |
|
|
91 } |
|
|
92 |
|
|
93 static inline double * |
|
238
|
94 divide (double s, const double *d, int len) |
|
3
|
95 { |
|
|
96 double *result = 0; |
|
|
97 if (len > 0) |
|
|
98 { |
|
|
99 result = new double [len]; |
|
|
100 for (int i = 0; i < len; i++) |
|
|
101 result[i] = s / d[i]; |
|
|
102 } |
|
|
103 return result; |
|
|
104 } |
|
|
105 |
|
|
106 static inline double * |
|
238
|
107 add (const double *x, const double *y, int len) |
|
3
|
108 { |
|
|
109 double *result = 0; |
|
|
110 if (len > 0) |
|
|
111 { |
|
|
112 result = new double [len]; |
|
|
113 for (int i = 0; i < len; i++) |
|
|
114 result[i] = x[i] + y[i]; |
|
|
115 } |
|
|
116 return result; |
|
|
117 } |
|
|
118 |
|
|
119 static inline double * |
|
238
|
120 subtract (const double *x, const double *y, int len) |
|
3
|
121 { |
|
|
122 double *result = 0; |
|
|
123 if (len > 0) |
|
|
124 { |
|
|
125 result = new double [len]; |
|
|
126 for (int i = 0; i < len; i++) |
|
|
127 result[i] = x[i] - y[i]; |
|
|
128 } |
|
|
129 return result; |
|
|
130 } |
|
|
131 |
|
|
132 static inline double * |
|
238
|
133 multiply (const double *x, const double *y, int len) |
|
3
|
134 { |
|
|
135 double *result = 0; |
|
|
136 if (len > 0) |
|
|
137 { |
|
|
138 result = new double [len]; |
|
|
139 for (int i = 0; i < len; i++) |
|
|
140 result[i] = x[i] * y[i]; |
|
|
141 } |
|
|
142 return result; |
|
|
143 } |
|
|
144 |
|
|
145 static inline double * |
|
238
|
146 divide (const double *x, const double *y, int len) |
|
3
|
147 { |
|
|
148 double *result = 0; |
|
|
149 if (len > 0) |
|
|
150 { |
|
|
151 result = new double [len]; |
|
|
152 for (int i = 0; i < len; i++) |
|
|
153 result[i] = x[i] / y[i]; |
|
|
154 } |
|
|
155 return result; |
|
|
156 } |
|
|
157 |
|
|
158 static inline double * |
|
238
|
159 add2 (double *x, const double *y, int len) |
|
3
|
160 { |
|
|
161 for (int i = 0; i < len; i++) |
|
|
162 x[i] += y[i]; |
|
|
163 return x; |
|
|
164 } |
|
|
165 |
|
|
166 static inline double * |
|
238
|
167 subtract2 (double *x, const double *y, int len) |
|
3
|
168 { |
|
|
169 for (int i = 0; i < len; i++) |
|
|
170 x[i] -= y[i]; |
|
|
171 return x; |
|
|
172 } |
|
|
173 |
|
|
174 static inline double * |
|
238
|
175 negate (const double *d, int len) |
|
3
|
176 { |
|
|
177 double *result = 0; |
|
|
178 if (len > 0) |
|
|
179 { |
|
|
180 result = new double [len]; |
|
|
181 for (int i = 0; i < len; i++) |
|
|
182 result[i] = -d[i]; |
|
|
183 } |
|
|
184 return result; |
|
|
185 } |
|
|
186 |
|
|
187 static inline void |
|
|
188 copy (double *d, int len, double s) |
|
|
189 { |
|
|
190 for (int i = 0; i < len; i++) |
|
|
191 d[i] = s; |
|
|
192 } |
|
|
193 |
|
|
194 static inline void |
|
238
|
195 copy (double *x, const double *y, int len) |
|
3
|
196 { |
|
|
197 for (int i = 0; i < len; i++) |
|
|
198 x[i] = y[i]; |
|
|
199 } |
|
|
200 |
|
|
201 static inline double * |
|
238
|
202 dup (const double *x, int len) |
|
3
|
203 { |
|
238
|
204 double *retval = 0; |
|
3
|
205 if (len > 0) |
|
|
206 { |
|
|
207 retval = new double [len]; |
|
|
208 for (int i = 0; i < len; i++) |
|
|
209 retval[i] = x[i]; |
|
|
210 } |
|
|
211 return retval; |
|
|
212 } |
|
|
213 |
|
|
214 static inline int |
|
238
|
215 equal (const double *x, const double *y, int len) |
|
3
|
216 { |
|
|
217 for (int i = 0; i < len; i++) |
|
|
218 if (x[i] != y[i]) |
|
|
219 return 0; |
|
|
220 return 1; |
|
|
221 } |
|
|
222 |
|
|
223 // And some for Complex too... |
|
|
224 |
|
|
225 static inline Complex * |
|
238
|
226 add (const Complex *d, int len, Complex s) |
|
3
|
227 { |
|
|
228 Complex *result = 0; |
|
|
229 if (len > 0) |
|
|
230 { |
|
|
231 result = new Complex [len]; |
|
|
232 for (int i = 0; i < len; i++) |
|
|
233 result[i] = d[i] + s; |
|
|
234 } |
|
|
235 return result; |
|
|
236 } |
|
|
237 |
|
|
238 static inline Complex * |
|
238
|
239 add (Complex s, const Complex *d, int len) |
|
3
|
240 { |
|
|
241 Complex *result = 0; |
|
|
242 if (len > 0) |
|
|
243 { |
|
|
244 result = new Complex [len]; |
|
|
245 for (int i = 0; i < len; i++) |
|
|
246 result[i] = s + d[i]; |
|
|
247 } |
|
|
248 return result; |
|
|
249 } |
|
|
250 |
|
|
251 static inline Complex * |
|
238
|
252 subtract (const Complex *d, int len, Complex s) |
|
3
|
253 { |
|
|
254 Complex *result = 0; |
|
|
255 if (len > 0) |
|
|
256 { |
|
|
257 result = new Complex [len]; |
|
|
258 for (int i = 0; i < len; i++) |
|
|
259 result[i] = d[i] - s; |
|
|
260 } |
|
|
261 return result; |
|
|
262 } |
|
|
263 |
|
|
264 static inline Complex * |
|
238
|
265 subtract (Complex s, const Complex *d, int len) |
|
3
|
266 { |
|
|
267 Complex *result = 0; |
|
|
268 if (len > 0) |
|
|
269 { |
|
|
270 result = new Complex [len]; |
|
|
271 for (int i = 0; i < len; i++) |
|
|
272 result[i] = s - d[i]; |
|
|
273 } |
|
|
274 return result; |
|
|
275 } |
|
|
276 |
|
|
277 static inline Complex * |
|
238
|
278 multiply (const Complex *d, int len, Complex s) |
|
3
|
279 { |
|
|
280 Complex *result = 0; |
|
|
281 if (len > 0) |
|
|
282 { |
|
|
283 result = new Complex [len]; |
|
|
284 for (int i = 0; i < len; i++) |
|
|
285 result[i] = d[i] * s; |
|
|
286 } |
|
|
287 return result; |
|
|
288 } |
|
|
289 |
|
|
290 static inline Complex * |
|
238
|
291 multiply (Complex s, const Complex *d, int len) |
|
3
|
292 { |
|
|
293 Complex *result = 0; |
|
|
294 if (len > 0) |
|
|
295 { |
|
|
296 result = new Complex [len]; |
|
|
297 for (int i = 0; i < len; i++) |
|
|
298 result[i] = s * d[i]; |
|
|
299 } |
|
|
300 return result; |
|
|
301 } |
|
|
302 |
|
|
303 static inline Complex * |
|
238
|
304 divide (const Complex *d, int len, Complex s) |
|
3
|
305 { |
|
|
306 Complex *result = 0; |
|
|
307 if (len > 0) |
|
|
308 { |
|
|
309 result = new Complex [len]; |
|
|
310 for (int i = 0; i < len; i++) |
|
|
311 result[i] = d[i] / s; |
|
|
312 } |
|
|
313 return result; |
|
|
314 } |
|
|
315 |
|
|
316 static inline Complex * |
|
238
|
317 divide (Complex s, const Complex *d, int len) |
|
3
|
318 { |
|
|
319 Complex *result = 0; |
|
|
320 if (len > 0) |
|
|
321 { |
|
|
322 result = new Complex [len]; |
|
|
323 for (int i = 0; i < len; i++) |
|
|
324 result[i] = s / d[i]; |
|
|
325 } |
|
|
326 return result; |
|
|
327 } |
|
|
328 |
|
|
329 static inline Complex * |
|
238
|
330 add (const Complex *x, const Complex *y, int len) |
|
3
|
331 { |
|
|
332 Complex *result = 0; |
|
|
333 if (len > 0) |
|
|
334 { |
|
|
335 result = new Complex [len]; |
|
|
336 for (int i = 0; i < len; i++) |
|
|
337 result[i] = x[i] + y[i]; |
|
|
338 } |
|
|
339 return result; |
|
|
340 } |
|
|
341 |
|
|
342 static inline Complex * |
|
238
|
343 subtract (const Complex *x, const Complex *y, int len) |
|
3
|
344 { |
|
|
345 Complex *result = 0; |
|
|
346 if (len > 0) |
|
|
347 { |
|
|
348 result = new Complex [len]; |
|
|
349 for (int i = 0; i < len; i++) |
|
|
350 result[i] = x[i] - y[i]; |
|
|
351 } |
|
|
352 return result; |
|
|
353 } |
|
|
354 |
|
|
355 static inline Complex * |
|
238
|
356 multiply (const Complex *x, const Complex *y, int len) |
|
3
|
357 { |
|
|
358 Complex *result = 0; |
|
|
359 if (len > 0) |
|
|
360 { |
|
|
361 result = new Complex [len]; |
|
|
362 for (int i = 0; i < len; i++) |
|
|
363 result[i] = x[i] * y[i]; |
|
|
364 } |
|
|
365 return result; |
|
|
366 } |
|
|
367 |
|
|
368 static inline Complex * |
|
238
|
369 divide (const Complex *x, const Complex *y, int len) |
|
3
|
370 { |
|
|
371 Complex *result = 0; |
|
|
372 if (len > 0) |
|
|
373 { |
|
|
374 result = new Complex [len]; |
|
|
375 for (int i = 0; i < len; i++) |
|
|
376 result[i] = x[i] / y[i]; |
|
|
377 } |
|
|
378 return result; |
|
|
379 } |
|
|
380 |
|
|
381 static inline Complex * |
|
238
|
382 add2 (Complex *x, const Complex *y, int len) |
|
3
|
383 { |
|
|
384 for (int i = 0; i < len; i++) |
|
|
385 x[i] += y[i]; |
|
|
386 return x; |
|
|
387 } |
|
|
388 |
|
|
389 static inline Complex * |
|
238
|
390 subtract2 (Complex *x, const Complex *y, int len) |
|
3
|
391 { |
|
|
392 for (int i = 0; i < len; i++) |
|
|
393 x[i] -= y[i]; |
|
|
394 return x; |
|
|
395 } |
|
|
396 |
|
|
397 static inline Complex * |
|
238
|
398 negate (const Complex *d, int len) |
|
3
|
399 { |
|
|
400 Complex *result = 0; |
|
|
401 if (len > 0) |
|
|
402 { |
|
|
403 result = new Complex [len]; |
|
|
404 for (int i = 0; i < len; i++) |
|
|
405 result[i] = -d[i]; |
|
|
406 } |
|
|
407 return result; |
|
|
408 } |
|
|
409 |
|
|
410 static inline double * |
|
238
|
411 not (const Complex *d, int len) |
|
3
|
412 { |
|
|
413 double *result = 0; |
|
|
414 if (len > 0) |
|
|
415 { |
|
|
416 result = new double [len]; |
|
|
417 for (int i = 0; i < len; i++) |
|
|
418 result[i] = (d[i] == 0.0); |
|
|
419 } |
|
|
420 return result; |
|
|
421 } |
|
|
422 |
|
|
423 static inline void |
|
|
424 copy (Complex *d, int len, Complex s) |
|
|
425 { |
|
|
426 for (int i = 0; i < len; i++) |
|
|
427 d[i] = s; |
|
|
428 } |
|
|
429 |
|
|
430 static inline void |
|
238
|
431 copy (Complex *x, const Complex *y, int len) |
|
3
|
432 { |
|
|
433 for (int i = 0; i < len; i++) |
|
|
434 x[i] = y[i]; |
|
|
435 } |
|
|
436 |
|
|
437 static inline Complex * |
|
238
|
438 dup (const Complex *x, int len) |
|
3
|
439 { |
|
238
|
440 Complex *retval = 0; |
|
3
|
441 if (len > 0) |
|
|
442 { |
|
|
443 retval = new Complex [len]; |
|
|
444 for (int i = 0; i < len; i++) |
|
|
445 retval[i] = x[i]; |
|
|
446 } |
|
|
447 return retval; |
|
|
448 } |
|
|
449 |
|
|
450 static inline Complex * |
|
238
|
451 make_complex (const double *x, int len) |
|
3
|
452 { |
|
238
|
453 Complex *retval = 0; |
|
3
|
454 if (len > 0) |
|
|
455 { |
|
|
456 retval = new Complex [len]; |
|
|
457 for (int i = 0; i < len; i++) |
|
|
458 retval[i] = x[i]; |
|
|
459 } |
|
|
460 return retval; |
|
|
461 } |
|
|
462 |
|
|
463 static inline Complex * |
|
238
|
464 conj_dup (const Complex *x, int len) |
|
3
|
465 { |
|
238
|
466 Complex *retval = 0; |
|
3
|
467 if (len > 0) |
|
|
468 { |
|
|
469 retval = new Complex [len]; |
|
|
470 for (int i = 0; i < len; i++) |
|
|
471 retval[i] = conj (x[i]); |
|
|
472 } |
|
|
473 return retval; |
|
|
474 } |
|
|
475 |
|
|
476 static inline double * |
|
238
|
477 real_dup (const Complex *x, int len) |
|
3
|
478 { |
|
238
|
479 double *retval = 0; |
|
3
|
480 if (len > 0) |
|
|
481 { |
|
|
482 retval = new double [len]; |
|
|
483 for (int i = 0; i < len; i++) |
|
|
484 retval[i] = real (x[i]); |
|
|
485 } |
|
|
486 return retval; |
|
|
487 } |
|
|
488 |
|
|
489 static inline double * |
|
238
|
490 imag_dup (const Complex *x, int len) |
|
3
|
491 { |
|
238
|
492 double *retval = 0; |
|
3
|
493 if (len > 0) |
|
|
494 { |
|
|
495 retval = new double [len]; |
|
|
496 for (int i = 0; i < len; i++) |
|
|
497 retval[i] = imag (x[i]); |
|
|
498 } |
|
|
499 return retval; |
|
|
500 } |
|
|
501 |
|
|
502 static inline int |
|
238
|
503 equal (const Complex *x, const Complex *y, int len) |
|
3
|
504 { |
|
|
505 for (int i = 0; i < len; i++) |
|
|
506 if (x[i] != y[i]) |
|
|
507 return 0; |
|
|
508 return 1; |
|
|
509 } |
|
|
510 |
|
|
511 // And still some more for mixed Complex/double operations... |
|
|
512 |
|
|
513 static inline Complex * |
|
238
|
514 add (const Complex *d, int len, double s) |
|
3
|
515 { |
|
|
516 Complex *result = 0; |
|
|
517 if (len > 0) |
|
|
518 { |
|
|
519 result = new Complex [len]; |
|
|
520 for (int i = 0; i < len; i++) |
|
|
521 result[i] = d[i] + s; |
|
|
522 } |
|
|
523 return result; |
|
|
524 } |
|
|
525 |
|
|
526 static inline Complex * |
|
238
|
527 add (const double *d, int len, Complex s) |
|
3
|
528 { |
|
|
529 Complex *result = 0; |
|
|
530 if (len > 0) |
|
|
531 { |
|
|
532 result = new Complex [len]; |
|
|
533 for (int i = 0; i < len; i++) |
|
|
534 result[i] = d[i] + s; |
|
|
535 } |
|
|
536 return result; |
|
|
537 } |
|
|
538 |
|
|
539 static inline Complex * |
|
238
|
540 add (double s, const Complex *d, int len) |
|
3
|
541 { |
|
|
542 Complex *result = 0; |
|
|
543 if (len > 0) |
|
|
544 { |
|
|
545 result = new Complex [len]; |
|
|
546 for (int i = 0; i < len; i++) |
|
|
547 result[i] = s + d[i]; |
|
|
548 } |
|
|
549 return result; |
|
|
550 } |
|
|
551 |
|
|
552 static inline Complex * |
|
238
|
553 add (Complex s, const double *d, int len) |
|
3
|
554 { |
|
|
555 Complex *result = 0; |
|
|
556 if (len > 0) |
|
|
557 { |
|
|
558 result = new Complex [len]; |
|
|
559 for (int i = 0; i < len; i++) |
|
|
560 result[i] = s + d[i]; |
|
|
561 } |
|
|
562 return result; |
|
|
563 } |
|
|
564 |
|
|
565 static inline Complex * |
|
238
|
566 subtract (const Complex *d, int len, double s) |
|
3
|
567 { |
|
|
568 Complex *result = 0; |
|
|
569 if (len > 0) |
|
|
570 { |
|
|
571 result = new Complex [len]; |
|
|
572 for (int i = 0; i < len; i++) |
|
|
573 result[i] = d[i] - s; |
|
|
574 } |
|
|
575 return result; |
|
|
576 } |
|
|
577 |
|
|
578 static inline Complex * |
|
238
|
579 subtract (const double *d, int len, Complex s) |
|
3
|
580 { |
|
|
581 Complex *result = 0; |
|
|
582 if (len > 0) |
|
|
583 { |
|
|
584 result = new Complex [len]; |
|
|
585 for (int i = 0; i < len; i++) |
|
|
586 result[i] = d[i] - s; |
|
|
587 } |
|
|
588 return result; |
|
|
589 } |
|
|
590 |
|
|
591 static inline Complex * |
|
238
|
592 subtract (double s, const Complex *d, int len) |
|
3
|
593 { |
|
|
594 Complex *result = 0; |
|
|
595 if (len > 0) |
|
|
596 { |
|
|
597 result = new Complex [len]; |
|
|
598 for (int i = 0; i < len; i++) |
|
|
599 result[i] = s - d[i]; |
|
|
600 } |
|
|
601 return result; |
|
|
602 } |
|
|
603 |
|
|
604 static inline Complex * |
|
238
|
605 subtract (Complex s, const double *d, int len) |
|
3
|
606 { |
|
|
607 Complex *result = 0; |
|
|
608 if (len > 0) |
|
|
609 { |
|
|
610 result = new Complex [len]; |
|
|
611 for (int i = 0; i < len; i++) |
|
|
612 result[i] = s - d[i]; |
|
|
613 } |
|
|
614 return result; |
|
|
615 } |
|
|
616 |
|
|
617 static inline Complex * |
|
238
|
618 multiply (const Complex *d, int len, double s) |
|
3
|
619 { |
|
|
620 Complex *result = 0; |
|
|
621 if (len > 0) |
|
|
622 { |
|
|
623 result = new Complex [len]; |
|
|
624 for (int i = 0; i < len; i++) |
|
|
625 result[i] = d[i] * s; |
|
|
626 } |
|
|
627 return result; |
|
|
628 } |
|
|
629 |
|
|
630 static inline Complex * |
|
238
|
631 multiply (const double *d, int len, Complex s) |
|
3
|
632 { |
|
|
633 Complex *result = 0; |
|
|
634 if (len > 0) |
|
|
635 { |
|
|
636 result = new Complex [len]; |
|
|
637 for (int i = 0; i < len; i++) |
|
|
638 result[i] = d[i] * s; |
|
|
639 } |
|
|
640 return result; |
|
|
641 } |
|
|
642 |
|
|
643 static inline Complex * |
|
238
|
644 divide (const Complex *d, int len, double s) |
|
3
|
645 { |
|
|
646 Complex *result = 0; |
|
|
647 if (len > 0) |
|
|
648 { |
|
|
649 result = new Complex [len]; |
|
|
650 for (int i = 0; i < len; i++) |
|
|
651 result[i] = d[i] / s; |
|
|
652 } |
|
|
653 return result; |
|
|
654 } |
|
|
655 |
|
|
656 static inline Complex * |
|
238
|
657 divide (const double *d, int len, Complex s) |
|
3
|
658 { |
|
|
659 Complex *result = 0; |
|
|
660 if (len > 0) |
|
|
661 { |
|
|
662 result = new Complex [len]; |
|
|
663 for (int i = 0; i < len; i++) |
|
|
664 result[i] = d[i] / s; |
|
|
665 } |
|
|
666 return result; |
|
|
667 } |
|
|
668 |
|
|
669 static inline Complex * |
|
238
|
670 divide (double s, const Complex *d, int len) |
|
3
|
671 { |
|
|
672 Complex *result = 0; |
|
|
673 if (len > 0) |
|
|
674 { |
|
|
675 result = new Complex [len]; |
|
|
676 for (int i = 0; i < len; i++) |
|
|
677 result[i] = s / d[i]; |
|
|
678 } |
|
|
679 return result; |
|
|
680 } |
|
|
681 |
|
|
682 static inline Complex * |
|
238
|
683 divide (Complex s, const double *d, int len) |
|
3
|
684 { |
|
|
685 Complex *result = 0; |
|
|
686 if (len > 0) |
|
|
687 { |
|
|
688 result = new Complex [len]; |
|
|
689 for (int i = 0; i < len; i++) |
|
|
690 result[i] = s / d[i]; |
|
|
691 } |
|
|
692 return result; |
|
|
693 } |
|
|
694 |
|
|
695 static inline Complex * |
|
238
|
696 add (const Complex *x, const double *y, int len) |
|
3
|
697 { |
|
|
698 Complex *result = 0; |
|
|
699 if (len > 0) |
|
|
700 { |
|
|
701 result = new Complex [len]; |
|
|
702 for (int i = 0; i < len; i++) |
|
|
703 result[i] = x[i] + y[i]; |
|
|
704 } |
|
|
705 return result; |
|
|
706 } |
|
|
707 |
|
|
708 static inline Complex * |
|
238
|
709 add (const double *x, const Complex *y, int len) |
|
3
|
710 { |
|
|
711 Complex *result = 0; |
|
|
712 if (len > 0) |
|
|
713 { |
|
|
714 result = new Complex [len]; |
|
|
715 for (int i = 0; i < len; i++) |
|
|
716 result[i] = x[i] + y[i]; |
|
|
717 } |
|
|
718 return result; |
|
|
719 } |
|
|
720 |
|
|
721 static inline Complex * |
|
238
|
722 subtract (const Complex *x, const double *y, int len) |
|
3
|
723 { |
|
|
724 Complex *result = 0; |
|
|
725 if (len > 0) |
|
|
726 { |
|
|
727 result = new Complex [len]; |
|
|
728 for (int i = 0; i < len; i++) |
|
|
729 result[i] = x[i] - y[i]; |
|
|
730 } |
|
|
731 return result; |
|
|
732 } |
|
|
733 |
|
|
734 static inline Complex * |
|
238
|
735 subtract (const double *x, const Complex *y, int len) |
|
3
|
736 { |
|
|
737 Complex *result = 0; |
|
|
738 if (len > 0) |
|
|
739 { |
|
|
740 result = new Complex [len]; |
|
|
741 for (int i = 0; i < len; i++) |
|
|
742 result[i] = x[i] - y[i]; |
|
|
743 } |
|
|
744 return result; |
|
|
745 } |
|
|
746 |
|
|
747 static inline Complex * |
|
238
|
748 multiply (const Complex *x, const double *y, int len) |
|
3
|
749 { |
|
|
750 Complex *result = 0; |
|
|
751 if (len > 0) |
|
|
752 { |
|
|
753 result = new Complex [len]; |
|
|
754 for (int i = 0; i < len; i++) |
|
|
755 result[i] = x[i] * y[i]; |
|
|
756 } |
|
|
757 return result; |
|
|
758 } |
|
|
759 |
|
|
760 static inline Complex * |
|
238
|
761 multiply (const double *x, const Complex *y, int len) |
|
3
|
762 { |
|
|
763 Complex *result = 0; |
|
|
764 if (len > 0) |
|
|
765 { |
|
|
766 result = new Complex [len]; |
|
|
767 for (int i = 0; i < len; i++) |
|
|
768 result[i] = x[i] * y[i]; |
|
|
769 } |
|
|
770 return result; |
|
|
771 } |
|
|
772 |
|
|
773 static inline Complex * |
|
238
|
774 divide (const Complex *x, const double *y, int len) |
|
3
|
775 { |
|
|
776 Complex *result = 0; |
|
|
777 if (len > 0) |
|
|
778 { |
|
|
779 result = new Complex [len]; |
|
|
780 for (int i = 0; i < len; i++) |
|
|
781 result[i] = x[i] / y[i]; |
|
|
782 } |
|
|
783 return result; |
|
|
784 } |
|
|
785 |
|
|
786 static inline Complex * |
|
238
|
787 divide (const double *x, const Complex *y, int len) |
|
3
|
788 { |
|
|
789 Complex *result = 0; |
|
|
790 if (len > 0) |
|
|
791 { |
|
|
792 result = new Complex [len]; |
|
|
793 for (int i = 0; i < len; i++) |
|
|
794 result[i] = x[i] / y[i]; |
|
|
795 } |
|
|
796 return result; |
|
|
797 } |
|
|
798 |
|
|
799 static inline Complex * |
|
238
|
800 add2 (Complex *x, const double *y, int len) |
|
3
|
801 { |
|
|
802 for (int i = 0; i < len; i++) |
|
|
803 x[i] += y[i]; |
|
|
804 return x; |
|
|
805 } |
|
|
806 |
|
|
807 static inline Complex * |
|
238
|
808 subtract2 (Complex *x, const double *y, int len) |
|
3
|
809 { |
|
|
810 for (int i = 0; i < len; i++) |
|
|
811 x[i] -= y[i]; |
|
|
812 return x; |
|
|
813 } |
|
|
814 |
|
|
815 static inline void |
|
|
816 copy (Complex *d, int len, double s) |
|
|
817 { |
|
|
818 for (int i = 0; i < len; i++) |
|
|
819 d[i] = s; |
|
|
820 } |
|
|
821 |
|
|
822 static inline void |
|
238
|
823 copy (Complex *x, const double *y, int len) |
|
3
|
824 { |
|
|
825 for (int i = 0; i < len; i++) |
|
|
826 x[i] = y[i]; |
|
|
827 } |
|
|
828 |
|
|
829 /* |
|
|
830 ;;; Local Variables: *** |
|
|
831 ;;; mode: C++ *** |
|
|
832 ;;; page-delimiter: "^/\\*" *** |
|
|
833 ;;; End: *** |
|
|
834 */ |
