Mercurial > hg > octave-nkf

comparison liboctave/mx-inlines.cc @ 238:780cbbc57b7c

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