Mercurial > octave-nkf
annotate liboctave/mx-inlines.cc @ 10314:07ebe522dac2
untabify liboctave C++ sources
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Thu, 11 Feb 2010 12:23:32 -0500 |
parents | 4c0cdbe0acca |
children | b47ab50a6aa8 |
rev | line source |
---|---|
3 | 1 /* |
2 | |
7017 | 3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, |
8920 | 4 2003, 2004, 2005, 2006, 2007, 2008 John W. Eaton |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
5 Copyright (C) 2009 Jaroslav Hajek |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
6 Copyright (C) 2009 VZLU Prague |
3 | 7 |
8 This file is part of Octave. | |
9 | |
10 Octave is free software; you can redistribute it and/or modify it | |
11 under the terms of the GNU General Public License as published by the | |
7016 | 12 Free Software Foundation; either version 3 of the License, or (at your |
13 option) any later version. | |
3 | 14 |
15 Octave is distributed in the hope that it will be useful, but WITHOUT | |
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
18 for more details. | |
19 | |
20 You should have received a copy of the GNU General Public License | |
7016 | 21 along with Octave; see the file COPYING. If not, see |
22 <http://www.gnu.org/licenses/>. | |
3 | 23 |
24 */ | |
25 | |
2828 | 26 #if !defined (octave_mx_inlines_h) |
27 #define octave_mx_inlines_h 1 | |
2804 | 28 |
29 #include <cstddef> | |
8650
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
30 #include <cmath> |
10146
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
31 #include <memory> |
2804 | 32 |
5525 | 33 #include "quit.h" |
34 | |
1650 | 35 #include "oct-cmplx.h" |
8758
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
36 #include "oct-locbuf.h" |
8897 | 37 #include "oct-inttypes.h" |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
38 #include "Array-util.h" |
10146
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
39 #include "Array-util.h" |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
40 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
41 // Provides some commonly repeated, basic loop templates. |
461 | 42 |
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
43 template <class R, class S> |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
44 inline void mx_inline_fill (size_t n, R *r, S s) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
45 { for (size_t i = 0; i < n; i++) r[i] = s; } |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
46 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
47 #define DEFMXUNOP(F, OP) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
48 template <class R, class X> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
49 inline void F (size_t n, R *r, const X *x) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
50 { for (size_t i = 0; i < n; i++) r[i] = OP x[i]; } |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
51 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
52 DEFMXUNOP (mx_inline_uminus, -) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
53 |
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
54 #define DEFMXUNOPEQ(F, OP) \ |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
55 template <class R> \ |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
56 inline void F (size_t n, R *r) \ |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
57 { for (size_t i = 0; i < n; i++) r[i] = OP r[i]; } |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
58 |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
59 DEFMXUNOPEQ (mx_inline_uminus2, -) |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
60 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
61 #define DEFMXUNBOOLOP(F, OP) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
62 template <class X> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
63 inline void F (size_t n, bool *r, const X *x) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
64 { const X zero = X(); for (size_t i = 0; i < n; i++) r[i] = x[i] OP zero; } |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
65 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
66 DEFMXUNBOOLOP (mx_inline_iszero, ==) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
67 DEFMXUNBOOLOP (mx_inline_notzero, !=) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
68 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
69 #define DEFMXBINOP(F, OP) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
70 template <class R, class X, class Y> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
71 inline void F (size_t n, R *r, const X *x, const Y *y) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
72 { for (size_t i = 0; i < n; i++) r[i] = x[i] OP y[i]; } \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
73 template <class R, class X, class Y> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
74 inline void F (size_t n, R *r, const X *x, Y y) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
75 { for (size_t i = 0; i < n; i++) r[i] = x[i] OP y; } \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
76 template <class R, class X, class Y> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
77 inline void F (size_t n, R *r, X x, const Y *y) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
78 { for (size_t i = 0; i < n; i++) r[i] = x OP y[i]; } |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
79 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
80 DEFMXBINOP (mx_inline_add, +) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
81 DEFMXBINOP (mx_inline_sub, -) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
82 DEFMXBINOP (mx_inline_mul, *) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
83 DEFMXBINOP (mx_inline_div, /) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
84 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
85 #define DEFMXBINOPEQ(F, OP) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
86 template <class R, class X> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
87 inline void F (size_t n, R *r, const X *x) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
88 { for (size_t i = 0; i < n; i++) r[i] OP x[i]; } \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
89 template <class R, class X> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
90 inline void F (size_t n, R *r, X x) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
91 { for (size_t i = 0; i < n; i++) r[i] OP x; } |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
92 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
93 DEFMXBINOPEQ (mx_inline_add2, +=) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
94 DEFMXBINOPEQ (mx_inline_sub2, -=) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
95 DEFMXBINOPEQ (mx_inline_mul2, *=) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
96 DEFMXBINOPEQ (mx_inline_div2, /=) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
97 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
98 #define DEFMXCMPOP(F, OP) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
99 template <class X, class Y> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
100 inline void F (size_t n, bool *r, const X *x, const Y *y) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
101 { for (size_t i = 0; i < n; i++) r[i] = x[i] OP y[i]; } \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
102 template <class X, class Y> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
103 inline void F (size_t n, bool *r, const X *x, Y y) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
104 { for (size_t i = 0; i < n; i++) r[i] = x[i] OP y; } \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
105 template <class X, class Y> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
106 inline void F (size_t n, bool *r, X x, const Y *y) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
107 { for (size_t i = 0; i < n; i++) r[i] = x OP y[i]; } |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
108 |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
109 DEFMXCMPOP (mx_inline_lt, <) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
110 DEFMXCMPOP (mx_inline_le, <=) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
111 DEFMXCMPOP (mx_inline_gt, >) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
112 DEFMXCMPOP (mx_inline_ge, >=) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
113 DEFMXCMPOP (mx_inline_eq, ==) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
114 DEFMXCMPOP (mx_inline_ne, !=) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
115 |
9553
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
116 // Convert to logical value, for logical op purposes. |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
117 template <class T> inline bool logical_value (T x) { return x; } |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
118 template <class T> inline bool logical_value (const octave_int<T>& x) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
119 { return x.value (); } |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
120 |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
121 // NaNs in real data should generate an error. Doing it on-the-fly is faster. |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
122 |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
123 #define DEFLOGCHKNAN(ARG, ZERO) \ |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
124 inline bool logical_value (ARG x) \ |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
125 { if (xisnan (x)) gripe_nan_to_logical_conversion (); return x != ZERO; } |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
126 |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
127 DEFLOGCHKNAN (double, 0.0) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
128 DEFLOGCHKNAN (const Complex&, 0.0) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
129 DEFLOGCHKNAN (float, 0.0f) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
130 DEFLOGCHKNAN (const FloatComplex&, 0.0f) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
131 |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
132 template <class X> |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
133 void mx_inline_not (size_t n, bool *r, const X* x) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
134 { |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
135 for (size_t i = 0; i < n; i++) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
136 r[i] = ! logical_value (x[i]); |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
137 } |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
138 |
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
139 inline void mx_inline_not2 (size_t n, bool *r) |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
140 { |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
141 for (size_t i = 0; i < n; i++) r[i] = ! r[i]; |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
142 } |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
143 |
9553
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
144 #define DEFMXBOOLOP(F, NOT1, OP, NOT2) \ |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
145 template <class X, class Y> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
146 inline void F (size_t n, bool *r, const X *x, const Y *y) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
147 { \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
148 for (size_t i = 0; i < n; i++) \ |
9553
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
149 r[i] = (NOT1 logical_value (x[i])) OP (NOT2 logical_value (y[i])); \ |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
150 } \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
151 template <class X, class Y> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
152 inline void F (size_t n, bool *r, const X *x, Y y) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
153 { \ |
9553
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
154 const bool yy = (NOT2 logical_value (y)); \ |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
155 for (size_t i = 0; i < n; i++) \ |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
156 r[i] = (NOT1 logical_value (x[i])) OP yy; \ |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
157 } \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
158 template <class X, class Y> \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
159 inline void F (size_t n, bool *r, X x, const Y *y) \ |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
160 { \ |
9553
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
161 const bool xx = (NOT1 logical_value (x)); \ |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
162 for (size_t i = 0; i < n; i++) \ |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
163 r[i] = xx OP (NOT2 logical_value (y[i])); \ |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
164 } |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
165 |
9553
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
166 DEFMXBOOLOP (mx_inline_and, , &, ) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
167 DEFMXBOOLOP (mx_inline_or, , |, ) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
168 DEFMXBOOLOP (mx_inline_not_and, !, &, ) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
169 DEFMXBOOLOP (mx_inline_not_or, !, |, ) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
170 DEFMXBOOLOP (mx_inline_and_not, , &, !) |
0c72d9284087
further bool ops tweaks
Jaroslav Hajek <highegg@gmail.com>
parents:
9550
diff
changeset
|
171 DEFMXBOOLOP (mx_inline_or_not, , |, !) |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
172 |
9612
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
173 #define DEFMXBOOLOPEQ(F, OP) \ |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
174 template <class X> \ |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
175 inline void F (size_t n, bool *r, const X *x) \ |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
176 { \ |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
177 for (size_t i = 0; i < n; i++) \ |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
178 r[i] OP logical_value (x[i]); \ |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
179 } \ |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
180 |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
181 DEFMXBOOLOPEQ (mx_inline_and2, &=) |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
182 DEFMXBOOLOPEQ (mx_inline_or2, |=) |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
183 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
184 template <class T> |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
185 inline bool |
9814
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
186 mx_inline_any_nan (size_t n, const T* x) |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
187 { |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
188 for (size_t i = 0; i < n; i++) |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
189 { |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
190 if (xisnan (x[i])) |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
191 return true; |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
192 } |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
193 |
9814
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
194 return false; |
8380
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
195 } |
dbe67764e628
fix & improve speed of diagonal matrix multiplication
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
196 |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
197 template <class T> |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
198 inline bool |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
199 mx_inline_any_negative (size_t n, const T* x) |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
200 { |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
201 for (size_t i = 0; i < n; i++) |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
202 { |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
203 if (x[i] < 0) |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
204 return true; |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
205 } |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
206 |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
207 return false; |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
208 } |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
209 |
9814
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
210 template<class T> |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
211 inline bool |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
212 mx_inline_all_real (size_t n, const std::complex<T>* x) |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
213 { |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
214 for (size_t i = 0; i < n; i++) |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
215 { |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
216 if (x[i].imag () != 0) |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
217 return false; |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
218 } |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
219 |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
220 return true; |
2b29f3472e20
add a couple of useful loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9800
diff
changeset
|
221 } |
2811 | 222 |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
223 #define DEFMXMAPPER(F, FUN) \ |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
224 template <class T> \ |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
225 inline void F (size_t n, T *r, const T *x) \ |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
226 { for (size_t i = 0; i < n; i++) r[i] = FUN (x[i]); } |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
227 |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
228 template<class T> |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
229 inline void mx_inline_real (size_t n, T *r, const std::complex<T>* x) |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
230 { for (size_t i = 0; i < n; i++) r[i] = x[i].real (); } |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
231 template<class T> |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
232 inline void mx_inline_imag (size_t n, T *r, const std::complex<T>* x) |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
233 { for (size_t i = 0; i < n; i++) r[i] = x[i].imag (); } |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
234 |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
235 // Pairwise minimums/maximums |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
236 #define DEFMXMAPPER2(F, FUN) \ |
9743
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
237 template <class T> \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
238 inline void F (size_t n, T *r, const T *x, const T *y) \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
239 { for (size_t i = 0; i < n; i++) r[i] = FUN (x[i], y[i]); } \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
240 template <class T> \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
241 inline void F (size_t n, T *r, const T *x, T y) \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
242 { for (size_t i = 0; i < n; i++) r[i] = FUN (x[i], y); } \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
243 template <class T> \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
244 inline void F (size_t n, T *r, T x, const T *y) \ |
26abff55f6fe
optimize bsxfun for common built-in operations
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
245 { for (size_t i = 0; i < n; i++) r[i] = FUN (x, y[i]); } |
3 | 246 |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
247 DEFMXMAPPER2 (mx_inline_xmin, xmin) |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
248 DEFMXMAPPER2 (mx_inline_xmax, xmax) |
2811 | 249 |
10146
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
250 // Specialize array-scalar max/min |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
251 #define DEFMINMAXSPEC(T, F, OP) \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
252 template <> \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
253 inline void F<T> (size_t n, T *r, const T *x, T y) \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
254 { \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
255 if (xisnan (y)) \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
256 std::memcpy (r, x, n * sizeof (T)); \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
257 else \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
258 for (size_t i = 0; i < n; i++) r[i] = (x[i] OP y) ? x[i] : y; \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
259 } \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
260 template <> \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
261 inline void F<T> (size_t n, T *r, T x, const T *y) \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
262 { \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
263 if (xisnan (x)) \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
264 std::memcpy (r, y, n * sizeof (T)); \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
265 else \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
266 for (size_t i = 0; i < n; i++) r[i] = (y[i] OP x) ? y[i] : x; \ |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
267 } |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
268 |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
269 DEFMINMAXSPEC (double, mx_inline_xmin, <=) |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
270 DEFMINMAXSPEC (double, mx_inline_xmax, >=) |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
271 DEFMINMAXSPEC (float, mx_inline_xmin, <=) |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
272 DEFMINMAXSPEC (float, mx_inline_xmax, >=) |
9597eea7fa36
inline xmin/xmax & optimize special cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9827
diff
changeset
|
273 |
9827
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
274 // Pairwise power |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
275 #define DEFMXMAPPER2X(F, FUN) \ |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
276 template <class R, class X, class Y> \ |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
277 inline void F (size_t n, R *r, const X *x, const Y *y) \ |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
278 { for (size_t i = 0; i < n; i++) r[i] = FUN (x[i], y[i]); } \ |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
279 template <class R, class X, class Y> \ |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
280 inline void F (size_t n, R *r, const X *x, Y y) \ |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
281 { for (size_t i = 0; i < n; i++) r[i] = FUN (x[i], y); } \ |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
282 template <class R, class X, class Y> \ |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
283 inline void F (size_t n, R *r, X x, const Y *y) \ |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
284 { for (size_t i = 0; i < n; i++) r[i] = FUN (x, y[i]); } |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
285 |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
286 DEFMXMAPPER2X (mx_inline_pow, std::pow) |
c15a5ed0da58
optimize bsxfun (@power, ...)
Jaroslav Hajek <highegg@gmail.com>
parents:
9814
diff
changeset
|
287 |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
288 // Arbitrary function appliers. The function is a template parameter to enable |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
289 // inlining. |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
290 template <class R, class X, R fun (X x)> |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
291 inline void mx_inline_map (size_t n, R *r, const X *x) |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
292 { for (size_t i = 0; i < n; i++) r[i] = fun (x[i]); } |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
293 |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
294 template <class R, class X, R fun (const X& x)> |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
295 inline void mx_inline_map (size_t n, R *r, const X *x) |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
296 { for (size_t i = 0; i < n; i++) r[i] = fun (x[i]); } |
3 | 297 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
298 // Appliers. Since these call the operation just once, we pass it as |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
299 // a pointer, to allow the compiler reduce number of instances. |
3 | 300 |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
301 #define AELEMT(ARRAY) typename ARRAY::element_type |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
302 template <class RNDA, class XNDA> |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
303 inline RNDA |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
304 do_mx_unary_op (const XNDA& x, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
305 void (*op) (size_t, AELEMT(RNDA) *, |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
306 const AELEMT(XNDA) *)) |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
307 { |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
308 RNDA r (x.dims ()); |
9612
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
309 op (r.length (), r.fortran_vec (), x.data ()); |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
310 return r; |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
311 } |
2811 | 312 |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
313 // Shortcuts for applying mx_inline_map. |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
314 |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
315 template <class RNDA, class XNDA, AELEMT(RNDA) fun (AELEMT(XNDA))> |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
316 inline RNDA |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
317 do_mx_unary_map (const XNDA& x) |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
318 { |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
319 return do_mx_unary_op<RNDA, XNDA> (x, mx_inline_map<AELEMT(RNDA), AELEMT(XNDA), fun>); |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
320 } |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
321 |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
322 template <class RNDA, class XNDA, AELEMT(RNDA) fun (const AELEMT(XNDA)&)> |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
323 inline RNDA |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
324 do_mx_unary_map (const XNDA& x) |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
325 { |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
326 return do_mx_unary_op<RNDA, XNDA> (x, mx_inline_map<AELEMT(RNDA), AELEMT(XNDA), fun>); |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
327 } |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
328 |
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
329 template <class RNDA> |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
330 inline RNDA& |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
331 do_mx_inplace_op (RNDA& r, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
332 void (*op) (size_t, AELEMT(RNDA) *)) |
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
333 { |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
334 op (r.numel (), r.fortran_vec ()); |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
335 return r; |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
336 } |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
337 |
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9578
diff
changeset
|
338 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
339 template <class RNDA, class XNDA, class YNDA> |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
340 inline RNDA |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
341 do_mm_binary_op (const XNDA& x, const YNDA& y, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
342 void (*op) (size_t, AELEMT(RNDA) *, |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
343 const AELEMT(XNDA) *, |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
344 const AELEMT(YNDA) *), |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
345 const char *opname) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
346 { |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
347 dim_vector dx = x.dims (), dy = y.dims (); |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
348 if (dx == dy) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
349 { |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
350 RNDA r (dx); |
9612
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
351 op (r.length (), r.fortran_vec (), x.data (), y.data ()); |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
352 return r; |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
353 } |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
354 else |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
355 { |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
356 gripe_nonconformant (opname, dx, dy); |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
357 return RNDA (); |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
358 } |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
359 } |
3 | 360 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
361 template <class RNDA, class XNDA, class YS> |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
362 inline RNDA |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
363 do_ms_binary_op (const XNDA& x, const YS& y, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
364 void (*op) (size_t, AELEMT(RNDA) *, |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
365 const AELEMT(XNDA) *, YS)) |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
366 { |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
367 RNDA r (x.dims ()); |
9612
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
368 op (r.length (), r.fortran_vec (), x.data (), y); |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
369 return r; |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
370 } |
3 | 371 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
372 template <class RNDA, class XS, class YNDA> |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
373 inline RNDA |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
374 do_sm_binary_op (const XS& x, const YNDA& y, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
375 void (*op) (size_t, AELEMT(RNDA) *, XS, |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
376 const AELEMT(YNDA) *)) |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
377 { |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
378 RNDA r (y.dims ()); |
9612
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
379 op (r.length (), r.fortran_vec (), x, y.data ()); |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
380 return r; |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
381 } |
3 | 382 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
383 template <class RNDA, class XNDA> |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
384 inline RNDA& |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
385 do_mm_inplace_op (RNDA& r, const XNDA& x, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
386 void (*op) (size_t, AELEMT(RNDA) *, |
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
387 const AELEMT(XNDA) *), |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
388 const char *opname) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
389 { |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
390 dim_vector dr = r.dims (), dx = x.dims (); |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
391 if (dr == dx) |
9612
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
392 op (r.length (), r.fortran_vec (), x.data ()); |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
393 else |
9612
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
394 gripe_nonconformant (opname, dr, dx); |
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
395 return r; |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
396 } |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
397 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
398 template <class RNDA, class XS> |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
399 inline RNDA& |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
400 do_ms_inplace_op (RNDA& r, const XS& x, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
401 void (*op) (size_t, AELEMT(RNDA) *, XS)) |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
402 { |
9612
66970dd627f6
further liboctave design improvements
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
403 op (r.length (), r.fortran_vec (), x); |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
404 return r; |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
405 } |
3 | 406 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
407 template <class T1, class T2> |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
408 inline bool |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
409 mx_inline_equal (size_t n, const T1 *x, const T2 *y) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
410 { |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
411 for (size_t i = 0; i < n; i++) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
412 if (x[i] != y[i]) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
413 return false; |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
414 return true; |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
415 } |
3 | 416 |
2804 | 417 #define OP_DUP_FCN(OP, F, R, T) \ |
418 static inline R * \ | |
419 F (const T *x, size_t n) \ | |
420 { \ | |
421 R *r = 0; \ | |
422 if (n > 0) \ | |
423 { \ | |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
424 r = new R [n]; \ |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
425 for (size_t i = 0; i < n; i++) \ |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
426 r[i] = OP (x[i]); \ |
2804 | 427 } \ |
428 return r; \ | |
429 } | |
3 | 430 |
3769 | 431 OP_DUP_FCN (, mx_inline_dup, double, double) |
432 OP_DUP_FCN (, mx_inline_dup, Complex, Complex) | |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
433 OP_DUP_FCN (, mx_inline_dup, float, float) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
434 OP_DUP_FCN (, mx_inline_dup, FloatComplex, FloatComplex) |
3 | 435 |
2804 | 436 // These should really return a bool *. Also, they should probably be |
437 // in with a collection of other element-by-element boolean ops. | |
3769 | 438 OP_DUP_FCN (0.0 ==, mx_inline_not, double, double) |
439 OP_DUP_FCN (0.0 ==, mx_inline_not, double, Complex) | |
3 | 440 |
3769 | 441 OP_DUP_FCN (, mx_inline_make_complex, Complex, double) |
2804 | 442 |
3769 | 443 OP_DUP_FCN (-, mx_inline_change_sign, double, double) |
444 OP_DUP_FCN (-, mx_inline_change_sign, Complex, Complex) | |
3 | 445 |
8650
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
446 OP_DUP_FCN (std::abs, mx_inline_fabs_dup, double, double) |
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
447 OP_DUP_FCN (std::abs, mx_inline_cabs_dup, double, Complex) |
3769 | 448 OP_DUP_FCN (real, mx_inline_real_dup, double, Complex) |
449 OP_DUP_FCN (imag, mx_inline_imag_dup, double, Complex) | |
450 OP_DUP_FCN (conj, mx_inline_conj_dup, Complex, Complex) | |
3 | 451 |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
452 OP_DUP_FCN (0.0 ==, mx_inline_not, float, float) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
453 OP_DUP_FCN (static_cast<float>(0.0) ==, mx_inline_not, float, FloatComplex) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
454 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
455 OP_DUP_FCN (, mx_inline_make_complex, FloatComplex, float) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
456 |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
457 OP_DUP_FCN (-, mx_inline_change_sign, float, float) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
458 OP_DUP_FCN (-, mx_inline_change_sign, FloatComplex, FloatComplex) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
459 |
8650
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
460 OP_DUP_FCN (std::abs, mx_inline_fabs_dup, float, float) |
a1ae2aae903e
abs,real,imag,conj: use code from mx-inlines rather than the generic map
Jaroslav Hajek <highegg@gmail.com>
parents:
8380
diff
changeset
|
461 OP_DUP_FCN (std::abs, mx_inline_cabs_dup, float, FloatComplex) |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
462 OP_DUP_FCN (real, mx_inline_real_dup, float, FloatComplex) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
463 OP_DUP_FCN (imag, mx_inline_imag_dup, float, FloatComplex) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
464 OP_DUP_FCN (conj, mx_inline_conj_dup, FloatComplex, FloatComplex) |
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
465 |
8899 | 466 // FIXME: Due to a performance defect in g++ (<= 4.3), std::norm is slow unless |
467 // ffast-math is on (not by default even with -O3). The following helper function | |
468 // gives the expected straightforward implementation of std::norm. | |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
469 template <class T> |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
470 inline T cabsq (const std::complex<T>& c) |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
471 { return c.real () * c.real () + c.imag () * c.imag (); } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
472 |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
473 // default. works for integers and bool. |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
474 template <class T> |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
475 inline bool xis_true (T x) { return x; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
476 template <class T> |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
477 inline bool xis_false (T x) { return ! x; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
478 // for octave_ints |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
479 template <class T> |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
480 inline bool xis_true (const octave_int<T>& x) { return x.value (); } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
481 template <class T> |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
482 inline bool xis_false (const octave_int<T>& x) { return ! x.value (); } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
483 // for reals, we want to ignore NaNs. |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
484 inline bool xis_true (double x) { return ! xisnan (x) && x != 0.0; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
485 inline bool xis_false (double x) { return x == 0.0; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
486 inline bool xis_true (float x) { return ! xisnan (x) && x != 0.0f; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
487 inline bool xis_false (float x) { return x == 0.0f; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
488 // Ditto for complex. |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
489 inline bool xis_true (const Complex& x) { return ! xisnan (x) && x != 0.0; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
490 inline bool xis_false (const Complex& x) { return x == 0.0; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
491 inline bool xis_true (const FloatComplex& x) { return ! xisnan (x) && x != 0.0f; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
492 inline bool xis_false (const FloatComplex& x) { return x == 0.0f; } |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
493 |
9550
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
494 #define OP_RED_SUM(ac, el) ac += el |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
495 #define OP_RED_PROD(ac, el) ac *= el |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
496 #define OP_RED_SUMSQ(ac, el) ac += el*el |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
497 #define OP_RED_SUMSQC(ac, el) ac += cabsq (el) |
3d6a9aea2aea
refactor binary & bool ops in liboctave
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
498 |
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
499 inline void op_dble_sum(double& ac, float el) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
500 { ac += el; } |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
501 inline void op_dble_sum(Complex& ac, const FloatComplex& el) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
502 { ac += el; } // FIXME: guaranteed? |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
503 template <class T> |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
504 inline void op_dble_sum(double& ac, const octave_int<T>& el) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
505 { ac += el.double_value (); } |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
506 |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
507 // The following two implement a simple short-circuiting. |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
508 #define OP_RED_ANYC(ac, el) if (xis_true (el)) { ac = true; break; } else continue |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
509 #define OP_RED_ALLC(ac, el) if (xis_false (el)) { ac = false; break; } else continue |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
510 |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
511 #define OP_RED_FCN(F, TSRC, TRES, OP, ZERO) \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
512 template <class T> \ |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
513 inline TRES \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
514 F (const TSRC* v, octave_idx_type n) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
515 { \ |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
516 TRES ac = ZERO; \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
517 for (octave_idx_type i = 0; i < n; i++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
518 OP(ac, v[i]); \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
519 return ac; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
520 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
521 |
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
522 #define PROMOTE_DOUBLE(T) typename subst_template_param<std::complex, T, double>::type |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
523 |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
524 OP_RED_FCN (mx_inline_sum, T, T, OP_RED_SUM, 0) |
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
525 OP_RED_FCN (mx_inline_dsum, T, PROMOTE_DOUBLE(T), op_dble_sum, 0.0) |
8756
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8751
diff
changeset
|
526 OP_RED_FCN (mx_inline_count, bool, T, OP_RED_SUM, 0) |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
527 OP_RED_FCN (mx_inline_prod, T, T, OP_RED_PROD, 1) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
528 OP_RED_FCN (mx_inline_sumsq, T, T, OP_RED_SUMSQ, 0) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
529 OP_RED_FCN (mx_inline_sumsq, std::complex<T>, T, OP_RED_SUMSQC, 0) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
530 OP_RED_FCN (mx_inline_any, T, bool, OP_RED_ANYC, false) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
531 OP_RED_FCN (mx_inline_all, T, bool, OP_RED_ALLC, true) |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
532 |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
533 |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
534 #define OP_RED_FCN2(F, TSRC, TRES, OP, ZERO) \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
535 template <class T> \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
536 inline void \ |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
537 F (const TSRC* v, TRES *r, octave_idx_type m, octave_idx_type n) \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
538 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
539 for (octave_idx_type i = 0; i < m; i++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
540 r[i] = ZERO; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
541 for (octave_idx_type j = 0; j < n; j++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
542 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
543 for (octave_idx_type i = 0; i < m; i++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
544 OP(r[i], v[i]); \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
545 v += m; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
546 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
547 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
548 |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
549 OP_RED_FCN2 (mx_inline_sum, T, T, OP_RED_SUM, 0) |
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
550 OP_RED_FCN2 (mx_inline_dsum, T, PROMOTE_DOUBLE(T), op_dble_sum, 0.0) |
8756
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8751
diff
changeset
|
551 OP_RED_FCN2 (mx_inline_count, bool, T, OP_RED_SUM, 0) |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
552 OP_RED_FCN2 (mx_inline_prod, T, T, OP_RED_PROD, 1) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
553 OP_RED_FCN2 (mx_inline_sumsq, T, T, OP_RED_SUMSQ, 0) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
554 OP_RED_FCN2 (mx_inline_sumsq, std::complex<T>, T, OP_RED_SUMSQC, 0) |
8758
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
555 |
10147
adc0143e9419
optimize any/all (x, 2) with small number of rows
Jaroslav Hajek <highegg@gmail.com>
parents:
10146
diff
changeset
|
556 #define OP_RED_ANYR(ac, el) ac |= xis_true (el) |
adc0143e9419
optimize any/all (x, 2) with small number of rows
Jaroslav Hajek <highegg@gmail.com>
parents:
10146
diff
changeset
|
557 #define OP_RED_ALLR(ac, el) ac &= xis_true (el) |
adc0143e9419
optimize any/all (x, 2) with small number of rows
Jaroslav Hajek <highegg@gmail.com>
parents:
10146
diff
changeset
|
558 |
adc0143e9419
optimize any/all (x, 2) with small number of rows
Jaroslav Hajek <highegg@gmail.com>
parents:
10146
diff
changeset
|
559 OP_RED_FCN2 (mx_inline_any_r, T, bool, OP_RED_ANYR, false) |
adc0143e9419
optimize any/all (x, 2) with small number of rows
Jaroslav Hajek <highegg@gmail.com>
parents:
10146
diff
changeset
|
560 OP_RED_FCN2 (mx_inline_all_r, T, bool, OP_RED_ALLR, true) |
adc0143e9419
optimize any/all (x, 2) with small number of rows
Jaroslav Hajek <highegg@gmail.com>
parents:
10146
diff
changeset
|
561 |
8758
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
562 // Using the general code for any/all would sacrifice short-circuiting. |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
563 // OTOH, going by rows would sacrifice cache-coherence. The following algorithm |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
564 // will achieve both, at the cost of a temporary octave_idx_type array. |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
565 |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
566 #define OP_ROW_SHORT_CIRCUIT(F, PRED, ZERO) \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
567 template <class T> \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
568 inline void \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
569 F (const T* v, bool *r, octave_idx_type m, octave_idx_type n) \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
570 { \ |
10147
adc0143e9419
optimize any/all (x, 2) with small number of rows
Jaroslav Hajek <highegg@gmail.com>
parents:
10146
diff
changeset
|
571 if (n <= 8) \ |
adc0143e9419
optimize any/all (x, 2) with small number of rows
Jaroslav Hajek <highegg@gmail.com>
parents:
10146
diff
changeset
|
572 return F ## _r (v, r, m, n); \ |
adc0143e9419
optimize any/all (x, 2) with small number of rows
Jaroslav Hajek <highegg@gmail.com>
parents:
10146
diff
changeset
|
573 \ |
8758
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
574 /* FIXME: it may be sub-optimal to allocate the buffer here. */ \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
575 OCTAVE_LOCAL_BUFFER (octave_idx_type, iact, m); \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
576 for (octave_idx_type i = 0; i < m; i++) iact[i] = i; \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
577 octave_idx_type nact = m; \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
578 for (octave_idx_type j = 0; j < n; j++) \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
579 { \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
580 octave_idx_type k = 0; \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
581 for (octave_idx_type i = 0; i < nact; i++) \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
582 { \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
583 octave_idx_type ia = iact[i]; \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
584 if (! PRED (v[ia])) \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
585 iact[k++] = ia; \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
586 } \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
587 nact = k; \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
588 v += m; \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
589 } \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
590 for (octave_idx_type i = 0; i < m; i++) r[i] = ! ZERO; \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
591 for (octave_idx_type i = 0; i < nact; i++) r[iact[i]] = ZERO; \ |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
592 } |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
593 |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
594 OP_ROW_SHORT_CIRCUIT (mx_inline_any, xis_true, false) |
83c9d60c3c47
implement short-circuiting row-reduction any/all algorithm
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
595 OP_ROW_SHORT_CIRCUIT (mx_inline_all, xis_false, true) |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
596 |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
597 #define OP_RED_FCNN(F, TSRC, TRES) \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
598 template <class T> \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
599 inline void \ |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
600 F (const TSRC *v, TRES *r, octave_idx_type l, \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
601 octave_idx_type n, octave_idx_type u) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
602 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
603 if (l == 1) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
604 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
605 for (octave_idx_type i = 0; i < u; i++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
606 { \ |
8756
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8751
diff
changeset
|
607 r[i] = F<T> (v, n); \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
608 v += n; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
609 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
610 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
611 else \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
612 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
613 for (octave_idx_type i = 0; i < u; i++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
614 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
615 F (v, r, l, n); \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
616 v += l*n; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
617 r += l; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
618 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
619 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
620 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
621 |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
622 OP_RED_FCNN (mx_inline_sum, T, T) |
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
623 OP_RED_FCNN (mx_inline_dsum, T, PROMOTE_DOUBLE(T)) |
8756
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8751
diff
changeset
|
624 OP_RED_FCNN (mx_inline_count, bool, T) |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
625 OP_RED_FCNN (mx_inline_prod, T, T) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
626 OP_RED_FCNN (mx_inline_sumsq, T, T) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
627 OP_RED_FCNN (mx_inline_sumsq, std::complex<T>, T) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
628 OP_RED_FCNN (mx_inline_any, T, bool) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
629 OP_RED_FCNN (mx_inline_all, T, bool) |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
630 |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
631 #define OP_CUM_FCN(F, TSRC, TRES, OP) \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
632 template <class T> \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
633 inline void \ |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
634 F (const TSRC *v, TRES *r, octave_idx_type n) \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
635 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
636 if (n) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
637 { \ |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
638 TRES t = r[0] = v[0]; \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
639 for (octave_idx_type i = 1; i < n; i++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
640 r[i] = t = t OP v[i]; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
641 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
642 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
643 |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
644 OP_CUM_FCN (mx_inline_cumsum, T, T, +) |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
645 OP_CUM_FCN (mx_inline_cumprod, T, T, *) |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
646 OP_CUM_FCN (mx_inline_cumcount, bool, T, +) |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
647 |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
648 #define OP_CUM_FCN2(F, TSRC, TRES, OP) \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
649 template <class T> \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
650 inline void \ |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
651 F (const TSRC *v, TRES *r, octave_idx_type m, octave_idx_type n) \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
652 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
653 if (n) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
654 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
655 for (octave_idx_type i = 0; i < m; i++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
656 r[i] = v[i]; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
657 const T *r0 = r; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
658 for (octave_idx_type j = 1; j < n; j++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
659 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
660 r += m; v += m; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
661 for (octave_idx_type i = 0; i < m; i++) \ |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
662 r[i] = r0[i] OP v[i]; \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
663 r0 += m; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
664 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
665 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
666 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
667 |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
668 OP_CUM_FCN2 (mx_inline_cumsum, T, T, +) |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
669 OP_CUM_FCN2 (mx_inline_cumprod, T, T, *) |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
670 OP_CUM_FCN2 (mx_inline_cumcount, bool, T, *) |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
671 |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
672 #define OP_CUM_FCNN(F, TSRC, TRES) \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
673 template <class T> \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
674 inline void \ |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
675 F (const TSRC *v, TRES *r, octave_idx_type l, \ |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
676 octave_idx_type n, octave_idx_type u) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
677 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
678 if (l == 1) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
679 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
680 for (octave_idx_type i = 0; i < u; i++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
681 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
682 F (v, r, n); \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
683 v += n; r += n; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
684 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
685 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
686 else \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
687 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
688 for (octave_idx_type i = 0; i < u; i++) \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
689 { \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
690 F (v, r, l, n); \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
691 v += l*n; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
692 r += l*n; \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
693 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
694 } \ |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
695 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
696 |
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
697 OP_CUM_FCNN (mx_inline_cumsum, T, T) |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
698 OP_CUM_FCNN (mx_inline_cumprod, T, T) |
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8777
diff
changeset
|
699 OP_CUM_FCNN (mx_inline_cumcount, bool, T) |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
700 |
8751
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
701 #define OP_MINMAX_FCN(F, OP) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
702 template <class T> \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
703 void F (const T *v, T *r, octave_idx_type n) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
704 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
705 if (! n) return; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
706 T tmp = v[0]; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
707 octave_idx_type i = 1; \ |
8776
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
708 if (xisnan (tmp)) \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
709 { \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
710 for (; i < n && xisnan (v[i]); i++) ; \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
711 if (i < n) tmp = v[i]; \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
712 } \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
713 for (; i < n; i++) \ |
8751
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
714 if (v[i] OP tmp) tmp = v[i]; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
715 *r = tmp; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
716 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
717 template <class T> \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
718 void F (const T *v, T *r, octave_idx_type *ri, octave_idx_type n) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
719 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
720 if (! n) return; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
721 T tmp = v[0]; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
722 octave_idx_type tmpi = 0; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
723 octave_idx_type i = 1; \ |
8776
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
724 if (xisnan (tmp)) \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
725 { \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
726 for (; i < n && xisnan (v[i]); i++) ; \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
727 if (i < n) { tmp = v[i]; tmpi = i; } \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
728 } \ |
d23c33ec6bd3
fix min/max behaviour with NaNs
Jaroslav Hajek <highegg@gmail.com>
parents:
8759
diff
changeset
|
729 for (; i < n; i++) \ |
8751
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
730 if (v[i] OP tmp) { tmp = v[i]; tmpi = i; }\ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
731 *r = tmp; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
732 *ri = tmpi; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
733 } |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
734 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
735 OP_MINMAX_FCN (mx_inline_min, <) |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
736 OP_MINMAX_FCN (mx_inline_max, >) |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
737 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
738 // Row reductions will be slightly complicated. We will proceed with checks |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
739 // for NaNs until we detect that no row will yield a NaN, in which case we |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
740 // proceed to a faster code. |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
741 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
742 #define OP_MINMAX_FCN2(F, OP) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
743 template <class T> \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
744 inline void \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
745 F (const T *v, T *r, octave_idx_type m, octave_idx_type n) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
746 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
747 if (! n) return; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
748 bool nan = false; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
749 octave_idx_type j = 0; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
750 for (octave_idx_type i = 0; i < m; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
751 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
752 r[i] = v[i]; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
753 if (xisnan (v[i])) nan = true; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
754 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
755 j++; v += m; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
756 while (nan && j < n) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
757 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
758 nan = false; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
759 for (octave_idx_type i = 0; i < m; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
760 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
761 if (xisnan (v[i])) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
762 nan = true; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
763 else if (xisnan (r[i]) || v[i] OP r[i]) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
764 r[i] = v[i]; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
765 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
766 j++; v += m; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
767 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
768 while (j < n) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
769 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
770 for (octave_idx_type i = 0; i < m; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
771 if (v[i] OP r[i]) r[i] = v[i]; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
772 j++; v += m; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
773 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
774 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
775 template <class T> \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
776 inline void \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
777 F (const T *v, T *r, octave_idx_type *ri, \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
778 octave_idx_type m, octave_idx_type n) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
779 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
780 if (! n) return; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
781 bool nan = false; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
782 octave_idx_type j = 0; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
783 for (octave_idx_type i = 0; i < m; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
784 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
785 r[i] = v[i]; ri[i] = j; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
786 if (xisnan (v[i])) nan = true; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
787 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
788 j++; v += m; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
789 while (nan && j < n) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
790 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
791 nan = false; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
792 for (octave_idx_type i = 0; i < m; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
793 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
794 if (xisnan (v[i])) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
795 nan = true; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
796 else if (xisnan (r[i]) || v[i] OP r[i]) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
797 { r[i] = v[i]; ri[i] = j; } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
798 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
799 j++; v += m; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
800 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
801 while (j < n) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
802 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
803 for (octave_idx_type i = 0; i < m; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
804 if (v[i] OP r[i]) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
805 { r[i] = v[i]; ri[i] = j; } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
806 j++; v += m; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
807 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
808 } |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
809 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
810 OP_MINMAX_FCN2 (mx_inline_min, <) |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
811 OP_MINMAX_FCN2 (mx_inline_max, >) |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
812 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
813 #define OP_MINMAX_FCNN(F) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
814 template <class T> \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
815 inline void \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
816 F (const T *v, T *r, octave_idx_type l, \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
817 octave_idx_type n, octave_idx_type u) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
818 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
819 if (! n) return; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
820 if (l == 1) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
821 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
822 for (octave_idx_type i = 0; i < u; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
823 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
824 F (v, r, n); \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
825 v += n; r++; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
826 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
827 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
828 else \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
829 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
830 for (octave_idx_type i = 0; i < u; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
831 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
832 F (v, r, l, n); \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
833 v += l*n; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
834 r += l; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
835 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
836 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
837 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
838 template <class T> \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
839 inline void \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
840 F (const T *v, T *r, octave_idx_type *ri, \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
841 octave_idx_type l, octave_idx_type n, octave_idx_type u) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
842 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
843 if (! n) return; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
844 if (l == 1) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
845 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
846 for (octave_idx_type i = 0; i < u; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
847 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
848 F (v, r, ri, n); \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
849 v += n; r++; ri++; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
850 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
851 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
852 else \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
853 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
854 for (octave_idx_type i = 0; i < u; i++) \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
855 { \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
856 F (v, r, ri, l, n); \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
857 v += l*n; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
858 r += l; ri += l; \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
859 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
860 } \ |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
861 } |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
862 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
863 OP_MINMAX_FCNN (mx_inline_min) |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
864 OP_MINMAX_FCNN (mx_inline_max) |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
865 |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
866 #define OP_CUMMINMAX_FCN(F, OP) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
867 template <class T> \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
868 void F (const T *v, T *r, octave_idx_type n) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
869 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
870 if (! n) return; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
871 T tmp = v[0]; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
872 octave_idx_type i = 1, j = 0; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
873 if (xisnan (tmp)) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
874 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
875 for (; i < n && xisnan (v[i]); i++) ; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
876 for (; j < i; j++) r[j] = tmp; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
877 if (i < n) tmp = v[i]; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
878 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
879 for (; i < n; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
880 if (v[i] OP tmp) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
881 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
882 for (; j < i; j++) r[j] = tmp; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
883 tmp = v[i]; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
884 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
885 for (; j < i; j++) r[j] = tmp; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
886 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
887 template <class T> \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
888 void F (const T *v, T *r, octave_idx_type *ri, octave_idx_type n) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
889 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
890 if (! n) return; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
891 T tmp = v[0]; octave_idx_type tmpi = 0; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
892 octave_idx_type i = 1, j = 0; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
893 if (xisnan (tmp)) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
894 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
895 for (; i < n && xisnan (v[i]); i++) ; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
896 for (; j < i; j++) { r[j] = tmp; ri[j] = tmpi; } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
897 if (i < n) { tmp = v[i]; tmpi = i; } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
898 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
899 for (; i < n; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
900 if (v[i] OP tmp) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
901 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
902 for (; j < i; j++) { r[j] = tmp; ri[j] = tmpi; } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
903 tmp = v[i]; tmpi = i; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
904 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
905 for (; j < i; j++) { r[j] = tmp; ri[j] = tmpi; } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
906 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
907 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
908 OP_CUMMINMAX_FCN (mx_inline_cummin, <) |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
909 OP_CUMMINMAX_FCN (mx_inline_cummax, >) |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
910 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
911 // Row reductions will be slightly complicated. We will proceed with checks |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
912 // for NaNs until we detect that no row will yield a NaN, in which case we |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
913 // proceed to a faster code. |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
914 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
915 #define OP_CUMMINMAX_FCN2(F, OP) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
916 template <class T> \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
917 inline void \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
918 F (const T *v, T *r, octave_idx_type m, octave_idx_type n) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
919 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
920 if (! n) return; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
921 bool nan = false; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
922 const T *r0; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
923 octave_idx_type j = 0; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
924 for (octave_idx_type i = 0; i < m; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
925 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
926 r[i] = v[i]; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
927 if (xisnan (v[i])) nan = true; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
928 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
929 j++; v += m; r0 = r; r += m; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
930 while (nan && j < n) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
931 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
932 nan = false; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
933 for (octave_idx_type i = 0; i < m; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
934 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
935 if (xisnan (v[i])) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
936 { r[i] = r0[i]; nan = true; } \ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
937 else if (xisnan (r0[i]) || v[i] OP r0[i]) \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
938 r[i] = v[i]; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
939 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
940 j++; v += m; r0 = r; r += m; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
941 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
942 while (j < n) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
943 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
944 for (octave_idx_type i = 0; i < m; i++) \ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
945 if (v[i] OP r0[i]) \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
946 r[i] = v[i]; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
947 else \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
948 r[i] = r0[i]; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
949 j++; v += m; r0 = r; r += m; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
950 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
951 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
952 template <class T> \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
953 inline void \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
954 F (const T *v, T *r, octave_idx_type *ri, \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
955 octave_idx_type m, octave_idx_type n) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
956 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
957 if (! n) return; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
958 bool nan = false; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
959 const T *r0; const octave_idx_type *r0i; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
960 octave_idx_type j = 0; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
961 for (octave_idx_type i = 0; i < m; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
962 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
963 r[i] = v[i]; ri[i] = 0; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
964 if (xisnan (v[i])) nan = true; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
965 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
966 j++; v += m; r0 = r; r += m; r0i = ri; ri += m; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
967 while (nan && j < n) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
968 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
969 nan = false; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
970 for (octave_idx_type i = 0; i < m; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
971 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
972 if (xisnan (v[i])) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
973 { r[i] = r0[i]; ri[i] = r0i[i]; nan = true; } \ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
974 else if (xisnan (r0[i]) || v[i] OP r0[i]) \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
975 { r[i] = v[i]; ri[i] = j; }\ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
976 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
977 j++; v += m; r0 = r; r += m; r0i = ri; ri += m; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
978 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
979 while (j < n) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
980 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
981 for (octave_idx_type i = 0; i < m; i++) \ |
8949
e31d47f2c9bb
fixes to row-reducing cummin/cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
982 if (v[i] OP r0[i]) \ |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
983 { r[i] = v[i]; ri[i] = j; } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
984 else \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
985 { r[i] = r0[i]; ri[i] = r0i[i]; } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
986 j++; v += m; r0 = r; r += m; r0i = ri; ri += m; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
987 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
988 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
989 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
990 OP_CUMMINMAX_FCN2 (mx_inline_cummin, <) |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
991 OP_CUMMINMAX_FCN2 (mx_inline_cummax, >) |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
992 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
993 #define OP_CUMMINMAX_FCNN(F) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
994 template <class T> \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
995 inline void \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
996 F (const T *v, T *r, octave_idx_type l, \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
997 octave_idx_type n, octave_idx_type u) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
998 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
999 if (! n) return; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1000 if (l == 1) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1001 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1002 for (octave_idx_type i = 0; i < u; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1003 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1004 F (v, r, n); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1005 v += n; r += n; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1006 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1007 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1008 else \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1009 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1010 for (octave_idx_type i = 0; i < u; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1011 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1012 F (v, r, l, n); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1013 v += l*n; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1014 r += l*n; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1015 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1016 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1017 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1018 template <class T> \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1019 inline void \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1020 F (const T *v, T *r, octave_idx_type *ri, \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1021 octave_idx_type l, octave_idx_type n, octave_idx_type u) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1022 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1023 if (! n) return; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1024 if (l == 1) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1025 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1026 for (octave_idx_type i = 0; i < u; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1027 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1028 F (v, r, ri, n); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1029 v += n; r += n; ri += n; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1030 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1031 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1032 else \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1033 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1034 for (octave_idx_type i = 0; i < u; i++) \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1035 { \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1036 F (v, r, ri, l, n); \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1037 v += l*n; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1038 r += l*n; ri += l*n; \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1039 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1040 } \ |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1041 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1042 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1043 OP_CUMMINMAX_FCNN (mx_inline_cummin) |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1044 OP_CUMMINMAX_FCNN (mx_inline_cummax) |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1045 |
9513
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1046 template <class T> |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1047 void mx_inline_diff (const T *v, T *r, octave_idx_type n, |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1048 octave_idx_type order) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1049 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1050 switch (order) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1051 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1052 case 1: |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1053 for (octave_idx_type i = 0; i < n-1; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1054 r[i] = v[i+1] - v[i]; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1055 break; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1056 case 2: |
9702
9ecd35a606e3
avoid some warnings from g++
John W. Eaton <jwe@octave.org>
parents:
9612
diff
changeset
|
1057 if (n > 1) |
10314
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1058 { |
07ebe522dac2
untabify liboctave C++ sources
John W. Eaton <jwe@octave.org>
parents:
10158
diff
changeset
|
1059 T lst = v[1] - v[0]; |
9513
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1060 for (octave_idx_type i = 0; i < n-2; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1061 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1062 T dif = v[i+2] - v[i+1]; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1063 r[i] = dif - lst; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1064 lst = dif; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1065 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1066 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1067 break; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1068 default: |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1069 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1070 OCTAVE_LOCAL_BUFFER (T, buf, n-1); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1071 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1072 for (octave_idx_type i = 0; i < n-1; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1073 buf[i] = v[i+1] - v[i]; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1074 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1075 for (octave_idx_type o = 2; o <= order; o++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1076 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1077 for (octave_idx_type i = 0; i < n-o; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1078 buf[i] = buf[i+1] - buf[i]; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1079 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1080 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1081 for (octave_idx_type i = 0; i < n-order; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1082 r[i] = buf[i]; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1083 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1084 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1085 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1086 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1087 template <class T> |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1088 void mx_inline_diff (const T *v, T *r, |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1089 octave_idx_type m, octave_idx_type n, |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1090 octave_idx_type order) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1091 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1092 switch (order) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1093 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1094 case 1: |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1095 for (octave_idx_type i = 0; i < m*(n-1); i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1096 r[i] = v[i+m] - v[i]; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1097 break; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1098 case 2: |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1099 for (octave_idx_type i = 0; i < n-2; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1100 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1101 for (octave_idx_type j = i*m; j < i*m+m; j++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1102 r[j] = (v[j+m+m] - v[j+m]) + (v[j+m] - v[j]); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1103 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1104 break; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1105 default: |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1106 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1107 OCTAVE_LOCAL_BUFFER (T, buf, n-1); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1108 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1109 for (octave_idx_type j = 0; j < m; j++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1110 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1111 for (octave_idx_type i = 0; i < n-1; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1112 buf[i] = v[i*m+j+m] - v[i*m+j]; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1113 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1114 for (octave_idx_type o = 2; o <= order; o++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1115 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1116 for (octave_idx_type i = 0; i < n-o; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1117 buf[i] = buf[i+1] - buf[i]; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1118 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1119 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1120 for (octave_idx_type i = 0; i < n-order; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1121 r[i*m+j] = buf[i]; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1122 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1123 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1124 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1125 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1126 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1127 template <class T> |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1128 inline void |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1129 mx_inline_diff (const T *v, T *r, |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1130 octave_idx_type l, octave_idx_type n, octave_idx_type u, |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1131 octave_idx_type order) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1132 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1133 if (! n) return; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1134 if (l == 1) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1135 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1136 for (octave_idx_type i = 0; i < u; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1137 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1138 mx_inline_diff (v, r, n, order); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1139 v += n; r += n-order; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1140 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1141 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1142 else |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1143 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1144 for (octave_idx_type i = 0; i < u; i++) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1145 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1146 mx_inline_diff (v, r, l, n, order); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1147 v += l*n; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1148 r += l*(n-order); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1149 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1150 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1151 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1152 |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1153 // Assistant function |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1154 |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1155 inline void |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1156 get_extent_triplet (const dim_vector& dims, int& dim, |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1157 octave_idx_type& l, octave_idx_type& n, |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1158 octave_idx_type& u) |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1159 { |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1160 octave_idx_type ndims = dims.length (); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1161 if (dim >= ndims) |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1162 { |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1163 l = dims.numel (); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1164 n = 1; |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1165 u = 1; |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1166 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1167 else |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1168 { |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1169 if (dim < 0) |
9513
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1170 dim = dims.first_non_singleton (); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1171 |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1172 // calculate extent triplet. |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1173 l = 1, n = dims(dim), u = 1; |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1174 for (octave_idx_type i = 0; i < dim; i++) |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1175 l *= dims (i); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1176 for (octave_idx_type i = dim + 1; i < ndims; i++) |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1177 u *= dims (i); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1178 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1179 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1180 |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1181 // Appliers. |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1182 // FIXME: is this the best design? C++ gives a lot of options here... |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1183 // maybe it can be done without an explicit parameter? |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1184 |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1185 template <class ArrayType, class T> |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1186 inline ArrayType |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1187 do_mx_red_op (const Array<T>& src, int dim, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
1188 void (*mx_red_op) (const T *, AELEMT(ArrayType) *, |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1189 octave_idx_type, octave_idx_type, octave_idx_type)) |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1190 { |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1191 octave_idx_type l, n, u; |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1192 dim_vector dims = src.dims (); |
8743
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
1193 // M*b inconsistency: sum([]) = 0 etc. |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
1194 if (dims.length () == 2 && dims(0) == 0 && dims(1) == 0) |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
1195 dims (1) = 1; |
1bd918cfb6e2
reimplement any & all using the new reduction code
Jaroslav Hajek <highegg@gmail.com>
parents:
8736
diff
changeset
|
1196 |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1197 get_extent_triplet (dims, dim, l, n, u); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1198 |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1199 // Reduction operation reduces the array size. |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1200 if (dim < dims.length ()) dims(dim) = 1; |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1201 dims.chop_trailing_singletons (); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1202 |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1203 ArrayType ret (dims); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1204 mx_red_op (src.data (), ret.fortran_vec (), l, n, u); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1205 |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1206 return ret; |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1207 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1208 |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1209 template <class ArrayType, class T> |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1210 inline ArrayType |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1211 do_mx_cum_op (const Array<T>& src, int dim, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
1212 void (*mx_cum_op) (const T *, AELEMT(ArrayType) *, |
8736
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1213 octave_idx_type, octave_idx_type, octave_idx_type)) |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1214 { |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1215 octave_idx_type l, n, u; |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1216 dim_vector dims = src.dims (); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1217 get_extent_triplet (dims, dim, l, n, u); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1218 |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1219 // Cumulative operation doesn't reduce the array size. |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1220 ArrayType ret (dims); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1221 mx_cum_op (src.data (), ret.fortran_vec (), l, n, u); |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1222 |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1223 return ret; |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1224 } |
53b4fdeacc2e
improve reduction functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8650
diff
changeset
|
1225 |
8751
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1226 template <class ArrayType> |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1227 inline ArrayType |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1228 do_mx_minmax_op (const ArrayType& src, int dim, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
1229 void (*mx_minmax_op) (const AELEMT(ArrayType) *, AELEMT(ArrayType) *, |
8751
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1230 octave_idx_type, octave_idx_type, octave_idx_type)) |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1231 { |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1232 octave_idx_type l, n, u; |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1233 dim_vector dims = src.dims (); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1234 get_extent_triplet (dims, dim, l, n, u); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1235 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1236 // If the dimension is zero, we don't do anything. |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1237 if (dim < dims.length () && dims(dim) != 0) dims(dim) = 1; |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1238 dims.chop_trailing_singletons (); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1239 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1240 ArrayType ret (dims); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1241 mx_minmax_op (src.data (), ret.fortran_vec (), l, n, u); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1242 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1243 return ret; |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1244 } |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1245 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1246 template <class ArrayType> |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1247 inline ArrayType |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1248 do_mx_minmax_op (const ArrayType& src, Array<octave_idx_type>& idx, int dim, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
1249 void (*mx_minmax_op) (const AELEMT(ArrayType) *, AELEMT(ArrayType) *, |
8751
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1250 octave_idx_type *, |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1251 octave_idx_type, octave_idx_type, octave_idx_type)) |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1252 { |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1253 octave_idx_type l, n, u; |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1254 dim_vector dims = src.dims (); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1255 get_extent_triplet (dims, dim, l, n, u); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1256 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1257 // If the dimension is zero, we don't do anything. |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1258 if (dim < dims.length () && dims(dim) != 0) dims(dim) = 1; |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1259 dims.chop_trailing_singletons (); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1260 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1261 ArrayType ret (dims); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1262 if (idx.dims () != dims) idx = Array<octave_idx_type> (dims); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1263 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1264 mx_minmax_op (src.data (), ret.fortran_vec (), idx.fortran_vec (), |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1265 l, n, u); |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1266 |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1267 return ret; |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1268 } |
9f7ce4bf7650
optimize min/max functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8743
diff
changeset
|
1269 |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1270 template <class ArrayType> |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1271 inline ArrayType |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1272 do_mx_cumminmax_op (const ArrayType& src, int dim, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
1273 void (*mx_cumminmax_op) (const AELEMT(ArrayType) *, AELEMT(ArrayType) *, |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1274 octave_idx_type, octave_idx_type, octave_idx_type)) |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1275 { |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1276 octave_idx_type l, n, u; |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1277 dim_vector dims = src.dims (); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1278 get_extent_triplet (dims, dim, l, n, u); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1279 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1280 ArrayType ret (dims); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1281 mx_cumminmax_op (src.data (), ret.fortran_vec (), l, n, u); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1282 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1283 return ret; |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1284 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1285 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1286 template <class ArrayType> |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1287 inline ArrayType |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1288 do_mx_cumminmax_op (const ArrayType& src, Array<octave_idx_type>& idx, int dim, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
1289 void (*mx_cumminmax_op) (const AELEMT(ArrayType) *, AELEMT(ArrayType) *, |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1290 octave_idx_type *, |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1291 octave_idx_type, octave_idx_type, octave_idx_type)) |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1292 { |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1293 octave_idx_type l, n, u; |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1294 dim_vector dims = src.dims (); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1295 get_extent_triplet (dims, dim, l, n, u); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1296 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1297 ArrayType ret (dims); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1298 if (idx.dims () != dims) idx = Array<octave_idx_type> (dims); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1299 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1300 mx_cumminmax_op (src.data (), ret.fortran_vec (), idx.fortran_vec (), |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1301 l, n, u); |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1302 |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1303 return ret; |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1304 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
8776
diff
changeset
|
1305 |
9513
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1306 template <class ArrayType> |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1307 inline ArrayType |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1308 do_mx_diff_op (const ArrayType& src, int dim, octave_idx_type order, |
9800
ef4c4186cb47
improve some mx_inline loops
Jaroslav Hajek <highegg@gmail.com>
parents:
9766
diff
changeset
|
1309 void (*mx_diff_op) (const AELEMT(ArrayType) *, AELEMT(ArrayType) *, |
9513
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1310 octave_idx_type, octave_idx_type, octave_idx_type, |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1311 octave_idx_type)) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1312 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1313 octave_idx_type l, n, u; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1314 if (order <= 0) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1315 return src; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1316 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1317 dim_vector dims = src.dims (); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1318 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1319 get_extent_triplet (dims, dim, l, n, u); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1320 if (dim >= dims.length ()) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1321 dims.resize (dim+1, 1); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1322 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1323 if (dims(dim) <= order) |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1324 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1325 dims (dim) = 0; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1326 return ArrayType (dims); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1327 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1328 else |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1329 { |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1330 dims(dim) -= order; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1331 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1332 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1333 ArrayType ret (dims); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1334 mx_diff_op (src.data (), ret.fortran_vec (), l, n, u, order); |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1335 |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1336 return ret; |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1337 } |
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8949
diff
changeset
|
1338 |
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1339 // Fast extra-precise summation. According to |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1340 // T. Ogita, S. M. Rump, S. Oishi: |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1341 // Accurate Sum And Dot Product, |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1342 // SIAM J. Sci. Computing, Vol. 26, 2005 |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1343 |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1344 template <class T> |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1345 inline void twosum_accum (T& s, T& e, |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1346 const T& x) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1347 { |
9766
82fe4db20dec
fix bad FLOAT_TRUNCATE in mx-inlines.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9743
diff
changeset
|
1348 T s1 = s + x, t = s1 - s, e1 = (s - (s1 - t)) + (x - t); |
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1349 s = s1; |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1350 e += e1; |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1351 } |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1352 |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1353 template <class T> |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1354 inline T |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1355 mx_inline_xsum (const T *v, octave_idx_type n) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1356 { |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1357 T s = 0, e = 0; |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1358 for (octave_idx_type i = 0; i < n; i++) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1359 twosum_accum (s, e, v[i]); |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1360 |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1361 return s + e; |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1362 } |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1363 |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1364 template <class T> |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1365 inline void |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1366 mx_inline_xsum (const T *v, T *r, |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1367 octave_idx_type m, octave_idx_type n) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1368 { |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1369 OCTAVE_LOCAL_BUFFER (T, e, m); |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1370 for (octave_idx_type i = 0; i < m; i++) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1371 e[i] = r[i] = T (); |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1372 |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1373 for (octave_idx_type j = 0; j < n; j++) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1374 { |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1375 for (octave_idx_type i = 0; i < m; i++) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1376 twosum_accum (r[i], e[i], v[i]); |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1377 |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1378 v += m; |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1379 } |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1380 |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1381 for (octave_idx_type i = 0; i < m; i++) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1382 r[i] += e[i]; |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1383 } |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1384 |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1385 OP_RED_FCNN (mx_inline_xsum, T, T) |
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9702
diff
changeset
|
1386 |
2804 | 1387 #endif |