octave-lyh: liboctave/mx-inlines.cc annotate

annotate liboctave/mx-inlines.cc @ 8920:eb63fbe60fab

update copyright notices

author	John W. Eaton <jwe@octave.org>
date	Sat, 07 Mar 2009 10:41:27 -0500
parents	4ab9654eceac
children	e31d47f2c9bb

rev	line source
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	1 /*
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	2
7017 a1dbe9d80eee [project @ 2007-10-12 21:27:11 by jwe] jwe parents: 7016 diff changeset	3 Copyright (C) 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
8920 eb63fbe60fab update copyright notices John W. Eaton <jwe@octave.org> parents: 8899 diff changeset	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 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	7
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	8 This file is part of Octave.
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	9
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	10 Octave is free software; you can redistribute it and/or modify it
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	11 under the terms of the GNU General Public License as published by the
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 5972 diff changeset	12 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 5972 diff changeset	13 option) any later version.
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	14
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	15 Octave is distributed in the hope that it will be useful, but WITHOUT
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	18 for more details.
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	19
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	20 You should have received a copy of the GNU General Public License
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 5972 diff changeset	21 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 5972 diff changeset	22 <http://www.gnu.org/licenses/>.
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	23
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	24 */
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	25
2828 92826d6e8bd9 [project @ 1997-03-25 23:41:41 by jwe] jwe parents: 2811 diff changeset	26 #if !defined (octave_mx_inlines_h)
92826d6e8bd9 [project @ 1997-03-25 23:41:41 by jwe] jwe parents: 2811 diff changeset	27 #define octave_mx_inlines_h 1
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	28
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	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>
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	31
5525 558c69736dc0 [project @ 2005-11-01 00:49:50 by jwe] jwe parents: 5524 diff changeset	32 #include "quit.h"
558c69736dc0 [project @ 2005-11-01 00:49:50 by jwe] jwe parents: 5524 diff changeset	33
1650 23aa282707e8 [project @ 1995-12-20 06:53:12 by jwe] jwe parents: 1574 diff changeset	34 #include "oct-cmplx.h"
8758 83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	35 #include "oct-locbuf.h"
8897 fd83cc87f55e add missing include Jaroslav Hajek <highegg@gmail.com> parents: 8780 diff changeset	36 #include "oct-inttypes.h"
461 00f8b2242a18 [project @ 1994-06-06 00:45:57 by jwe] jwe parents: 238 diff changeset	37
8380 dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	38 template <class R, class S>
dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	39 inline void
dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	40 mx_inline_fill_vs (R *r, size_t n, S s)
dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	41 {
dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	42 for (size_t i = 0; i < n; i++)
dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	43 r[i] = s;
dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	44 }
dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	45
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	46 #define VS_OP_FCN(F, OP) \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	47 template <class R, class V, class S> \
3262 eaa639880b51 [project @ 1999-08-20 19:06:48 by jwe] jwe parents: 3107 diff changeset	48 inline void \
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	49 F ## _vs (R r, const V v, size_t n, S s) \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	50 { \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	51 for (size_t i = 0; i < n; i++) \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	52 r[i] = v[i] OP s; \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	53 }
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	54
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	55 VS_OP_FCN (mx_inline_add, +)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	56 VS_OP_FCN (mx_inline_subtract, -)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	57 VS_OP_FCN (mx_inline_multiply, *)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	58 VS_OP_FCN (mx_inline_divide, /)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	59
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	60 #define VS_OP(F, OP, R, V, S) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	61 static inline R * \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	62 F (const V *v, size_t n, S s) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	63 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	64 R *r = 0; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	65 if (n > 0) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	66 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	67 r = new R [n]; \
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	68 F ## _vs (r, v, n, s); \
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	69 } \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	70 return r; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	71 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	72
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	73 #define VS_OPS(R, V, S) \
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	74 VS_OP (mx_inline_add, +, R, V, S) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	75 VS_OP (mx_inline_subtract, -, R, V, S) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	76 VS_OP (mx_inline_multiply, *, R, V, S) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	77 VS_OP (mx_inline_divide, /, R, V, S)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	78
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	79 VS_OPS (double, double, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	80 VS_OPS (Complex, double, Complex)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	81 VS_OPS (Complex, Complex, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	82 VS_OPS (Complex, Complex, Complex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	83
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	84 VS_OPS (float, float, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	85 VS_OPS (FloatComplex, float, FloatComplex)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	86 VS_OPS (FloatComplex, FloatComplex, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	87 VS_OPS (FloatComplex, FloatComplex, FloatComplex)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	88
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	89 #define SV_OP_FCN(F, OP) \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	90 template <class R, class S, class V> \
3262 eaa639880b51 [project @ 1999-08-20 19:06:48 by jwe] jwe parents: 3107 diff changeset	91 inline void \
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	92 F ## _sv (R r, S s, const V v, size_t n) \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	93 { \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	94 for (size_t i = 0; i < n; i++) \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	95 r[i] = s OP v[i]; \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	96 } \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	97
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	98 SV_OP_FCN (mx_inline_add, +)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	99 SV_OP_FCN (mx_inline_subtract, -)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	100 SV_OP_FCN (mx_inline_multiply, *)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	101 SV_OP_FCN (mx_inline_divide, /)
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	102
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	103 #define SV_OP(F, OP, R, S, V) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	104 static inline R * \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	105 F (S s, const V *v, size_t n) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	106 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	107 R *r = 0; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	108 if (n > 0) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	109 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	110 r = new R [n]; \
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	111 F ## _sv (r, s, v, n); \
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	112 } \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	113 return r; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	114 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	115
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	116 #define SV_OPS(R, S, V) \
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	117 SV_OP (mx_inline_add, +, R, S, V) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	118 SV_OP (mx_inline_subtract, -, R, S, V) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	119 SV_OP (mx_inline_multiply, *, R, S, V) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	120 SV_OP (mx_inline_divide, /, R, S, V)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	121
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	122 SV_OPS (double, double, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	123 SV_OPS (Complex, double, Complex)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	124 SV_OPS (Complex, Complex, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	125 SV_OPS (Complex, Complex, Complex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	126
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	127 SV_OPS (float, float, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	128 SV_OPS (FloatComplex, float, FloatComplex)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	129 SV_OPS (FloatComplex, FloatComplex, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	130 SV_OPS (FloatComplex, FloatComplex, FloatComplex)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	131
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	132 #define VV_OP_FCN(F, OP) \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	133 template <class R, class T1, class T2> \
3262 eaa639880b51 [project @ 1999-08-20 19:06:48 by jwe] jwe parents: 3107 diff changeset	134 inline void \
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	135 F ## _vv (R r, const T1 v1, const T2 *v2, size_t n) \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	136 { \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	137 for (size_t i = 0; i < n; i++) \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	138 r[i] = v1[i] OP v2[i]; \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	139 } \
1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	140
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	141 VV_OP_FCN (mx_inline_add, +)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	142 VV_OP_FCN (mx_inline_subtract, -)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	143 VV_OP_FCN (mx_inline_multiply, *)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	144 VV_OP_FCN (mx_inline_divide, /)
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	145
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	146 #define VV_OP(F, OP, R, T1, T2) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	147 static inline R * \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	148 F (const T1 v1, const T2 v2, size_t n) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	149 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	150 R *r = 0; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	151 if (n > 0) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	152 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	153 r = new R [n]; \
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	154 F ## _vv (r, v1, v2, n); \
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	155 } \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	156 return r; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	157 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	158
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	159 #define VV_OPS(R, T1, T2) \
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	160 VV_OP (mx_inline_add, +, R, T1, T2) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	161 VV_OP (mx_inline_subtract, -, R, T1, T2) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	162 VV_OP (mx_inline_multiply, *, R, T1, T2) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	163 VV_OP (mx_inline_divide, /, R, T1, T2)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	164
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	165 VV_OPS (double, double, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	166 VV_OPS (Complex, double, Complex)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	167 VV_OPS (Complex, Complex, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	168 VV_OPS (Complex, Complex, Complex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	169
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	170 VV_OPS (float, float, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	171 VV_OPS (FloatComplex, float, FloatComplex)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	172 VV_OPS (FloatComplex, FloatComplex, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	173 VV_OPS (FloatComplex, FloatComplex, FloatComplex)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	174
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	175 #define VS_OP2(F, OP, V, S) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	176 static inline V * \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	177 F (V *v, size_t n, S s) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	178 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	179 for (size_t i = 0; i < n; i++) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	180 v[i] OP s; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	181 return v; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	182 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	183
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	184 #define VS_OP2S(V, S) \
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	185 VS_OP2 (mx_inline_add2, +=, V, S) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	186 VS_OP2 (mx_inline_subtract2, -=, V, S) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	187 VS_OP2 (mx_inline_multiply2, *=, V, S) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	188 VS_OP2 (mx_inline_divide2, /=, V, S) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	189 VS_OP2 (mx_inline_copy, =, V, S)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	190
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	191 VS_OP2S (double, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	192 VS_OP2S (Complex, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	193 VS_OP2S (Complex, Complex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	194
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	195 VS_OP2S (float, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	196 VS_OP2S (FloatComplex, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	197 VS_OP2S (FloatComplex, FloatComplex)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	198
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	199 #define VV_OP2(F, OP, T1, T2) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	200 static inline T1 * \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	201 F (T1 v1, const T2 v2, size_t n) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	202 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	203 for (size_t i = 0; i < n; i++) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	204 v1[i] OP v2[i]; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	205 return v1; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	206 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	207
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	208 #define VV_OP2S(T1, T2) \
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	209 VV_OP2 (mx_inline_add2, +=, T1, T2) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	210 VV_OP2 (mx_inline_subtract2, -=, T1, T2) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	211 VV_OP2 (mx_inline_multiply2, *=, T1, T2) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	212 VV_OP2 (mx_inline_divide2, /=, T1, T2) \
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	213 VV_OP2 (mx_inline_copy, =, T1, T2)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	214
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	215 VV_OP2S (double, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	216 VV_OP2S (Complex, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	217 VV_OP2S (Complex, Complex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	218
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	219 VV_OP2S (float, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	220 VV_OP2S (FloatComplex, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	221 VV_OP2S (FloatComplex, FloatComplex)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	222
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	223 #define OP_EQ_FCN(T1, T2) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	224 static inline bool \
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	225 mx_inline_equal (const T1 x, const T2 y, size_t n) \
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	226 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	227 for (size_t i = 0; i < n; i++) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	228 if (x[i] != y[i]) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	229 return false; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	230 return true; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	231 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	232
2828 92826d6e8bd9 [project @ 1997-03-25 23:41:41 by jwe] jwe parents: 2811 diff changeset	233 OP_EQ_FCN (bool, bool)
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	234 OP_EQ_FCN (char, char)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	235 OP_EQ_FCN (double, double)
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	236 OP_EQ_FCN (Complex, Complex)
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	237 OP_EQ_FCN (float, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	238 OP_EQ_FCN (FloatComplex, FloatComplex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	239
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	240 #define OP_DUP_FCN(OP, F, R, T) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	241 static inline R * \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	242 F (const T *x, size_t n) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	243 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	244 R *r = 0; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	245 if (n > 0) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	246 { \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	247 r = new R [n]; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	248 for (size_t i = 0; i < n; i++) \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	249 r[i] = OP (x[i]); \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	250 } \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	251 return r; \
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	252 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	253
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	254 OP_DUP_FCN (, mx_inline_dup, double, double)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	255 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	256 OP_DUP_FCN (, mx_inline_dup, float, float)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	257 OP_DUP_FCN (, mx_inline_dup, FloatComplex, FloatComplex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	258
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	259 // These should really return a bool *. Also, they should probably be
eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	260 // in with a collection of other element-by-element boolean ops.
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	261 OP_DUP_FCN (0.0 ==, mx_inline_not, double, double)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	262 OP_DUP_FCN (0.0 ==, mx_inline_not, double, Complex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	263
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	264 OP_DUP_FCN (, mx_inline_make_complex, Complex, double)
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	265
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	266 OP_DUP_FCN (-, mx_inline_change_sign, double, double)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	267 OP_DUP_FCN (-, mx_inline_change_sign, Complex, Complex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	268
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	269 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	270 OP_DUP_FCN (std::abs, mx_inline_cabs_dup, double, Complex)
3769 7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	271 OP_DUP_FCN (real, mx_inline_real_dup, double, Complex)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	272 OP_DUP_FCN (imag, mx_inline_imag_dup, double, Complex)
7c8e3c42ed04 [project @ 2001-01-31 22:15:51 by jwe] jwe parents: 3504 diff changeset	273 OP_DUP_FCN (conj, mx_inline_conj_dup, Complex, Complex)
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	274
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	275 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	276 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	277
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	278 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	279
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	280 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	281 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	282
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	283 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	284 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	285 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	286 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	287 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	288
8899 4ab9654eceac update comment Jaroslav Hajek <highegg@gmail.com> parents: 8897 diff changeset	289 // FIXME: Due to a performance defect in g++ (<= 4.3), std::norm is slow unless
4ab9654eceac update comment Jaroslav Hajek <highegg@gmail.com> parents: 8897 diff changeset	290 // ffast-math is on (not by default even with -O3). The following helper function
4ab9654eceac update comment Jaroslav Hajek <highegg@gmail.com> parents: 8897 diff changeset	291 // gives the expected straightforward implementation of std::norm.
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	292 template <class T>
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	293 inline T cabsq (const std::complex<T>& c)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	294 { return c.real () * c.real () + c.imag () * c.imag (); }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	295
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	296 #define OP_RED_SUM(ac, el) ac += el
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	297 #define OP_RED_PROD(ac, el) ac *= el
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	298 #define OP_RED_SUMSQ(ac, el) ac += el*el
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	299 #define OP_RED_SUMSQC(ac, el) ac += cabsq (el)
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	300
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	301 // default. works for integers and bool.
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	302 template <class T>
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	303 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	304 template <class T>
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	305 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	306 // for octave_ints
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	307 template <class T>
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	308 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	309 template <class T>
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	310 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	311 // 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	312 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	313 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	314 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	315 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	316 // Ditto for complex.
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	317 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	318 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	319 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	320 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	321
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	322 // 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	323 #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	324 #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	325
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	326 #define OP_RED_FCN(F, TSRC, TRES, OP, ZERO) \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	327 template <class T> \
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	328 inline TRES \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	329 F (const TSRC* v, octave_idx_type n) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	330 { \
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	331 TRES ac = ZERO; \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	332 for (octave_idx_type i = 0; i < n; i++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	333 OP(ac, v[i]); \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	334 return ac; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	335 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	336
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	337 OP_RED_FCN (mx_inline_sum, T, T, OP_RED_SUM, 0)
8756 d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8751 diff changeset	338 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	339 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	340 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	341 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	342 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	343 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	344
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	345
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	346 #define OP_RED_FCN2(F, TSRC, TRES, OP, ZERO) \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	347 template <class T> \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	348 inline void \
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	349 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	350 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	351 for (octave_idx_type i = 0; i < m; i++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	352 r[i] = ZERO; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	353 for (octave_idx_type j = 0; j < n; j++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	354 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	355 for (octave_idx_type i = 0; i < m; i++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	356 OP(r[i], v[i]); \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	357 v += m; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	358 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	359 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	360
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	361 OP_RED_FCN2 (mx_inline_sum, T, T, OP_RED_SUM, 0)
8756 d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8751 diff changeset	362 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	363 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	364 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	365 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	366
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	367 // 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	368 // 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	369 // 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	370
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	371 #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	372 template <class T> \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	373 inline void \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	374 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	375 { \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	376 /* 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	377 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	378 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	379 octave_idx_type nact = m; \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	380 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	381 { \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	382 octave_idx_type k = 0; \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	383 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	384 { \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	385 octave_idx_type ia = iact[i]; \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	386 if (! PRED (v[ia])) \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	387 iact[k++] = ia; \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	388 } \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	389 nact = k; \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	390 v += m; \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	391 } \
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	392 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	393 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	394 }
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	395
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	396 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	397 OP_ROW_SHORT_CIRCUIT (mx_inline_all, xis_false, true)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	398
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	399 #define OP_RED_FCNN(F, TSRC, TRES) \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	400 template <class T> \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	401 inline void \
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	402 F (const TSRC v, TRES r, octave_idx_type l, \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	403 octave_idx_type n, octave_idx_type u) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	404 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	405 if (l == 1) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	406 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	407 for (octave_idx_type i = 0; i < u; i++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	408 { \
8756 d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8751 diff changeset	409 r[i] = F<T> (v, n); \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	410 v += n; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	411 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	412 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	413 else \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	414 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	415 for (octave_idx_type i = 0; i < u; i++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	416 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	417 F (v, r, l, n); \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	418 v += l*n; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	419 r += l; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	420 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	421 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	422 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	423
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	424 OP_RED_FCNN (mx_inline_sum, T, T)
8756 d0755c9db5ed implement fast logical sum (counting) Jaroslav Hajek <highegg@gmail.com> parents: 8751 diff changeset	425 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	426 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	427 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	428 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	429 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	430 OP_RED_FCNN (mx_inline_all, T, bool)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	431
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	432 #define OP_CUM_FCN(F, TSRC, TRES, OP) \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	433 template <class T> \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	434 inline void \
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	435 F (const TSRC v, TRES r, octave_idx_type n) \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	436 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	437 if (n) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	438 { \
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	439 TRES t = r[0] = v[0]; \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	440 for (octave_idx_type i = 1; i < n; i++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	441 r[i] = t = t OP v[i]; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	442 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	443 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	444
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	445 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	446 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	447 OP_CUM_FCN (mx_inline_cumcount, bool, T, +)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	448
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	449 #define OP_CUM_FCN2(F, TSRC, TRES, OP) \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	450 template <class T> \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	451 inline void \
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	452 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	453 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	454 if (n) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	455 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	456 for (octave_idx_type i = 0; i < m; i++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	457 r[i] = v[i]; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	458 const T *r0 = r; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	459 for (octave_idx_type j = 1; j < n; j++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	460 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	461 r += m; v += m; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	462 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	463 r[i] = r0[i] OP v[i]; \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	464 r0 += m; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	465 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	466 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	467 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	468
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	469 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	470 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	471 OP_CUM_FCN2 (mx_inline_cumcount, bool, T, *)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	472
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	473 #define OP_CUM_FCNN(F, TSRC, TRES) \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	474 template <class T> \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	475 inline void \
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	476 F (const TSRC v, TRES r, octave_idx_type l, \
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	477 octave_idx_type n, octave_idx_type u) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	478 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	479 if (l == 1) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	480 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	481 for (octave_idx_type i = 0; i < u; i++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	482 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	483 F (v, r, n); \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	484 v += n; r += n; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	485 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	486 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	487 else \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	488 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	489 for (octave_idx_type i = 0; i < u; i++) \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	490 { \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	491 F (v, r, l, n); \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	492 v += l*n; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	493 r += l*n; \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	494 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	495 } \
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	496 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	497
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	498 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	499 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	500 OP_CUM_FCNN (mx_inline_cumcount, bool, T)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	501
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	502 #define OP_MINMAX_FCN(F, OP) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	503 template <class T> \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	504 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	505 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	506 if (! n) return; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	507 T tmp = v[0]; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	508 octave_idx_type i = 1; \
8776 d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	509 if (xisnan (tmp)) \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	510 { \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	511 for (; i < n && xisnan (v[i]); i++) ; \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	512 if (i < n) tmp = v[i]; \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	513 } \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	514 for (; i < n; i++) \
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	515 if (v[i] OP tmp) tmp = v[i]; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	516 *r = tmp; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	517 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	518 template <class T> \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	519 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	520 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	521 if (! n) return; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	522 T tmp = v[0]; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	523 octave_idx_type tmpi = 0; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	524 octave_idx_type i = 1; \
8776 d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	525 if (xisnan (tmp)) \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	526 { \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	527 for (; i < n && xisnan (v[i]); i++) ; \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	528 if (i < n) { tmp = v[i]; tmpi = i; } \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	529 } \
d23c33ec6bd3 fix min/max behaviour with NaNs Jaroslav Hajek <highegg@gmail.com> parents: 8759 diff changeset	530 for (; i < n; i++) \
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	531 if (v[i] OP tmp) { tmp = v[i]; tmpi = i; }\
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	532 *r = tmp; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	533 *ri = tmpi; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	534 }
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	535
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	536 OP_MINMAX_FCN (mx_inline_min, <)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	537 OP_MINMAX_FCN (mx_inline_max, >)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	538
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	539 // 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	540 // 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	541 // proceed to a faster code.
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	542
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	543 #define OP_MINMAX_FCN2(F, OP) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	544 template <class T> \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	545 inline void \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	546 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	547 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	548 if (! n) return; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	549 bool nan = false; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	550 octave_idx_type j = 0; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	551 for (octave_idx_type i = 0; i < m; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	552 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	553 r[i] = v[i]; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	554 if (xisnan (v[i])) nan = true; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	555 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	556 j++; v += m; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	557 while (nan && j < n) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	558 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	559 nan = false; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	560 for (octave_idx_type i = 0; i < m; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	561 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	562 if (xisnan (v[i])) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	563 nan = true; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	564 else if (xisnan (r[i]) \|\| v[i] OP r[i]) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	565 r[i] = v[i]; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	566 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	567 j++; v += m; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	568 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	569 while (j < n) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	570 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	571 for (octave_idx_type i = 0; i < m; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	572 if (v[i] OP r[i]) r[i] = v[i]; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	573 j++; v += m; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	574 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	575 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	576 template <class T> \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	577 inline void \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	578 F (const T v, T r, octave_idx_type *ri, \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	579 octave_idx_type m, octave_idx_type n) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	580 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	581 if (! n) return; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	582 bool nan = false; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	583 octave_idx_type j = 0; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	584 for (octave_idx_type i = 0; i < m; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	585 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	586 r[i] = v[i]; ri[i] = j; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	587 if (xisnan (v[i])) nan = true; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	588 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	589 j++; v += m; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	590 while (nan && j < n) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	591 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	592 nan = false; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	593 for (octave_idx_type i = 0; i < m; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	594 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	595 if (xisnan (v[i])) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	596 nan = true; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	597 else if (xisnan (r[i]) \|\| v[i] OP r[i]) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	598 { r[i] = v[i]; ri[i] = j; } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	599 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	600 j++; v += m; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	601 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	602 while (j < n) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	603 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	604 for (octave_idx_type i = 0; i < m; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	605 if (v[i] OP r[i]) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	606 { r[i] = v[i]; ri[i] = j; } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	607 j++; v += m; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	608 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	609 }
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	610
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	611 OP_MINMAX_FCN2 (mx_inline_min, <)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	612 OP_MINMAX_FCN2 (mx_inline_max, >)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	613
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	614 #define OP_MINMAX_FCNN(F) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	615 template <class T> \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	616 inline void \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	617 F (const T v, T r, octave_idx_type l, \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	618 octave_idx_type n, octave_idx_type u) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	619 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	620 if (! n) return; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	621 if (l == 1) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	622 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	623 for (octave_idx_type i = 0; i < u; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	624 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	625 F (v, r, n); \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	626 v += n; r++; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	627 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	628 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	629 else \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	630 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	631 for (octave_idx_type i = 0; i < u; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	632 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	633 F (v, r, l, n); \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	634 v += l*n; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	635 r += l; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	636 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	637 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	638 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	639 template <class T> \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	640 inline void \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	641 F (const T v, T r, octave_idx_type *ri, \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	642 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	643 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	644 if (! n) return; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	645 if (l == 1) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	646 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	647 for (octave_idx_type i = 0; i < u; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	648 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	649 F (v, r, ri, n); \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	650 v += n; r++; ri++; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	651 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	652 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	653 else \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	654 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	655 for (octave_idx_type i = 0; i < u; i++) \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	656 { \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	657 F (v, r, ri, l, n); \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	658 v += l*n; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	659 r += l; ri += l; \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	660 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	661 } \
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	662 }
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	663
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	664 OP_MINMAX_FCNN (mx_inline_min)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	665 OP_MINMAX_FCNN (mx_inline_max)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	666
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	667 #define OP_CUMMINMAX_FCN(F, OP) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	668 template <class T> \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	669 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	670 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	671 if (! n) return; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	672 T tmp = v[0]; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	673 octave_idx_type i = 1, j = 0; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	674 if (xisnan (tmp)) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	675 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	676 for (; i < n && xisnan (v[i]); i++) ; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	677 for (; j < i; j++) r[j] = tmp; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	678 if (i < n) tmp = v[i]; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	679 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	680 for (; i < n; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	681 if (v[i] OP tmp) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	682 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	683 for (; j < i; j++) r[j] = tmp; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	684 tmp = v[i]; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	685 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	686 for (; j < i; j++) r[j] = tmp; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	687 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	688 template <class T> \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	689 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	690 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	691 if (! n) return; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	692 T tmp = v[0]; octave_idx_type tmpi = 0; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	693 octave_idx_type i = 1, j = 0; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	694 if (xisnan (tmp)) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	695 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	696 for (; i < n && xisnan (v[i]); i++) ; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	697 for (; j < i; j++) { r[j] = tmp; ri[j] = tmpi; } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	698 if (i < n) { tmp = v[i]; tmpi = i; } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	699 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	700 for (; i < n; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	701 if (v[i] OP tmp) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	702 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	703 for (; j < i; j++) { r[j] = tmp; ri[j] = tmpi; } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	704 tmp = v[i]; tmpi = i; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	705 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	706 for (; j < i; j++) { r[j] = tmp; ri[j] = tmpi; } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	707 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	708
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	709 OP_CUMMINMAX_FCN (mx_inline_cummin, <)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	710 OP_CUMMINMAX_FCN (mx_inline_cummax, >)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	711
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	712 // 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	713 // 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	714 // proceed to a faster code.
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	715
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	716 #define OP_CUMMINMAX_FCN2(F, OP) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	717 template <class T> \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	718 inline void \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	719 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	720 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	721 if (! n) return; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	722 bool nan = false; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	723 const T *r0; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	724 octave_idx_type j = 0; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	725 for (octave_idx_type i = 0; i < m; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	726 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	727 r[i] = v[i]; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	728 if (xisnan (v[i])) nan = true; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	729 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	730 j++; v += m; r0 = r; r += m; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	731 while (nan && j < n) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	732 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	733 nan = false; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	734 for (octave_idx_type i = 0; i < m; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	735 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	736 if (xisnan (v[i])) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	737 { r[i] = r0[i]; nan = true; } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	738 else if (xisnan (r[i]) \|\| v[i] OP r[i]) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	739 r[i] = v[i]; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	740 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	741 j++; v += m; r0 = r; r += m; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	742 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	743 while (j < n) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	744 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	745 for (octave_idx_type i = 0; i < m; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	746 if (v[i] OP r[i]) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	747 r[i] = v[i]; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	748 else \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	749 r[i] = r0[i]; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	750 j++; v += m; r0 = r; r += m; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	751 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	752 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	753 template <class T> \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	754 inline void \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	755 F (const T v, T r, octave_idx_type *ri, \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	756 octave_idx_type m, octave_idx_type n) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	757 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	758 if (! n) return; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	759 bool nan = false; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	760 const T r0; const octave_idx_type r0i; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	761 octave_idx_type j = 0; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	762 for (octave_idx_type i = 0; i < m; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	763 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	764 r[i] = v[i]; ri[i] = 0; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	765 if (xisnan (v[i])) nan = true; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	766 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	767 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	768 while (nan && j < n) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	769 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	770 nan = false; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	771 for (octave_idx_type i = 0; i < m; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	772 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	773 if (xisnan (v[i])) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	774 { r[i] = r0[i]; ri[i] = r0i[i]; nan = true; } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	775 else if (xisnan (r[i]) \|\| v[i] OP r[i]) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	776 { r[i] = v[i]; ri[i] = j; }\
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	777 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	778 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	779 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	780 while (j < n) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	781 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	782 for (octave_idx_type i = 0; i < m; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	783 if (v[i] OP r[i]) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	784 { r[i] = v[i]; ri[i] = j; } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	785 else \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	786 { r[i] = r0[i]; ri[i] = r0i[i]; } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	787 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	788 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	789 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	790
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	791 OP_CUMMINMAX_FCN2 (mx_inline_cummin, <)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	792 OP_CUMMINMAX_FCN2 (mx_inline_cummax, >)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	793
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	794 #define OP_CUMMINMAX_FCNN(F) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	795 template <class T> \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	796 inline void \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	797 F (const T v, T r, octave_idx_type l, \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	798 octave_idx_type n, octave_idx_type u) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	799 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	800 if (! n) return; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	801 if (l == 1) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	802 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	803 for (octave_idx_type i = 0; i < u; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	804 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	805 F (v, r, n); \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	806 v += n; r += n; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	807 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	808 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	809 else \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	810 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	811 for (octave_idx_type i = 0; i < u; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	812 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	813 F (v, r, l, n); \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	814 v += l*n; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	815 r += l*n; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	816 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	817 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	818 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	819 template <class T> \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	820 inline void \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	821 F (const T v, T r, octave_idx_type *ri, \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	822 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	823 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	824 if (! n) return; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	825 if (l == 1) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	826 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	827 for (octave_idx_type i = 0; i < u; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	828 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	829 F (v, r, ri, n); \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	830 v += n; r += n; ri += n; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	831 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	832 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	833 else \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	834 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	835 for (octave_idx_type i = 0; i < u; i++) \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	836 { \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	837 F (v, r, ri, l, n); \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	838 v += l*n; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	839 r += ln; ri += ln; \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	840 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	841 } \
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	842 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	843
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	844 OP_CUMMINMAX_FCNN (mx_inline_cummin)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	845 OP_CUMMINMAX_FCNN (mx_inline_cummax)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	846
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	847 // Assistant function
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	848
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	849 inline void
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	850 get_extent_triplet (const dim_vector& dims, int& dim,
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	851 octave_idx_type& l, octave_idx_type& n,
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	852 octave_idx_type& u)
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	853 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	854 octave_idx_type ndims = dims.length ();
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	855 if (dim >= ndims)
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	856 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	857 l = dims.numel ();
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	858 n = 1;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	859 u = 1;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	860 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	861 else
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	862 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	863 if (dim < 0)
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	864 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	865 // find first non-singleton dim
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	866 for (dim = 0; dims(dim) == 1 && dim < ndims - 1; dim++) ;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	867 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	868 // calculate extent triplet.
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	869 l = 1, n = dims(dim), u = 1;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	870 for (octave_idx_type i = 0; i < dim; i++)
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	871 l *= dims (i);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	872 for (octave_idx_type i = dim + 1; i < ndims; i++)
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	873 u *= dims (i);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	874 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	875 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	876
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	877 // Appliers.
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	878 // 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	879 // maybe it can be done without an explicit parameter?
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	880
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	881 template <class ArrayType, class T>
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	882 inline ArrayType
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	883 do_mx_red_op (const Array<T>& src, int dim,
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	884 void (mx_red_op) (const T , typename ArrayType::element_type *,
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	885 octave_idx_type, octave_idx_type, octave_idx_type))
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	886 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	887 octave_idx_type l, n, u;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	888 dim_vector dims = src.dims ();
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	889 // M*b inconsistency: sum([]) = 0 etc.
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	890 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	891 dims (1) = 1;
1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	892
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	893 get_extent_triplet (dims, dim, l, n, u);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	894
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	895 // Reduction operation reduces the array size.
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	896 if (dim < dims.length ()) dims(dim) = 1;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	897 dims.chop_trailing_singletons ();
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	898
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	899 ArrayType ret (dims);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	900 mx_red_op (src.data (), ret.fortran_vec (), l, n, u);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	901
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	902 return ret;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	903 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	904
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	905 template <class ArrayType, class T>
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	906 inline ArrayType
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	907 do_mx_cum_op (const Array<T>& src, int dim,
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	908 void (mx_cum_op) (const T , typename ArrayType::element_type *,
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	909 octave_idx_type, octave_idx_type, octave_idx_type))
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	910 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	911 octave_idx_type l, n, u;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	912 dim_vector dims = src.dims ();
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	913 get_extent_triplet (dims, dim, l, n, u);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	914
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	915 // Cumulative operation doesn't reduce the array size.
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	916 ArrayType ret (dims);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	917 mx_cum_op (src.data (), ret.fortran_vec (), l, n, u);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	918
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	919 return ret;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	920 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	921
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	922 template <class ArrayType>
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	923 inline ArrayType
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	924 do_mx_minmax_op (const ArrayType& src, int dim,
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	925 void (mx_minmax_op) (const typename ArrayType::element_type ,
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	926 typename ArrayType::element_type *,
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	927 octave_idx_type, octave_idx_type, octave_idx_type))
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	928 {
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	929 octave_idx_type l, n, u;
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	930 dim_vector dims = src.dims ();
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	931 get_extent_triplet (dims, dim, l, n, u);
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	932
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	933 // If the dimension is zero, we don't do anything.
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	934 if (dim < dims.length () && dims(dim) != 0) dims(dim) = 1;
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	935 dims.chop_trailing_singletons ();
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	936
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	937 ArrayType ret (dims);
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	938 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	939
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	940 return ret;
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	941 }
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	942
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	943 template <class ArrayType>
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	944 inline ArrayType
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	945 do_mx_minmax_op (const ArrayType& src, Array<octave_idx_type>& idx, int dim,
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	946 void (mx_minmax_op) (const typename ArrayType::element_type ,
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	947 typename ArrayType::element_type *,
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	948 octave_idx_type *,
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	949 octave_idx_type, octave_idx_type, octave_idx_type))
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	950 {
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	951 octave_idx_type l, n, u;
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	952 dim_vector dims = src.dims ();
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	953 get_extent_triplet (dims, dim, l, n, u);
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	954
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	955 // If the dimension is zero, we don't do anything.
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	956 if (dim < dims.length () && dims(dim) != 0) dims(dim) = 1;
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	957 dims.chop_trailing_singletons ();
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	958
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	959 ArrayType ret (dims);
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	960 if (idx.dims () != dims) idx = Array<octave_idx_type> (dims);
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	961
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	962 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	963 l, n, u);
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	964
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	965 return ret;
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	966 }
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	967
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	968 template <class ArrayType>
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	969 inline ArrayType
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	970 do_mx_cumminmax_op (const ArrayType& src, int dim,
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	971 void (mx_cumminmax_op) (const typename ArrayType::element_type ,
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	972 typename ArrayType::element_type *,
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	973 octave_idx_type, octave_idx_type, octave_idx_type))
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	974 {
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	975 octave_idx_type l, n, u;
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	976 dim_vector dims = src.dims ();
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	977 get_extent_triplet (dims, dim, l, n, u);
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 ArrayType ret (dims);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	980 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	981
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	982 return ret;
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	983 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	984
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	985 template <class ArrayType>
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	986 inline ArrayType
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	987 do_mx_cumminmax_op (const ArrayType& src, Array<octave_idx_type>& idx, int dim,
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	988 void (mx_cumminmax_op) (const typename ArrayType::element_type ,
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	989 typename ArrayType::element_type *,
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	990 octave_idx_type *,
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	991 octave_idx_type, octave_idx_type, octave_idx_type))
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 octave_idx_type l, n, u;
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	994 dim_vector dims = src.dims ();
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	995 get_extent_triplet (dims, dim, l, n, u);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	996
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	997 ArrayType ret (dims);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	998 if (idx.dims () != dims) idx = Array<octave_idx_type> (dims);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	999
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1000 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	1001 l, n, u);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1002
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1003 return ret;
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1004 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1005
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	1006 #endif
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	1007
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	1008 /*
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	1009 ;;; Local Variables: ***
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	1010 ;;; mode: C++ ***
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	1011 ;;; End: ***
9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	1012 */

Mercurial > hg > octave-lyh

annotate liboctave/mx-inlines.cc @ 8920:eb63fbe60fab