octave-nkf: liboctave/operators/mx-inlines.cc annotate

annotate liboctave/operators/mx-inlines.cc @ 20595:c1a6c31ac29a

eliminate more simple uses of error_state * ov-classdef.cc: Eliminate simple uses of error_state.

author	John W. Eaton <jwe@octave.org>
date	Tue, 06 Oct 2015 00:20:02 -0400
parents	a9574e3c6e9e
children

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

Mercurial > octave-nkf

annotate liboctave/operators/mx-inlines.cc @ 20595:c1a6c31ac29a