Mercurial > hg > octave-max

comparison liboctave/mx-inlines.cc @ 3:9a4c07481e61

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