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

annotate liboctave/operators/mx-inlines.cc @ 30564:796f54d4ddbf stable

update Octave Project Developers copyright for the new year In files that have the "Octave Project Developers" copyright notice, update for 2021. In all .txi and .texi files except gpl.txi and gpl.texi in the doc/liboctave and doc/interpreter directories, change the copyright to "Octave Project Developers", the same as used for other source files. Update copyright notices for 2022 (not done since 2019). For gpl.txi and gpl.texi, change the copyright notice to be "Free Software Foundation, Inc." and leave the date at 2007 only because this file only contains the text of the GPL, not anything created by the Octave Project Developers. Add Paul Thomas to contributors.in.

author	John W. Eaton <jwe@octave.org>
date	Tue, 28 Dec 2021 18:22:40 -0500
parents	1f0a2689cab2
children	51a3d3a69193

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

Mercurial > octave

annotate liboctave/operators/mx-inlines.cc @ 30564:796f54d4ddbf stable