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