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

annotate liboctave/operators/mx-inlines.cc @ 33657:6f2baadfdb3d bytecode-interpreter tip

maint: Merge default to bytecode-interpreter.

author	Nicholas R. Jankowski <jankowski.nicholas@gmail.com>
date	Tue, 04 Jun 2024 20:06:05 -0400
parents	f53ac65ffba6
children

rev	line source
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	1 ////////////////////////////////////////////////////////////////////////
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	2 //
32632 2e484f9f1f18 maint: update Octave Project Developers copyright for the new year John W. Eaton <jwe@octave.org> parents: 32590 diff changeset	3 // Copyright (C) 1993-2024 The Octave Project Developers
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	4 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	7 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	9 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	14 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	19 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	23 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	24 ////////////////////////////////////////////////////////////////////////
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	25
20791 f7084eae3318 maint: Use Octave coding conventions for #if statements. Rik <rik@octave.org> parents: 20232 diff changeset	26 #if ! defined (octave_mx_inlines_h)
2828 92826d6e8bd9 [project @ 1997-03-25 23:41:41 by jwe] jwe parents: 2811 diff changeset	27 #define octave_mx_inlines_h 1
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	28
23475 d691ed308237 maint: Clean up #includes in liboctave/numeric directory. Rik <rik@octave.org> parents: 23450 diff changeset	29 // This file should not include config.h. It is only included in other C++
d691ed308237 maint: Clean up #includes in liboctave/numeric directory. Rik <rik@octave.org> parents: 23450 diff changeset	30 // source files that should have included config.h before including this file.
21690 b6a686543080 Only include config.h in files that are compiled separately. John W. Eaton <jwe@octave.org> parents: 21660 diff changeset	31
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	32 #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	33 #include <cmath>
23475 d691ed308237 maint: Clean up #includes in liboctave/numeric directory. Rik <rik@octave.org> parents: 23450 diff changeset	34
d691ed308237 maint: Clean up #includes in liboctave/numeric directory. Rik <rik@octave.org> parents: 23450 diff changeset	35 #include <algorithm>
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	36
23475 d691ed308237 maint: Clean up #includes in liboctave/numeric directory. Rik <rik@octave.org> parents: 23450 diff changeset	37 #include "Array-util.h"
d691ed308237 maint: Clean up #includes in liboctave/numeric directory. Rik <rik@octave.org> parents: 23450 diff changeset	38 #include "Array.h"
d691ed308237 maint: Clean up #includes in liboctave/numeric directory. Rik <rik@octave.org> parents: 23450 diff changeset	39 #include "bsxfun.h"
1650 23aa282707e8 [project @ 1995-12-20 06:53:12 by jwe] jwe parents: 1574 diff changeset	40 #include "oct-cmplx.h"
30435 1f0a2689cab2 Use forward declarations for octave_int<T> where possible (bug #59820). Markus Mützel <markus.muetzel@gmx.de> parents: 29572 diff changeset	41 #include "oct-inttypes-fwd.h"
8758 83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	42 #include "oct-locbuf.h"
13004 d9d65c3017c3 Make bsxfun automatic for most binary operators. Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11586 diff changeset	43
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	44 // Provides some commonly repeated, basic loop templates.
461 00f8b2242a18 [project @ 1994-06-06 00:45:57 by jwe] jwe parents: 238 diff changeset	45
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	46 template <typename R, typename S>
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	47 inline void
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	48 mx_inline_fill (std::size_t n, R *r, S s)
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	49 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	50 for (std::size_t i = 0; i < n; i++)
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	51 r[i] = s;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	52 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	53
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	54 template <typename R, typename X>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	55 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	56 mx_inline_uminus (std::size_t n, R r, const X x)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	57 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	58 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	59 r[i] = -x[i];
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	60 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	61
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	62 template <typename R>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	63 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	64 mx_inline_uminus2 (std::size_t n, R *r)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	65 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	66 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	67 r[i] = -r[i];
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	68 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	69
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	70 template <typename X>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	71 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	72 mx_inline_iszero (std::size_t n, bool r, const X x)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	73 {
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	74 const X zero = X ();
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	75 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	76 r[i] = x[i] == zero;
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	77 }
9607 1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	78
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	79 template <typename X>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	80 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	81 mx_inline_notzero (std::size_t n, bool r, const X x)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	82 {
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	83 const X zero = X ();
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	84 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	85 r[i] = x[i] != zero;
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	86 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	87
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	88 #define DEFMXBINOP(F, OP) \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	89 template <typename R, typename X, typename Y> \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	90 inline void F (std::size_t n, R r, const X x, const Y *y) \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	91 { \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	92 for (std::size_t i = 0; i < n; i++) \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	93 r[i] = x[i] OP y[i]; \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	94 } \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	95 template <typename R, typename X, typename Y> \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	96 inline void F (std::size_t n, R r, const X x, Y y) \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	97 { \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	98 for (std::size_t i = 0; i < n; i++) \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	99 r[i] = x[i] OP y; \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	100 } \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	101 template <typename R, typename X, typename Y> \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	102 inline void F (std::size_t n, R r, X x, const Y y) \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	103 { \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	104 for (std::size_t i = 0; i < n; i++) \
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	105 r[i] = x OP y[i]; \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	106 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	107
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	108 DEFMXBINOP (mx_inline_add, +)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	109 DEFMXBINOP (mx_inline_sub, -)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	110 DEFMXBINOP (mx_inline_mul, *)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	111 DEFMXBINOP (mx_inline_div, /)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	112
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	113 #define DEFMXBINOPEQ(F, OP) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	114 template <typename R, typename X> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	115 inline void F (std::size_t n, R r, const X x) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	116 { \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	117 for (std::size_t i = 0; i < n; i++) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	118 r[i] OP x[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	119 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	120 template <typename R, typename X> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	121 inline void F (std::size_t n, R *r, X x) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	122 { \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	123 for (std::size_t i = 0; i < n; i++) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	124 r[i] OP x; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	125 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	126
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	127 DEFMXBINOPEQ (mx_inline_add2, +=)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	128 DEFMXBINOPEQ (mx_inline_sub2, -=)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	129 DEFMXBINOPEQ (mx_inline_mul2, *=)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	130 DEFMXBINOPEQ (mx_inline_div2, /=)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	131
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	132 #define DEFMXCMPOP(F, OP) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	133 template <typename X, typename Y> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	134 inline void F (std::size_t n, bool r, const X x, const Y *y) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	135 { \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	136 for (std::size_t i = 0; i < n; i++) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	137 r[i] = x[i] OP y[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	138 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	139 template <typename X, typename Y> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	140 inline void F (std::size_t n, bool r, const X x, Y y) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	141 { \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	142 for (std::size_t i = 0; i < n; i++) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	143 r[i] = x[i] OP y; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	144 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	145 template <typename X, typename Y> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	146 inline void F (std::size_t n, bool r, X x, const Y y) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	147 { \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	148 for (std::size_t i = 0; i < n; i++) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	149 r[i] = x OP y[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	150 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	151
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	152 DEFMXCMPOP (mx_inline_lt, <)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	153 DEFMXCMPOP (mx_inline_le, <=)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	154 DEFMXCMPOP (mx_inline_gt, >)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	155 DEFMXCMPOP (mx_inline_ge, >=)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	156 DEFMXCMPOP (mx_inline_eq, ==)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	157 DEFMXCMPOP (mx_inline_ne, !=)
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 // Convert to logical value, for logical op purposes.
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	160 template <typename T>
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	161 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	162 logical_value (T x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	163 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	164 return x;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	165 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	166
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	167 template <typename T>
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	168 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	169 logical_value (const std::complex<T>& x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	170 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	171 return x.real () != 0 \|\| x.imag () != 0;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	172 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	173
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	174 template <typename T>
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	175 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	176 logical_value (const octave_int<T>& x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	177 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	178 return x.value ();
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	179 }
9553 0c72d9284087 further bool ops tweaks Jaroslav Hajek <highegg@gmail.com> parents: 9550 diff changeset	180
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	181 template <typename X>
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	182 void
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	183 mx_inline_not (std::size_t n, bool r, const X x)
9553 0c72d9284087 further bool ops tweaks Jaroslav Hajek <highegg@gmail.com> parents: 9550 diff changeset	184 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	185 for (std::size_t i = 0; i < n; i++)
9553 0c72d9284087 further bool ops tweaks Jaroslav Hajek <highegg@gmail.com> parents: 9550 diff changeset	186 r[i] = ! logical_value (x[i]);
0c72d9284087 further bool ops tweaks Jaroslav Hajek <highegg@gmail.com> parents: 9550 diff changeset	187 }
0c72d9284087 further bool ops tweaks Jaroslav Hajek <highegg@gmail.com> parents: 9550 diff changeset	188
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	189 inline void
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	190 mx_inline_not2 (std::size_t n, bool *r)
9607 1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	191 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	192 for (std::size_t i = 0; i < n; i++)
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	193 r[i] = ! r[i];
9607 1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	194 }
1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	195
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	196 #define DEFMXBOOLOP(F, NOT1, OP, NOT2) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	197 template <typename X, typename Y> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	198 inline void F (std::size_t n, bool r, const X x, const Y *y) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	199 { \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	200 for (std::size_t i = 0; i < n; i++) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	201 r[i] = ((NOT1 logical_value (x[i])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	202 OP (NOT2 logical_value (y[i]))); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	203 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	204 template <typename X, typename Y> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	205 inline void F (std::size_t n, bool r, const X x, Y y) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	206 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	207 const bool yy = (NOT2 logical_value (y)); \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	208 for (std::size_t i = 0; i < n; i++) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	209 r[i] = (NOT1 logical_value (x[i])) OP yy; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	210 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	211 template <typename X, typename Y> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	212 inline void F (std::size_t n, bool r, X x, const Y y) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	213 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	214 const bool xx = (NOT1 logical_value (x)); \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	215 for (std::size_t i = 0; i < n; i++) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	216 r[i] = xx OP (NOT2 logical_value (y[i])); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	217 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	218
31361 5cc53fd090c3 build: Silence compilation warning about use of bitwise operators with boolean operands (bug #63210) Rik <rik@octave.org> parents: 30898 diff changeset	219 DEFMXBOOLOP (mx_inline_and, , &&, )
5cc53fd090c3 build: Silence compilation warning about use of bitwise operators with boolean operands (bug #63210) Rik <rik@octave.org> parents: 30898 diff changeset	220 DEFMXBOOLOP (mx_inline_or, , \|\|, )
5cc53fd090c3 build: Silence compilation warning about use of bitwise operators with boolean operands (bug #63210) Rik <rik@octave.org> parents: 30898 diff changeset	221 DEFMXBOOLOP (mx_inline_not_and, !, &&, )
5cc53fd090c3 build: Silence compilation warning about use of bitwise operators with boolean operands (bug #63210) Rik <rik@octave.org> parents: 30898 diff changeset	222 DEFMXBOOLOP (mx_inline_not_or, !, \|\|, )
5cc53fd090c3 build: Silence compilation warning about use of bitwise operators with boolean operands (bug #63210) Rik <rik@octave.org> parents: 30898 diff changeset	223 DEFMXBOOLOP (mx_inline_and_not, , &&, !)
5cc53fd090c3 build: Silence compilation warning about use of bitwise operators with boolean operands (bug #63210) Rik <rik@octave.org> parents: 30898 diff changeset	224 DEFMXBOOLOP (mx_inline_or_not, , \|\|, !)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	225
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	226 template <typename X>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	227 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	228 mx_inline_and2 (std::size_t n, bool r, const X x)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	229 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	230 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	231 r[i] &= logical_value (x[i]);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	232 }
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	233
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	234 template <typename X>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	235 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	236 mx_inline_and2 (std::size_t n, bool *r, X x)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	237 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	238 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	239 r[i] &= x;
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	240 }
9612 66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	241
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	242 template <typename X>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	243 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	244 mx_inline_or2 (std::size_t n, bool r, const X x)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	245 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	246 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	247 r[i] \|= logical_value (x[i]);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	248 }
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	249
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	250 template <typename X>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	251 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	252 mx_inline_or2 (std::size_t n, bool *r, X x)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	253 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	254 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	255 r[i] \|= x;
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	256 }
9612 66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	257
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	258 template <typename T>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	259 inline bool
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	260 mx_inline_any_nan (std::size_t n, const T *x)
9814 2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	261 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	262 for (std::size_t i = 0; i < n; i++)
9814 2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	263 {
21782 2aef506f3fec use namespace for lo-mappers.h functions John W. Eaton <jwe@octave.org> parents: 21751 diff changeset	264 if (octave::math::isnan (x[i]))
9814 2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	265 return true;
2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	266 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	267
9814 2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	268 return false;
8380 dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	269 }
dbe67764e628 fix & improve speed of diagonal matrix multiplication Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	270
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	271 template <typename T>
10900 b64803a8be4e optimize element-wise sparse-dense multiplication and division Jaroslav Hajek <highegg@gmail.com> parents: 10643 diff changeset	272 inline bool
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	273 mx_inline_all_finite (std::size_t n, const T *x)
10900 b64803a8be4e optimize element-wise sparse-dense multiplication and division Jaroslav Hajek <highegg@gmail.com> parents: 10643 diff changeset	274 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	275 for (std::size_t i = 0; i < n; i++)
10900 b64803a8be4e optimize element-wise sparse-dense multiplication and division Jaroslav Hajek <highegg@gmail.com> parents: 10643 diff changeset	276 {
23564 7049da1648c0 Deprecate octave::math::finite in favor of octave::math::isfinite. Rik <rik@octave.org> parents: 23475 diff changeset	277 if (! octave::math::isfinite (x[i]))
10900 b64803a8be4e optimize element-wise sparse-dense multiplication and division Jaroslav Hajek <highegg@gmail.com> parents: 10643 diff changeset	278 return false;
b64803a8be4e optimize element-wise sparse-dense multiplication and division Jaroslav Hajek <highegg@gmail.com> parents: 10643 diff changeset	279 }
b64803a8be4e optimize element-wise sparse-dense multiplication and division Jaroslav Hajek <highegg@gmail.com> parents: 10643 diff changeset	280
b64803a8be4e optimize element-wise sparse-dense multiplication and division Jaroslav Hajek <highegg@gmail.com> parents: 10643 diff changeset	281 return true;
b64803a8be4e optimize element-wise sparse-dense multiplication and division Jaroslav Hajek <highegg@gmail.com> parents: 10643 diff changeset	282 }
b64803a8be4e optimize element-wise sparse-dense multiplication and division Jaroslav Hajek <highegg@gmail.com> parents: 10643 diff changeset	283
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	284 template <typename T>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	285 inline bool
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	286 mx_inline_any_negative (std::size_t n, const T *x)
9827 c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	287 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	288 for (std::size_t i = 0; i < n; i++)
9827 c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	289 {
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	290 if (x[i] < 0)
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	291 return true;
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	292 }
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	293
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	294 return false;
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	295 }
c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	296
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	297 template <typename T>
13756 6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13139 diff changeset	298 inline bool
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	299 mx_inline_any_positive (std::size_t n, const T *x)
13756 6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13139 diff changeset	300 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	301 for (std::size_t i = 0; i < n; i++)
13756 6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13139 diff changeset	302 {
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13139 diff changeset	303 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	304 return true;
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13139 diff changeset	305 }
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13139 diff changeset	306
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13139 diff changeset	307 return false;
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13139 diff changeset	308 }
6dfebfa334cb allow negative data log plots with OpenGL+FLTK graphics (bug #34232) John W. Eaton <jwe@octave.org> parents: 13139 diff changeset	309
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	310 template <typename T>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	311 inline bool
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	312 mx_inline_all_real (std::size_t n, const std::complex<T> *x)
9814 2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	313 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	314 for (std::size_t i = 0; i < n; i++)
9814 2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	315 {
2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	316 if (x[i].imag () != 0)
2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	317 return false;
2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	318 }
2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	319
2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	320 return true;
2b29f3472e20 add a couple of useful loops Jaroslav Hajek <highegg@gmail.com> parents: 9800 diff changeset	321 }
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	322
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	323 template <typename T>
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	324 inline void
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	325 mx_inline_real (std::size_t n, T r, const std::complex<T> x)
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	326 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	327 for (std::size_t i = 0; i < n; i++)
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	328 r[i] = x[i].real ();
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	329 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	330
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	331 template <typename T>
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	332 inline void
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	333 mx_inline_imag (std::size_t n, T r, const std::complex<T> x)
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	334 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	335 for (std::size_t i = 0; i < n; i++)
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	336 r[i] = x[i].imag ();
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	337 }
9800 ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	338
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	339 template <typename T>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	340 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	341 mx_inline_xmin (std::size_t n, T r, const T x, const T *y)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	342 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	343 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	344 r[i] = octave::math::min (x[i], y[i]);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	345 }
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	346
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	347 template <typename T>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	348 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	349 mx_inline_xmin (std::size_t n, T r, const T x, T y)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	350 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	351 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	352 r[i] = octave::math::min (x[i], y);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	353 }
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	354
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	355 template <typename T>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	356 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	357 mx_inline_xmin (std::size_t n, T r, T x, const T y)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	358 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	359 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	360 r[i] = octave::math::min (x, y[i]);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	361 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	362
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	363 template <typename T>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	364 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	365 mx_inline_xmax (std::size_t n, T r, const T x, const T *y)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	366 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	367 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	368 r[i] = octave::math::max (x[i], y[i]);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	369 }
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	370
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	371 template <typename T>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	372 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	373 mx_inline_xmax (std::size_t n, T r, const T x, T y)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	374 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	375 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	376 r[i] = octave::math::max (x[i], y);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	377 }
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	378
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	379 template <typename T>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	380 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	381 mx_inline_xmax (std::size_t n, T r, T x, const T y)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	382 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	383 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	384 r[i] = octave::math::max (x, y[i]);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	385 }
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	386
10146 9597eea7fa36 inline xmin/xmax & optimize special cases Jaroslav Hajek <highegg@gmail.com> parents: 9827 diff changeset	387 // Specialize array-scalar max/min
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	388 #define DEFMINMAXSPEC(T, F, OP) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	389 template <> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	390 inline void F<T> (std::size_t n, T r, const T x, T y) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	391 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	392 if (octave::math::isnan (y)) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	393 std::memcpy (r, x, n * sizeof (T)); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	394 else \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	395 for (std::size_t i = 0; i < n; i++) \
23450 855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)". Rik <rik@octave.org> parents: 23449 diff changeset	396 r[i] = (x[i] OP y ? x[i] : y); \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	397 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	398 template <> \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	399 inline void F<T> (std::size_t n, T r, T x, const T y) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	400 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	401 if (octave::math::isnan (x)) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	402 std::memcpy (r, y, n * sizeof (T)); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	403 else \
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	404 for (std::size_t i = 0; i < n; i++) \
23450 855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)". Rik <rik@octave.org> parents: 23449 diff changeset	405 r[i] = (y[i] OP x ? y[i] : x); \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	406 }
10146 9597eea7fa36 inline xmin/xmax & optimize special cases Jaroslav Hajek <highegg@gmail.com> parents: 9827 diff changeset	407
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	408 DEFMINMAXSPEC (double, mx_inline_xmin, <=)
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	409 DEFMINMAXSPEC (double, mx_inline_xmax, >=)
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	410 DEFMINMAXSPEC (float, mx_inline_xmin, <=)
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	411 DEFMINMAXSPEC (float, mx_inline_xmax, >=)
10146 9597eea7fa36 inline xmin/xmax & optimize special cases Jaroslav Hajek <highegg@gmail.com> parents: 9827 diff changeset	412
23639 b488e958d024 Use modf, pow from C++ std library. Rik <rik@octave.org> parents: 23564 diff changeset	413 // FIXME: Is this comment correct anymore? It seems like std::pow is chosen.
13005 4061106b1c4b Enable automatic bsxfun for power operators Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 13004 diff changeset	414 // 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	415 // arguments provided.
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	416
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	417 template <typename R, typename X, typename Y>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	418 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	419 mx_inline_pow (std::size_t n, R r, const X x, const Y *y)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	420 {
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	421 using std::pow;
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	422
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	423 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	424 r[i] = pow (x[i], y[i]);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	425 }
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	426
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	427 template <typename R, typename X, typename Y>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	428 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	429 mx_inline_pow (std::size_t n, R r, const X x, Y y)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	430 {
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	431 using std::pow;
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	432
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	433 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	434 r[i] = pow (x[i], y);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	435 }
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	436
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	437 template <typename R, typename X, typename Y>
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	438 inline void
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	439 mx_inline_pow (std::size_t n, R r, X x, const Y y)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	440 {
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	441 using std::pow;
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	442
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	443 for (std::size_t i = 0; i < n; i++)
22782 af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	444 r[i] = pow (x, y[i]);
af79b2a398ed eliminate some macros that are used only once or twice John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	445 }
9827 c15a5ed0da58 optimize bsxfun (@power, ...) Jaroslav Hajek <highegg@gmail.com> parents: 9814 diff changeset	446
21751 b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21690 diff changeset	447 // Arbitrary function appliers.
b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21690 diff changeset	448 // The function is a template parameter to enable inlining.
30898 51a3d3a69193 maint: Use "fcn" as preferred abbreviation for "function" in liboctave/. Rik <rik@octave.org> parents: 30564 diff changeset	449 template <typename R, typename X, R fcn (X x)>
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	450 inline void
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	451 mx_inline_map (std::size_t n, R r, const X x)
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	452 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	453 for (std::size_t i = 0; i < n; i++)
30898 51a3d3a69193 maint: Use "fcn" as preferred abbreviation for "function" in liboctave/. Rik <rik@octave.org> parents: 30564 diff changeset	454 r[i] = fcn (x[i]);
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	455 }
9800 ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	456
30898 51a3d3a69193 maint: Use "fcn" as preferred abbreviation for "function" in liboctave/. Rik <rik@octave.org> parents: 30564 diff changeset	457 template <typename R, typename X, R fcn (const X& x)>
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	458 inline void
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	459 mx_inline_map (std::size_t n, R r, const X x)
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	460 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	461 for (std::size_t i = 0; i < n; i++)
30898 51a3d3a69193 maint: Use "fcn" as preferred abbreviation for "function" in liboctave/. Rik <rik@octave.org> parents: 30564 diff changeset	462 r[i] = fcn (x[i]);
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	463 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	464
21751 b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21690 diff changeset	465 // Appliers. Since these call the operation just once, we pass it as
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	466 // 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	467
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	468 template <typename R, typename X>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	469 inline Array<R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	470 do_mx_unary_op (const Array<X>& x,
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	471 void (op) (std::size_t, R , const X *))
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	472 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	473 Array<R> r (x.dims ());
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	474 op (r.numel (), r.rwdata (), x.data ());
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	475 return r;
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	476 }
2811 1dd37f97364a [project @ 1997-03-12 23:06:13 by jwe] jwe parents: 2804 diff changeset	477
9800 ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	478 // Shortcuts for applying mx_inline_map.
ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	479
30898 51a3d3a69193 maint: Use "fcn" as preferred abbreviation for "function" in liboctave/. Rik <rik@octave.org> parents: 30564 diff changeset	480 template <typename R, typename X, R fcn (X)>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	481 inline Array<R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	482 do_mx_unary_map (const Array<X>& x)
9800 ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	483 {
30898 51a3d3a69193 maint: Use "fcn" as preferred abbreviation for "function" in liboctave/. Rik <rik@octave.org> parents: 30564 diff changeset	484 return do_mx_unary_op<R, X> (x, mx_inline_map<R, X, fcn>);
9800 ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	485 }
ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	486
30898 51a3d3a69193 maint: Use "fcn" as preferred abbreviation for "function" in liboctave/. Rik <rik@octave.org> parents: 30564 diff changeset	487 template <typename R, typename X, R fcn (const X&)>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	488 inline Array<R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	489 do_mx_unary_map (const Array<X>& x)
9800 ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	490 {
30898 51a3d3a69193 maint: Use "fcn" as preferred abbreviation for "function" in liboctave/. Rik <rik@octave.org> parents: 30564 diff changeset	491 return do_mx_unary_op<R, X> (x, mx_inline_map<R, X, fcn>);
9800 ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	492 }
ef4c4186cb47 improve some mx_inline loops Jaroslav Hajek <highegg@gmail.com> parents: 9766 diff changeset	493
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	494 template <typename R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	495 inline Array<R>&
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	496 do_mx_inplace_op (Array<R>& r,
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	497 void (op) (std::size_t, R ))
9607 1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	498 {
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	499 op (r.numel (), r.rwdata ());
9607 1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	500 return r;
1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	501 }
1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9578 diff changeset	502
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	503 template <typename R, typename X, typename Y>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	504 inline Array<R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	505 do_mm_binary_op (const Array<X>& x, const Array<Y>& y,
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	506 void (op) (std::size_t, R , const X , const Y ),
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	507 void (op1) (std::size_t, R , X, const Y *),
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	508 void (op2) (std::size_t, R , const X *, Y),
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	509 const char *opname)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	510 {
32580 324c67c33dbd mx-inlines.cc: Avoid unnecessary copy of dim_vector for performance (bug #64962) Petter .T <petter.vilhelm@gmail.com> parents: 31706 diff changeset	511 const dim_vector &dx = x.dims ();
324c67c33dbd mx-inlines.cc: Avoid unnecessary copy of dim_vector for performance (bug #64962) Petter .T <petter.vilhelm@gmail.com> parents: 31706 diff changeset	512 const dim_vector &dy = y.dims ();
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	513 if (dx == dy)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	514 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	515 Array<R> r (dx);
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	516 op (r.numel (), r.rwdata (), x.data (), y.data ());
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	517 return r;
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	518 }
14056 c3d401562410 allow warning (or error) for automatic bsxfun John W. Eaton <jwe@octave.org> parents: 13756 diff changeset	519 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	520 {
d9d65c3017c3 Make bsxfun automatic for most binary operators. Jordi Gutiérrez Hermoso <jordigh@gmail.com> parents: 11586 diff changeset	521 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	522 }
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	523 else
22327 d0562b3159c7 move more classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22323 diff changeset	524 octave::err_nonconformant (opname, dx, dy);
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	525 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	526
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	527 template <typename R, typename X, typename Y>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	528 inline Array<R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	529 do_ms_binary_op (const Array<X>& x, const Y& y,
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	530 void (op) (std::size_t, R , const X *, Y))
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	531 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	532 Array<R> r (x.dims ());
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	533 op (r.numel (), r.rwdata (), x.data (), y);
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	534 return r;
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	535 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	536
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	537 template <typename R, typename X, typename Y>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	538 inline Array<R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	539 do_sm_binary_op (const X& x, const Array<Y>& y,
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	540 void (op) (std::size_t, R , X, const Y *))
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	541 {
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	542 Array<R> r (y.dims ());
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	543 op (r.numel (), r.rwdata (), x, y.data ());
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	544 return r;
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	545 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	546
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	547 template <typename R, typename X>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	548 inline Array<R>&
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	549 do_mm_inplace_op (Array<R>& r, const Array<X>& x,
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	550 void (op) (std::size_t, R , const X *),
aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	551 void (op1) (std::size_t, R , X),
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	552 const char *opname)
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	553 {
32580 324c67c33dbd mx-inlines.cc: Avoid unnecessary copy of dim_vector for performance (bug #64962) Petter .T <petter.vilhelm@gmail.com> parents: 31706 diff changeset	554 const dim_vector &dr = r.dims ();
324c67c33dbd mx-inlines.cc: Avoid unnecessary copy of dim_vector for performance (bug #64962) Petter .T <petter.vilhelm@gmail.com> parents: 31706 diff changeset	555 const dim_vector &dx = x.dims ();
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	556 if (dr == dx)
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	557 op (r.numel (), r.rwdata (), x.data ());
14056 c3d401562410 allow warning (or error) for automatic bsxfun John W. Eaton <jwe@octave.org> parents: 13756 diff changeset	558 else if (is_valid_inplace_bsxfun (opname, dr, dx))
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21100 diff changeset	559 do_inplace_bsxfun_op (r, x, op, op1);
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	560 else
22327 d0562b3159c7 move more classes inside octave namespace John W. Eaton <jwe@octave.org> parents: 22323 diff changeset	561 octave::err_nonconformant (opname, dr, dx);
21118 3ac9f47fb04b Invert pattern if/code/else/err_XXX to if !/err_XXX/code. Rik <rik@octave.org> parents: 21100 diff changeset	562
9612 66970dd627f6 further liboctave design improvements Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	563 return r;
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	564 }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7017 diff changeset	565
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	566 template <typename R, typename X>
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	567 inline Array<R>&
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	568 do_ms_inplace_op (Array<R>& r, const X& x,
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	569 void (op) (std::size_t, R , X))
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	570 {
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	571 op (r.numel (), r.rwdata (), x);
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	572 return r;
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	573 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	574
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	575 template <typename T1, typename T2>
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	576 inline bool
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	577 mx_inline_equal (std::size_t n, const T1 x, const T2 y)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	578 {
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	579 for (std::size_t i = 0; i < n; i++)
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	580 if (x[i] != y[i])
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	581 return false;
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	582 return true;
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	583 }
3 9a4c07481e61 [project @ 1993-08-08 01:20:23 by jwe] jwe parents: diff changeset	584
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	585 template <typename T>
10481 e8811e5dd699 avoid exception throwing in mx-inline loops Jaroslav Hajek <highegg@gmail.com> parents: 10365 diff changeset	586 inline bool
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	587 do_mx_check (const Array<T>& a,
29572 aef11bb4e6d1 use std::size_t and std::ptrdiff_t in C++ code (bug #60471) John W. Eaton <jwe@octave.org> parents: 29358 diff changeset	588 bool (op) (std::size_t, const T ))
10481 e8811e5dd699 avoid exception throwing in mx-inline loops Jaroslav Hajek <highegg@gmail.com> parents: 10365 diff changeset	589 {
e8811e5dd699 avoid exception throwing in mx-inline loops Jaroslav Hajek <highegg@gmail.com> parents: 10365 diff changeset	590 return op (a.numel (), a.data ());
e8811e5dd699 avoid exception throwing in mx-inline loops Jaroslav Hajek <highegg@gmail.com> parents: 10365 diff changeset	591 }
e8811e5dd699 avoid exception throwing in mx-inline loops Jaroslav Hajek <highegg@gmail.com> parents: 10365 diff changeset	592
e8811e5dd699 avoid exception throwing in mx-inline loops Jaroslav Hajek <highegg@gmail.com> parents: 10365 diff changeset	593 // 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	594 // magic to avoid underflows, which we don't need here.
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	595 template <typename T>
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	596 inline T
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	597 cabsq (const std::complex<T>& c)
22402 4caa7b28d183 maint: Style check C++ code in liboctave/ Rik <rik@octave.org> parents: 22327 diff changeset	598 {
4caa7b28d183 maint: Style check C++ code in liboctave/ Rik <rik@octave.org> parents: 22327 diff changeset	599 return c.real () * c.real () + c.imag () * c.imag ();
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	600 }
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	601
21751 b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21690 diff changeset	602 // default. works for integers and bool.
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	603 template <typename T>
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	604 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	605 xis_true (T x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	606 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	607 return x;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	608 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	609
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	610 template <typename T>
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	611 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	612 xis_false (T x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	613 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	614 return ! x;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	615 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	616
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	617 // for octave_ints
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	618 template <typename T>
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	619 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	620 xis_true (const octave_int<T>& x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	621 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	622 return x.value ();
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	623 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	624
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	625 template <typename T>
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	626 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	627 xis_false (const octave_int<T>& x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	628 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	629 return ! x.value ();
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	630 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	631
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	632 // for reals, we want to ignore NaNs.
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	633 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	634 xis_true (double x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	635 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	636 return ! octave::math::isnan (x) && x != 0.0;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	637 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	638
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	639 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	640 xis_false (double x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	641 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	642 return x == 0.0;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	643 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	644
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	645 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	646 xis_true (float x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	647 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	648 return ! octave::math::isnan (x) && x != 0.0f;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	649 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	650
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	651 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	652 xis_false (float x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	653 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	654 return x == 0.0f;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	655 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	656
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	657 // Ditto for complex.
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	658 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	659 xis_true (const Complex& x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	660 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	661 return ! octave::math::isnan (x) && x != 0.0;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	662 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	663
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	664 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	665 xis_false (const Complex& x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	666 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	667 return x == 0.0;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	668 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	669
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	670 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	671 xis_true (const FloatComplex& x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	672 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	673 return ! octave::math::isnan (x) && x != 0.0f;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	674 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	675
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	676 inline bool
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	677 xis_false (const FloatComplex& x)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	678 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	679 return x == 0.0f;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	680 }
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	681
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	682 #define OP_RED_SUM(ac, el) ac += el
3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	683 #define OP_RED_PROD(ac, el) ac *= el
26471 5becd46b75f8 mx-inlines.cc: Fix static analyzer detected issues (bug #55347). Rik <rik@octave.org> parents: 26376 diff changeset	684 #define OP_RED_SUMSQ(ac, el) ac += ((el)*(el))
9550 3d6a9aea2aea refactor binary & bool ops in liboctave Jaroslav Hajek <highegg@gmail.com> parents: 9513 diff changeset	685 #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	686
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	687 inline void
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	688 op_dble_prod (double& ac, float el)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	689 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	690 ac *= el;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	691 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	692
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	693 // FIXME: guaranteed?
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	694 inline void
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	695 op_dble_prod (Complex& ac, const FloatComplex& el)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	696 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	697 ac *= el;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	698 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	699
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	700 template <typename T>
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	701 inline void
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	702 op_dble_prod (double& ac, const octave_int<T>& el)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	703 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	704 ac *= el.double_value ();
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	705 }
18725 8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 18099 diff changeset	706
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	707 inline void
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	708 op_dble_sum (double& ac, float el)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	709 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	710 ac += el;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	711 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	712
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	713 // FIXME: guaranteed?
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	714 inline void
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	715 op_dble_sum (Complex& ac, const FloatComplex& el)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	716 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	717 ac += el;
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	718 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	719
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	720 template <typename T>
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	721 inline void
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	722 op_dble_sum (double& ac, const octave_int<T>& el)
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	723 {
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	724 ac += el.double_value ();
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	725 }
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	726
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	727 // The following two implement a simple short-circuiting.
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	728 #define OP_RED_ANYC(ac, el) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	729 if (xis_true (el)) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	730 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	731 ac = true; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	732 break; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	733 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	734 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	735 continue
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	736
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	737 #define OP_RED_ALLC(ac, el) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	738 if (xis_false (el)) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	739 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	740 ac = false; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	741 break; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	742 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	743 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	744 continue
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	745
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	746 #define OP_RED_FCN(F, TSRC, TRES, OP, ZERO) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	747 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	748 inline TRES \
23449 c763214a8260 maint: Use convention 'int x' for naming pointers. Rik <rik@octave.org>* parents: 23220 diff changeset	749 F (const TSRC *v, octave_idx_type n) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	750 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	751 TRES ac = ZERO; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	752 for (octave_idx_type i = 0; i < n; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	753 OP(ac, v[i]); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	754 return ac; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	755 }
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	756
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	757 #define PROMOTE_DOUBLE(T) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	758 typename subst_template_param<std::complex, T, double>::type
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	759
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	760 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	761 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	762 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	763 OP_RED_FCN (mx_inline_prod, T, T, OP_RED_PROD, 1)
18725 8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 18099 diff changeset	764 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	765 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	766 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	767 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	768 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	769
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	770 #define OP_RED_FCN2(F, TSRC, TRES, OP, ZERO) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	771 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	772 inline void \
23449 c763214a8260 maint: Use convention 'int x' for naming pointers. Rik <rik@octave.org>* parents: 23220 diff changeset	773 F (const TSRC v, TRES r, octave_idx_type m, octave_idx_type n) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	774 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	775 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	776 r[i] = ZERO; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	777 for (octave_idx_type j = 0; j < n; j++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	778 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	779 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	780 OP(r[i], v[i]); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	781 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	782 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	783 }
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	784
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	785 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	786 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	787 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	788 OP_RED_FCN2 (mx_inline_prod, T, T, OP_RED_PROD, 1)
18725 8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 18099 diff changeset	789 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	790 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	791 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	792
10147 adc0143e9419 optimize any/all (x, 2) with small number of rows Jaroslav Hajek <highegg@gmail.com> parents: 10146 diff changeset	793 #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	794 #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	795
adc0143e9419 optimize any/all (x, 2) with small number of rows Jaroslav Hajek <highegg@gmail.com> parents: 10146 diff changeset	796 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	797 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	798
8758 83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	799 // Using the general code for any/all would sacrifice short-circuiting.
21751 b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21690 diff changeset	800 // OTOH, going by rows would sacrifice cache-coherence. The following
b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21690 diff changeset	801 // algorithm will achieve both, at the cost of a temporary octave_idx_type
b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21690 diff changeset	802 // array.
8758 83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	803
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	804 #define OP_ROW_SHORT_CIRCUIT(F, PRED, ZERO) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	805 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	806 inline void \
23449 c763214a8260 maint: Use convention 'int x' for naming pointers. Rik <rik@octave.org>* parents: 23220 diff changeset	807 F (const T v, bool r, octave_idx_type m, octave_idx_type n) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	808 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	809 if (n <= 8) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	810 return F ## _r (v, r, m, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	811 \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	812 /* FIXME: it may be sub-optimal to allocate the buffer here. */ \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	813 OCTAVE_LOCAL_BUFFER (octave_idx_type, iact, m); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	814 for (octave_idx_type i = 0; i < m; i++) iact[i] = i; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	815 octave_idx_type nact = m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	816 for (octave_idx_type j = 0; j < n; j++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	817 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	818 octave_idx_type k = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	819 for (octave_idx_type i = 0; i < nact; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	820 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	821 octave_idx_type ia = iact[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	822 if (! PRED (v[ia])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	823 iact[k++] = ia; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	824 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	825 nact = k; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	826 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	827 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	828 for (octave_idx_type i = 0; i < m; i++) r[i] = ! ZERO; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	829 for (octave_idx_type i = 0; i < nact; i++) r[iact[i]] = ZERO; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	830 }
8758 83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	831
83c9d60c3c47 implement short-circuiting row-reduction any/all algorithm Jaroslav Hajek <highegg@gmail.com> parents: 8756 diff changeset	832 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	833 OP_ROW_SHORT_CIRCUIT (mx_inline_all, xis_false, true)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	834
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	835 #define OP_RED_FCNN(F, TSRC, TRES) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	836 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	837 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	838 F (const TSRC v, TRES r, octave_idx_type l, \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	839 octave_idx_type n, octave_idx_type u) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	840 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	841 if (l == 1) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	842 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	843 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	844 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	845 r[i] = F<T> (v, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	846 v += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	847 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	848 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	849 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	850 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	851 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	852 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	853 F (v, r, l, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	854 v += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	855 r += l; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	856 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	857 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	858 }
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	859
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	860 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	861 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	862 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	863 OP_RED_FCNN (mx_inline_prod, T, T)
18725 8cc66f091584 Add "native" option to prod() (bug #40349). Rik <rik@octave.org> parents: 18099 diff changeset	864 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	865 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	866 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	867 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	868 OP_RED_FCNN (mx_inline_all, T, bool)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	869
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	870 #define OP_CUM_FCN(F, TSRC, TRES, OP) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	871 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	872 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	873 F (const TSRC v, TRES r, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	874 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	875 if (n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	876 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	877 TRES t = r[0] = v[0]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	878 for (octave_idx_type i = 1; i < n; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	879 r[i] = t = t OP v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	880 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	881 }
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	882
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	883 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	884 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	885 OP_CUM_FCN (mx_inline_cumcount, bool, T, +)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	886
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	887 #define OP_CUM_FCN2(F, TSRC, TRES, OP) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	888 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	889 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	890 F (const TSRC v, TRES r, octave_idx_type m, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	891 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	892 if (n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	893 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	894 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	895 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	896 const T *r0 = r; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	897 for (octave_idx_type j = 1; j < n; j++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	898 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	899 r += m; v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	900 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	901 r[i] = r0[i] OP v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	902 r0 += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	903 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	904 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	905 }
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	906
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	907 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	908 OP_CUM_FCN2 (mx_inline_cumprod, T, T, *)
10643 9852264314d1 fix cumulative logical sum Jaroslav Hajek <highegg@gmail.com> parents: 10482 diff changeset	909 OP_CUM_FCN2 (mx_inline_cumcount, bool, T, +)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	910
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	911 #define OP_CUM_FCNN(F, TSRC, TRES) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	912 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	913 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	914 F (const TSRC v, TRES r, octave_idx_type l, \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	915 octave_idx_type n, octave_idx_type u) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	916 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	917 if (l == 1) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	918 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	919 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	920 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	921 F (v, r, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	922 v += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	923 r += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	924 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	925 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	926 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	927 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	928 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	929 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	930 F (v, r, l, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	931 v += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	932 r += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	933 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	934 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	935 }
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	936
8780 ea76466605ba support native cumsum, gripe on overflow in sum/cumsum Jaroslav Hajek <highegg@gmail.com> parents: 8777 diff changeset	937 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	938 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	939 OP_CUM_FCNN (mx_inline_cumcount, bool, T)
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	940
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	941 #define OP_MINMAX_FCN(F, OP) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	942 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	943 void F (const T v, T r, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	944 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	945 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	946 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	947 T tmp = v[0]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	948 octave_idx_type i = 1; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	949 if (octave::math::isnan (tmp)) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	950 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	951 for (; i < n && octave::math::isnan (v[i]); i++) ; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	952 if (i < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	953 tmp = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	954 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	955 for (; i < n; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	956 if (v[i] OP tmp) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	957 tmp = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	958 *r = tmp; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	959 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	960 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	961 void F (const T v, T r, octave_idx_type *ri, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	962 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	963 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	964 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	965 T tmp = v[0]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	966 octave_idx_type tmpi = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	967 octave_idx_type i = 1; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	968 if (octave::math::isnan (tmp)) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	969 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	970 for (; i < n && octave::math::isnan (v[i]); i++) ; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	971 if (i < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	972 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	973 tmp = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	974 tmpi = i; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	975 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	976 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	977 for (; i < n; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	978 if (v[i] OP tmp) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	979 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	980 tmp = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	981 tmpi = i; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	982 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	983 *r = tmp; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	984 *ri = tmpi; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	985 }
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	986
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	987 OP_MINMAX_FCN (mx_inline_min, <)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	988 OP_MINMAX_FCN (mx_inline_max, >)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	989
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	990 // 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	991 // 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	992 // proceed to a faster code.
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	993
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	994 #define OP_MINMAX_FCN2(F, OP) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	995 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	996 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	997 F (const T v, T r, octave_idx_type m, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	998 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	999 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1000 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1001 bool nan = false; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1002 octave_idx_type j = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1003 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1004 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1005 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1006 if (octave::math::isnan (v[i])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1007 nan = true; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1008 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1009 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1010 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1011 while (nan && j < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1012 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1013 nan = false; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1014 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1015 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1016 if (octave::math::isnan (v[i])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1017 nan = true; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1018 else if (octave::math::isnan (r[i]) \|\| v[i] OP r[i]) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1019 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1020 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1021 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1022 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1023 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1024 while (j < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1025 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1026 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1027 if (v[i] OP r[i]) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1028 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1029 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1030 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1031 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1032 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1033 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1034 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1035 F (const T v, T r, octave_idx_type *ri, \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1036 octave_idx_type m, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1037 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1038 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1039 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1040 bool nan = false; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1041 octave_idx_type j = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1042 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1043 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1044 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1045 ri[i] = j; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1046 if (octave::math::isnan (v[i])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1047 nan = true; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1048 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1049 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1050 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1051 while (nan && j < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1052 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1053 nan = false; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1054 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1055 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1056 if (octave::math::isnan (v[i])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1057 nan = true; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1058 else if (octave::math::isnan (r[i]) \|\| v[i] OP r[i]) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1059 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1060 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1061 ri[i] = j; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1062 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1063 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1064 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1065 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1066 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1067 while (j < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1068 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1069 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1070 if (v[i] OP r[i]) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1071 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1072 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1073 ri[i] = j; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1074 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1075 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1076 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1077 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1078 }
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1079
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1080 OP_MINMAX_FCN2 (mx_inline_min, <)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1081 OP_MINMAX_FCN2 (mx_inline_max, >)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1082
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1083 #define OP_MINMAX_FCNN(F) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1084 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1085 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1086 F (const T v, T r, octave_idx_type l, \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1087 octave_idx_type n, octave_idx_type u) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1088 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1089 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1090 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1091 if (l == 1) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1092 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1093 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1094 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1095 F (v, r, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1096 v += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1097 r++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1098 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1099 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1100 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1101 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1102 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1103 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1104 F (v, r, l, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1105 v += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1106 r += l; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1107 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1108 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1109 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1110 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1111 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1112 F (const T v, T r, octave_idx_type *ri, \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1113 octave_idx_type l, octave_idx_type n, octave_idx_type u) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1114 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1115 if (! n) return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1116 if (l == 1) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1117 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1118 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1119 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1120 F (v, r, ri, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1121 v += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1122 r++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1123 ri++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1124 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1125 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1126 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1127 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1128 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1129 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1130 F (v, r, ri, l, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1131 v += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1132 r += l; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1133 ri += l; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1134 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1135 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1136 }
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1137
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1138 OP_MINMAX_FCNN (mx_inline_min)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1139 OP_MINMAX_FCNN (mx_inline_max)
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1140
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1141 #define OP_CUMMINMAX_FCN(F, OP) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1142 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1143 void F (const T v, T r, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1144 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1145 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1146 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1147 T tmp = v[0]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1148 octave_idx_type i = 1; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1149 octave_idx_type j = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1150 if (octave::math::isnan (tmp)) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1151 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1152 for (; i < n && octave::math::isnan (v[i]); i++) ; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1153 for (; j < i; j++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1154 r[j] = tmp; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1155 if (i < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1156 tmp = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1157 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1158 for (; i < n; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1159 if (v[i] OP tmp) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1160 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1161 for (; j < i; j++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1162 r[j] = tmp; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1163 tmp = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1164 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1165 for (; j < i; j++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1166 r[j] = tmp; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1167 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1168 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1169 void F (const T v, T r, octave_idx_type *ri, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1170 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1171 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1172 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1173 T tmp = v[0]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1174 octave_idx_type tmpi = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1175 octave_idx_type i = 1; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1176 octave_idx_type j = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1177 if (octave::math::isnan (tmp)) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1178 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1179 for (; i < n && octave::math::isnan (v[i]); i++) ; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1180 for (; j < i; j++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1181 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1182 r[j] = tmp; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1183 ri[j] = tmpi; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1184 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1185 if (i < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1186 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1187 tmp = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1188 tmpi = i; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1189 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1190 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1191 for (; i < n; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1192 if (v[i] OP tmp) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1193 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1194 for (; j < i; j++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1195 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1196 r[j] = tmp; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1197 ri[j] = tmpi; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1198 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1199 tmp = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1200 tmpi = i; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1201 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1202 for (; j < i; j++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1203 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1204 r[j] = tmp; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1205 ri[j] = tmpi; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1206 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1207 }
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1208
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1209 OP_CUMMINMAX_FCN (mx_inline_cummin, <)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1210 OP_CUMMINMAX_FCN (mx_inline_cummax, >)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1211
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1212 // 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	1213 // 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	1214 // proceed to a faster code.
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1215
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1216 #define OP_CUMMINMAX_FCN2(F, OP) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1217 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1218 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1219 F (const T v, T r, octave_idx_type m, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1220 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1221 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1222 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1223 bool nan = false; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1224 const T *r0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1225 octave_idx_type j = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1226 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1227 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1228 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1229 if (octave::math::isnan (v[i])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1230 nan = true; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1231 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1232 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1233 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1234 r0 = r; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1235 r += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1236 while (nan && j < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1237 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1238 nan = false; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1239 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1240 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1241 if (octave::math::isnan (v[i])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1242 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1243 r[i] = r0[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1244 nan = true; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1245 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1246 else if (octave::math::isnan (r0[i]) \|\| v[i] OP r0[i]) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1247 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1248 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1249 r[i] = r0[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1250 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1251 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1252 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1253 r0 = r; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1254 r += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1255 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1256 while (j < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1257 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1258 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1259 if (v[i] OP r0[i]) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1260 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1261 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1262 r[i] = r0[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1263 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1264 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1265 r0 = r; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1266 r += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1267 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1268 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1269 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1270 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1271 F (const T v, T r, octave_idx_type *ri, \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1272 octave_idx_type m, octave_idx_type n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1273 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1274 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1275 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1276 bool nan = false; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1277 const T *r0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1278 const octave_idx_type *r0i; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1279 octave_idx_type j = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1280 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1281 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1282 r[i] = v[i]; ri[i] = 0; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1283 if (octave::math::isnan (v[i])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1284 nan = true; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1285 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1286 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1287 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1288 r0 = r; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1289 r += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1290 r0i = ri; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1291 ri += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1292 while (nan && j < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1293 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1294 nan = false; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1295 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1296 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1297 if (octave::math::isnan (v[i])) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1298 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1299 r[i] = r0[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1300 ri[i] = r0i[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1301 nan = true; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1302 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1303 else if (octave::math::isnan (r0[i]) \|\| v[i] OP r0[i]) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1304 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1305 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1306 ri[i] = j; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1307 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1308 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1309 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1310 r[i] = r0[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1311 ri[i] = r0i[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1312 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1313 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1314 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1315 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1316 r0 = r; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1317 r += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1318 r0i = ri; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1319 ri += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1320 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1321 while (j < n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1322 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1323 for (octave_idx_type i = 0; i < m; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1324 if (v[i] OP r0[i]) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1325 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1326 r[i] = v[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1327 ri[i] = j; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1328 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1329 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1330 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1331 r[i] = r0[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1332 ri[i] = r0i[i]; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1333 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1334 j++; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1335 v += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1336 r0 = r; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1337 r += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1338 r0i = ri; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1339 ri += m; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1340 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1341 }
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1342
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1343 OP_CUMMINMAX_FCN2 (mx_inline_cummin, <)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1344 OP_CUMMINMAX_FCN2 (mx_inline_cummax, >)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1345
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1346 #define OP_CUMMINMAX_FCNN(F) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1347 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1348 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1349 F (const T v, T r, octave_idx_type l, \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1350 octave_idx_type n, octave_idx_type u) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1351 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1352 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1353 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1354 if (l == 1) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1355 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1356 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1357 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1358 F (v, r, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1359 v += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1360 r += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1361 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1362 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1363 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1364 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1365 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1366 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1367 F (v, r, l, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1368 v += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1369 r += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1370 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1371 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1372 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1373 template <typename T> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1374 inline void \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1375 F (const T v, T r, octave_idx_type *ri, \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1376 octave_idx_type l, octave_idx_type n, octave_idx_type u) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1377 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1378 if (! n) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1379 return; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1380 if (l == 1) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1381 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1382 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1383 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1384 F (v, r, ri, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1385 v += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1386 r += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1387 ri += n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1388 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1389 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1390 else \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1391 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1392 for (octave_idx_type i = 0; i < u; i++) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1393 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1394 F (v, r, ri, l, n); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1395 v += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1396 r += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1397 ri += l*n; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1398 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1399 } \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1400 }
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1401
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1402 OP_CUMMINMAX_FCNN (mx_inline_cummin)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1403 OP_CUMMINMAX_FCNN (mx_inline_cummax)
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1404
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1405 template <typename T>
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1406 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	1407 octave_idx_type order)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1408 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1409 switch (order)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1410 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1411 case 1:
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1412 for (octave_idx_type i = 0; i < n-1; i++)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1413 r[i] = v[i+1] - v[i];
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1414 break;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1415 case 2:
9702 9ecd35a606e3 avoid some warnings from g++ John W. Eaton <jwe@octave.org> parents: 9612 diff changeset	1416 if (n > 1)
10314 07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1417 {
07ebe522dac2 untabify liboctave C++ sources John W. Eaton <jwe@octave.org> parents: 10158 diff changeset	1418 T lst = v[1] - v[0];
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1419 for (octave_idx_type i = 0; i < n-2; i++)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1420 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1421 T dif = v[i+2] - v[i+1];
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1422 r[i] = dif - lst;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1423 lst = dif;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1424 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1425 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1426 break;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1427 default:
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1428 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1429 OCTAVE_LOCAL_BUFFER (T, buf, n-1);
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1430
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1431 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	1432 buf[i] = v[i+1] - v[i];
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1433
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1434 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	1435 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1436 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	1437 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	1438 }
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1439
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1440 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	1441 r[i] = buf[i];
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1442 }
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1443 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1444 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1445
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1446 template <typename T>
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	1447 void
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	1448 mx_inline_diff (const T v, T r,
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	1449 octave_idx_type m, octave_idx_type n,
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	1450 octave_idx_type order)
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1451 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1452 switch (order)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1453 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1454 case 1:
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1455 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	1456 r[i] = v[i+m] - v[i];
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1457 break;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1458 case 2:
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1459 for (octave_idx_type i = 0; i < n-2; i++)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1460 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1461 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	1462 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	1463 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1464 break;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1465 default:
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1466 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1467 OCTAVE_LOCAL_BUFFER (T, buf, n-1);
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1468
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1469 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	1470 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1471 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	1472 buf[i] = v[im+j+m] - v[im+j];
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1473
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1474 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	1475 {
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1476 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	1477 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	1478 }
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1479
17769 49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1480 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	1481 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	1482 }
49a5a4be04a1 maint: Use GNU style coding conventions for code in liboctave/ Rik <rik@octave.org> parents: 17744 diff changeset	1483 }
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1484 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1485 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1486
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1487 template <typename T>
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1488 inline void
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1489 mx_inline_diff (const T v, T r,
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1490 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	1491 octave_idx_type order)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1492 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1493 if (! n) return;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1494 if (l == 1)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1495 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1496 for (octave_idx_type i = 0; i < u; i++)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1497 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1498 mx_inline_diff (v, r, n, order);
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1499 v += n; r += n-order;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1500 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1501 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1502 else
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1503 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1504 for (octave_idx_type i = 0; i < u; i++)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1505 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1506 mx_inline_diff (v, r, l, n, order);
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1507 v += l*n;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1508 r += l*(n-order);
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1509 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1510 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1511 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1512
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1513 // Assistant function
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1514
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1515 inline void
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1516 get_extent_triplet (const dim_vector& dims, int& dim,
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1517 octave_idx_type& l, octave_idx_type& n,
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1518 octave_idx_type& u)
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1519 {
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21139 diff changeset	1520 octave_idx_type ndims = dims.ndims ();
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1521 if (dim >= ndims)
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1522 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1523 l = dims.numel ();
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1524 n = 1;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1525 u = 1;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1526 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1527 else
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1528 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1529 if (dim < 0)
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1530 dim = dims.first_non_singleton ();
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1531
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1532 // calculate extent triplet.
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1533 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	1534 for (octave_idx_type i = 0; i < dim; i++)
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	1535 l *= dims(i);
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1536 for (octave_idx_type i = dim + 1; i < ndims; i++)
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	1537 u *= dims(i);
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1538 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1539 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1540
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1541 // Appliers.
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1542 // 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	1543 // maybe it can be done without an explicit parameter?
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1544
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1545 template <typename R, typename T>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1546 inline Array<R>
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1547 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	1548 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	1549 octave_idx_type, octave_idx_type))
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1550 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1551 octave_idx_type l, n, u;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1552 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	1553 // M*b inconsistency: sum ([]) = 0 etc.
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21139 diff changeset	1554 if (dims.ndims () == 2 && dims(0) == 0 && dims(1) == 0)
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	1555 dims(1) = 1;
8743 1bd918cfb6e2 reimplement any & all using the new reduction code Jaroslav Hajek <highegg@gmail.com> parents: 8736 diff changeset	1556
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1557 get_extent_triplet (dims, dim, l, n, u);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1558
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1559 // Reduction operation reduces the array size.
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21139 diff changeset	1560 if (dim < dims.ndims ()) dims(dim) = 1;
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1561 dims.chop_trailing_singletons ();
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1562
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1563 Array<R> ret (dims);
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	1564 mx_red_op (src.data (), ret.rwdata (), l, n, u);
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1565
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1566 return ret;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1567 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1568
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1569 template <typename R, typename T>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1570 inline Array<R>
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1571 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	1572 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	1573 octave_idx_type, octave_idx_type))
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1574 {
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1575 octave_idx_type l, n, u;
32598 2f3b54f81947 avoid dim_vector copies in more places where possible (bug #64962) John W. Eaton <jwe@octave.org> parents: 32592 diff changeset	1576 const dim_vector& dims = src.dims ();
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1577 get_extent_triplet (dims, dim, l, n, u);
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1578
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1579 // 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	1580 Array<R> ret (dims);
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	1581 mx_cum_op (src.data (), ret.rwdata (), l, n, u);
8736 53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1582
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1583 return ret;
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1584 }
53b4fdeacc2e improve reduction functions Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	1585
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1586 template <typename R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1587 inline Array<R>
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1588 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	1589 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	1590 octave_idx_type, octave_idx_type))
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1591 {
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1592 octave_idx_type l, n, u;
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1593 dim_vector dims = src.dims ();
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1594 get_extent_triplet (dims, dim, l, n, u);
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1595
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1596 // If the dimension is zero, we don't do anything.
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21139 diff changeset	1597 if (dim < dims.ndims () && dims(dim) != 0) dims(dim) = 1;
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1598 dims.chop_trailing_singletons ();
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1599
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1600 Array<R> ret (dims);
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	1601 mx_minmax_op (src.data (), ret.rwdata (), l, n, u);
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1602
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1603 return ret;
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1604 }
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1605
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1606 template <typename R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1607 inline Array<R>
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1608 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	1609 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	1610 octave_idx_type, octave_idx_type, octave_idx_type))
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1611 {
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1612 octave_idx_type l, n, u;
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1613 dim_vector dims = src.dims ();
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1614 get_extent_triplet (dims, dim, l, n, u);
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1615
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1616 // If the dimension is zero, we don't do anything.
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21139 diff changeset	1617 if (dim < dims.ndims () && dims(dim) != 0) dims(dim) = 1;
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1618 dims.chop_trailing_singletons ();
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1619
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1620 Array<R> ret (dims);
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1621 if (idx.dims () != dims) idx = Array<octave_idx_type> (dims);
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1622
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	1623 mx_minmax_op (src.data (), ret.rwdata (), idx.rwdata (),
8751 9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1624 l, n, u);
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1625
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1626 return ret;
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1627 }
9f7ce4bf7650 optimize min/max functions Jaroslav Hajek <highegg@gmail.com> parents: 8743 diff changeset	1628
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1629 template <typename R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1630 inline Array<R>
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1631 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	1632 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	1633 octave_idx_type, octave_idx_type))
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1634 {
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1635 octave_idx_type l, n, u;
32598 2f3b54f81947 avoid dim_vector copies in more places where possible (bug #64962) John W. Eaton <jwe@octave.org> parents: 32592 diff changeset	1636 const dim_vector& dims = src.dims ();
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1637 get_extent_triplet (dims, dim, l, n, u);
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1638
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1639 Array<R> ret (dims);
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	1640 mx_cumminmax_op (src.data (), ret.rwdata (), l, n, u);
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1641
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1642 return ret;
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1643 }
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1644
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1645 template <typename R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1646 inline Array<R>
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1647 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	1648 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	1649 octave_idx_type, octave_idx_type, octave_idx_type))
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1650 {
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1651 octave_idx_type l, n, u;
32598 2f3b54f81947 avoid dim_vector copies in more places where possible (bug #64962) John W. Eaton <jwe@octave.org> parents: 32592 diff changeset	1652 const dim_vector& dims = src.dims ();
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1653 get_extent_triplet (dims, dim, l, n, u);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1654
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1655 Array<R> ret (dims);
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1656 if (idx.dims () != dims) idx = Array<octave_idx_type> (dims);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1657
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	1658 mx_cumminmax_op (src.data (), ret.rwdata (), idx.rwdata (),
8777 724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1659 l, n, u);
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1660
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1661 return ret;
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1662 }
724c0f46d9d4 implement cummin/cummax functions Jaroslav Hajek <highegg@gmail.com> parents: 8776 diff changeset	1663
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1664 template <typename R>
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1665 inline Array<R>
b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1666 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	1667 void (mx_diff_op) (const R , R *,
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1668 octave_idx_type, octave_idx_type,
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1669 octave_idx_type, octave_idx_type))
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1670 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1671 octave_idx_type l, n, u;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1672 if (order <= 0)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1673 return src;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1674
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1675 dim_vector dims = src.dims ();
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1676
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1677 get_extent_triplet (dims, dim, l, n, u);
21660 53728df3e4c9 maint: for clarity, call ndims() rather than length() on dimension vectors. Rik <rik@octave.org> parents: 21139 diff changeset	1678 if (dim >= dims.ndims ())
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1679 dims.resize (dim+1, 1);
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1680
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1681 if (dims(dim) <= order)
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1682 {
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19697 diff changeset	1683 dims(dim) = 0;
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1684 return Array<R> (dims);
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1685 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1686 else
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1687 {
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1688 dims(dim) -= order;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1689 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1690
10362 b47ab50a6aa8 simplify appliers in mx-inlines.cc Jaroslav Hajek <highegg@gmail.com> parents: 10314 diff changeset	1691 Array<R> ret (dims);
32660 f53ac65ffba6 maint: New method rwdata() as clearer alternative to fortran_vec(). Rik <rik@octave.org> parents: 32633 diff changeset	1692 mx_diff_op (src.data (), ret.rwdata (), l, n, u, order);
9513 9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1693
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1694 return ret;
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1695 }
9f870f73ab7d implement built-in diff Jaroslav Hajek <highegg@gmail.com> parents: 8949 diff changeset	1696
21751 b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21690 diff changeset	1697 // Fast extra-precise summation. According to
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1698 // 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	1699 // Accurate Sum And Dot Product,
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1700 // 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	1701
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1702 template <typename T>
32590 3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	1703 inline void
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	1704 twosum_accum (T& s, T& e,
3c2c585965cc maint: C++ style check for liboctave/ before 9.1 release. Rik <rik@octave.org> parents: 31706 diff changeset	1705 const T& x)
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1706 {
18084 8e056300994b Follow coding convention of defining and initializing only 1 variable per line in liboctave. Rik <rik@octave.org> parents: 17769 diff changeset	1707 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	1708 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	1709 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	1710 s = s1;
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1711 e += e1;
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1712 }
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1713
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1714 template <typename T>
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1715 inline T
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1716 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	1717 {
18099 6c706a83070f Tweak cset 8e056300994b defining 1 var per line in liboctave. Rik <rik@octave.org> parents: 18084 diff changeset	1718 T s, e;
6c706a83070f Tweak cset 8e056300994b defining 1 var per line in liboctave. Rik <rik@octave.org> parents: 18084 diff changeset	1719 s = e = 0;
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1720 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	1721 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	1722
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1723 return s + e;
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1724 }
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1725
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21129 diff changeset	1726 template <typename T>
9721 192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1727 inline void
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1728 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	1729 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	1730 {
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1731 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	1732 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	1733 e[i] = r[i] = T ();
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1734
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1735 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	1736 {
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1737 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	1738 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	1739
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1740 v += m;
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1741 }
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1742
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1743 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	1744 r[i] += e[i];
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1745 }
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1746
192d94cff6c1 improve sum & implement the 'extra' option, refactor some code Jaroslav Hajek <highegg@gmail.com> parents: 9702 diff changeset	1747 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	1748
2804 eedc2f3f61f7 [project @ 1997-03-11 04:34:50 by jwe] jwe parents: 2386 diff changeset	1749 #endif

Mercurial > octave

annotate liboctave/operators/mx-inlines.cc @ 33657:6f2baadfdb3d bytecode-interpreter tip