Mercurial > octave
annotate libinterp/corefcn/max.cc @ 29359:7854d5752dd2
maint: merge stable to default.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Wed, 10 Feb 2021 10:10:40 -0500 |
parents | 06c8e0877864 0a5b15007766 |
children | 32c3a5805893 |
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 // |
29358
0a5b15007766
update Octave Project Developers copyright for the new year
John W. Eaton <jwe@octave.org>
parents:
27955
diff
changeset
|
3 // Copyright (C) 1996-2021 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 //////////////////////////////////////////////////////////////////////// |
2928 | 25 |
21724
aba2e6293dd8
use "#if ..." consistently instead of "#ifdef" and "#ifndef"
John W. Eaton <jwe@octave.org>
parents:
21604
diff
changeset
|
26 #if defined (HAVE_CONFIG_H) |
21301
40de9f8f23a6
Use '#include "config.h"' rather than <config.h>.
Rik <rik@octave.org>
parents:
21265
diff
changeset
|
27 # include "config.h" |
2928 | 28 #endif |
29 | |
23662
bd77ab816e43
eliminate obsolete file lo-math.h
John W. Eaton <jwe@octave.org>
parents:
23583
diff
changeset
|
30 #include <cmath> |
bd77ab816e43
eliminate obsolete file lo-math.h
John W. Eaton <jwe@octave.org>
parents:
23583
diff
changeset
|
31 |
2928 | 32 #include "lo-ieee.h" |
3248 | 33 #include "lo-mappers.h" |
4844 | 34 #include "dNDArray.h" |
35 #include "CNDArray.h" | |
4153 | 36 #include "quit.h" |
2928 | 37 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14501
diff
changeset
|
38 #include "defun.h" |
2928 | 39 #include "error.h" |
21100
e39e05d90788
Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents:
20946
diff
changeset
|
40 #include "errwarn.h" |
20940
48b2ad5ee801
maint: Rename oct-obj.[cc|h] to ovl.[cc|h] for clarity.
Rik <rik@octave.org>
parents:
20921
diff
changeset
|
41 #include "ovl.h" |
2928 | 42 |
4844 | 43 #include "ov-cx-mat.h" |
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
44 #include "ov-re-sparse.h" |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
45 #include "ov-cx-sparse.h" |
4844 | 46 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21100
diff
changeset
|
47 template <typename ArrayType> |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
48 static octave_value_list |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
49 do_minmax_red_op (const octave_value& arg, |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
50 int nargout, int dim, bool ismin) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
51 { |
20892 | 52 octave_value_list retval (nargout > 1 ? 2 : 1); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
53 ArrayType array = octave_value_extract<ArrayType> (arg); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
54 |
20892 | 55 if (nargout <= 1) |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
56 { |
20892 | 57 if (ismin) |
58 retval(0) = array.min (dim); | |
59 else | |
60 retval(0) = array.max (dim); | |
61 } | |
62 else | |
63 { | |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
64 Array<octave_idx_type> idx; |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
65 if (ismin) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
66 retval(0) = array.min (idx, dim); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
67 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
68 retval(0) = array.max (idx, dim); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
69 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
70 retval(1) = octave_value (idx, true, true); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
71 } |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
72 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
73 return retval; |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
74 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
75 |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
76 // Matlab returns double arrays for min/max operations on character |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
77 // arrays, so we specialize here to get that behavior. Other possible |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
78 // solutions are to convert the argument to double here and call the |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
79 // code for double, but that could waste memory, or to have the |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
80 // underlying charNDArray::min/max functions return NDArray instead of |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
81 // charNDArray, but that is inconsistent with the way other min/max |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
82 // functions work. |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
83 |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
84 template <> |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
85 octave_value_list |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
86 do_minmax_red_op<charNDArray> (const octave_value& arg, |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
87 int nargout, int dim, bool ismin) |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
88 { |
20892 | 89 octave_value_list retval (nargout > 1 ? 2 : 1); |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
90 charNDArray array = octave_value_extract<charNDArray> (arg); |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
91 |
20892 | 92 if (nargout <= 1) |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
93 { |
20892 | 94 if (ismin) |
95 retval(0) = NDArray (array.min (dim)); | |
96 else | |
97 retval(0) = NDArray (array.max (dim)); | |
98 } | |
99 else | |
100 { | |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
101 Array<octave_idx_type> idx; |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
102 if (ismin) |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
103 retval(0) = NDArray (array.min (idx, dim)); |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
104 else |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
105 retval(0) = NDArray (array.max (idx, dim)); |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
106 |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
107 retval(1) = octave_value (idx, true, true); |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
108 } |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
109 |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
110 return retval; |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
111 } |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
112 |
21265
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
113 // Specialization for bool arrays (dense or sparse). |
9993
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
114 template <> |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
115 octave_value_list |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
116 do_minmax_red_op<boolNDArray> (const octave_value& arg, |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
117 int nargout, int dim, bool ismin) |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
118 { |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
119 octave_value_list retval; |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
120 |
23583
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
121 if (! arg.issparse ()) |
9993
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
122 { |
21265
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
123 if (nargout <= 1) |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
124 { |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
125 // This case can be handled using any/all. |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
126 boolNDArray array = arg.bool_array_value (); |
9993
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
127 |
23577
80c42f4cca13
maint: Deprecate is_empty and replace with isempty.
Rik <rik@octave.org>
parents:
23573
diff
changeset
|
128 if (array.isempty ()) |
21265
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
129 retval(0) = array; |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
130 else if (ismin) |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
131 retval(0) = array.all (dim); |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
132 else |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
133 retval(0) = array.any (dim); |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
134 } |
9993
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
135 else |
21265
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
136 { |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
137 // any/all don't have indexed versions, so do it via a conversion. |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
138 retval = do_minmax_red_op<int8NDArray> (arg, nargout, dim, ismin); |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
139 |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
140 retval(0) = retval(0).bool_array_value (); |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
141 } |
9993
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
142 } |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
143 else |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
144 { |
21604
d7a268e68e69
maint: Strip trailing whitespace from source files.
John W. Eaton <jwe@octave.org>
parents:
21301
diff
changeset
|
145 // Sparse: Don't use any/all trick, as full matrix could exceed memory. |
21265
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
146 // Instead, convert to double. |
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
147 retval = do_minmax_red_op<SparseMatrix> (arg, nargout, dim, ismin); |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20228
diff
changeset
|
148 |
21265
f780d057a3ec
Let max/min return a second (index) value for sparse logicals (bug #41512).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
21200
diff
changeset
|
149 retval(0) = retval(0).sparse_bool_matrix_value (); |
9993
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
150 } |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
151 |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
152 return retval; |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
153 } |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
154 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21100
diff
changeset
|
155 template <typename ArrayType> |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
156 static octave_value |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
157 do_minmax_bin_op (const octave_value& argx, const octave_value& argy, |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
158 bool ismin) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
159 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
160 typedef typename ArrayType::element_type ScalarType; |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
161 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
162 octave_value retval; |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
163 |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
164 if (argx.is_scalar_type ()) |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
165 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
166 ScalarType x = octave_value_extract<ScalarType> (argx); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
167 ArrayType y = octave_value_extract<ArrayType> (argy); |
7189 | 168 |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20228
diff
changeset
|
169 if (ismin) |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
170 retval = min (x, y); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
171 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
172 retval = max (x, y); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
173 } |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
174 else if (argy.is_scalar_type ()) |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
175 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
176 ArrayType x = octave_value_extract<ArrayType> (argx); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
177 ScalarType y = octave_value_extract<ScalarType> (argy); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
178 |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20228
diff
changeset
|
179 if (ismin) |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
180 retval = min (x, y); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
181 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
182 retval = max (x, y); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
183 } |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
184 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
185 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
186 ArrayType x = octave_value_extract<ArrayType> (argx); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
187 ArrayType y = octave_value_extract<ArrayType> (argy); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
188 |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20228
diff
changeset
|
189 if (ismin) |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
190 retval = min (x, y); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
191 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
192 retval = max (x, y); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
193 } |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
194 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
195 return retval; |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
196 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
197 |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
198 // Matlab returns double arrays for min/max operations on character |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
199 // arrays, so we specialize here to get that behavior. Other possible |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
200 // solutions are to convert the arguments to double here and call the |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
201 // code for double, but that could waste a lot of memory, or to have the |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
202 // underlying charNDArray::min/max functions return NDArray instead of |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
203 // charNDArray, but that is inconsistent with the way other min/max |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
204 // functions work. |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
205 |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
206 template <> |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
207 octave_value |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
208 do_minmax_bin_op<charNDArray> (const octave_value& argx, |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
209 const octave_value& argy, bool ismin) |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
210 { |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
211 octave_value retval; |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
212 |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
213 charNDArray x = octave_value_extract<charNDArray> (argx); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
214 charNDArray y = octave_value_extract<charNDArray> (argy); |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
215 |
20555
f90c8372b7ba
eliminate many more simple uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20228
diff
changeset
|
216 if (ismin) |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
217 { |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
218 if (x.numel () == 1) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
219 retval = NDArray (min (x(0), y)); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
220 else if (y.numel () == 1) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
221 retval = NDArray (min (x, y(0))); |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
222 else |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
223 retval = NDArray (min (x, y)); |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
224 } |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
225 else |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
226 { |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
227 if (x.numel () == 1) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
228 retval = NDArray (max (x(0), y)); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
229 else if (y.numel () == 1) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
230 retval = NDArray (max (x, y(0))); |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
231 else |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
232 retval = NDArray (max (x, y)); |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
233 } |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
234 |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
235 return retval; |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
236 } |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
237 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
238 static octave_value_list |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
239 do_minmax_body (const octave_value_list& args, |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
240 int nargout, bool ismin) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
241 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
242 int nargin = args.length (); |
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7662
diff
changeset
|
243 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
244 if (nargin < 1 || nargin > 3) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
245 print_usage (); |
20921
4d3daf7e43f3
eliminate trailing whitespace in source files
John W. Eaton <jwe@octave.org>
parents:
20892
diff
changeset
|
246 |
20892 | 247 octave_value_list retval (nargout > 1 ? 2 : 1); |
248 | |
23450
855122b993da
maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
249 const char *func = (ismin ? "min" : "max"); |
20892 | 250 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
251 if (nargin == 3 || nargin == 1) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
252 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
253 octave_value arg = args(0); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
254 int dim = -1; |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
255 if (nargin == 3) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
256 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
257 dim = args(2).int_value (true) - 1; |
20743
b6408331bfa2
eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
258 |
b6408331bfa2
eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
259 if (dim < 0) |
20831
35241c4b696c
eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents:
20802
diff
changeset
|
260 error ("%s: DIM must be a valid dimension", func); |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
261 |
23577
80c42f4cca13
maint: Deprecate is_empty and replace with isempty.
Rik <rik@octave.org>
parents:
23573
diff
changeset
|
262 if (! args(1).isempty ()) |
13717
fcdf0993b8c9
Fix segfault in do_minmax_bin_op (bug #34589)
Jordi Gutiérrez Hermoso <jordigh@octave.org>
parents:
11586
diff
changeset
|
263 warning ("%s: second argument is ignored", func); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
264 } |
7189 | 265 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
266 switch (arg.builtin_type ()) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
267 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
268 case btyp_double: |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
269 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
270 if (arg.is_range () && (dim == -1 || dim == 1)) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
271 { |
28638
98192ec1621f
replace Range with range<double>
John W. Eaton <jwe@octave.org>
parents:
28636
diff
changeset
|
272 octave::range<double> range = arg.range_value (); |
20228
00cf2847355d
Deprecate Array::nelem() and Range::nelem() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents:
20172
diff
changeset
|
273 if (range.numel () < 1) |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
274 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
275 retval(0) = arg; |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
276 if (nargout > 1) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
277 retval(1) = arg; |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
278 } |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
279 else if (ismin) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
280 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
281 retval(0) = range.min (); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
282 if (nargout > 1) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
283 retval(1) = static_cast<double> |
28636
a3db48e66ef8
use Range::increment instead of Range::inc
John W. Eaton <jwe@octave.org>
parents:
27955
diff
changeset
|
284 (range.increment () < 0 ? range.numel () : 1); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
285 } |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
286 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
287 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
288 retval(0) = range.max (); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
289 if (nargout > 1) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
290 retval(1) = static_cast<double> |
28636
a3db48e66ef8
use Range::increment instead of Range::inc
John W. Eaton <jwe@octave.org>
parents:
27955
diff
changeset
|
291 (range.increment () >= 0 ? range.numel () : 1); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
292 } |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
293 } |
23583
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
294 else if (arg.issparse ()) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
295 retval = do_minmax_red_op<SparseMatrix> (arg, nargout, dim, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
296 ismin); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
297 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
298 retval = do_minmax_red_op<NDArray> (arg, nargout, dim, ismin); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
299 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
300 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
301 break; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
302 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
303 case btyp_complex: |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
304 { |
23583
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
305 if (arg.issparse ()) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
306 retval = do_minmax_red_op<SparseComplexMatrix> (arg, nargout, dim, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
307 ismin); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
308 else |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
309 retval = do_minmax_red_op<ComplexNDArray> (arg, nargout, dim, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
310 ismin); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
311 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
312 break; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
313 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
314 case btyp_float: |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
315 retval = do_minmax_red_op<FloatNDArray> (arg, nargout, dim, ismin); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
316 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
317 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
318 case btyp_float_complex: |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
319 retval = do_minmax_red_op<FloatComplexNDArray> (arg, nargout, dim, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
320 ismin); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
321 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
322 |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
323 case btyp_char: |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
324 retval = do_minmax_red_op<charNDArray> (arg, nargout, dim, ismin); |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
325 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
326 |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
327 #define MAKE_INT_BRANCH(X) \ |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
328 case btyp_ ## X: \ |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
329 retval = do_minmax_red_op<X ## NDArray> (arg, nargout, dim, ismin); \ |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
330 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
331 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
332 MAKE_INT_BRANCH (int8); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
333 MAKE_INT_BRANCH (int16); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
334 MAKE_INT_BRANCH (int32); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
335 MAKE_INT_BRANCH (int64); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
336 MAKE_INT_BRANCH (uint8); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
337 MAKE_INT_BRANCH (uint16); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
338 MAKE_INT_BRANCH (uint32); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
339 MAKE_INT_BRANCH (uint64); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
340 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
341 #undef MAKE_INT_BRANCH |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
342 |
9993
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
343 case btyp_bool: |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
344 retval = do_minmax_red_op<boolNDArray> (arg, nargout, dim, ismin); |
b22a2f4b34aa
support min/max with logical arrays
Jaroslav Hajek <highegg@gmail.com>
parents:
9791
diff
changeset
|
345 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
346 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
347 default: |
21100
e39e05d90788
Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents:
20946
diff
changeset
|
348 err_wrong_type_arg (func, arg); |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
349 } |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
350 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
351 else |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
352 { |
18100
6a71e5030df5
Follow coding convention of defining and initializing only 1 variable per line in liboctinterp.
Rik <rik@octave.org>
parents:
18076
diff
changeset
|
353 octave_value argx = args(0); |
6a71e5030df5
Follow coding convention of defining and initializing only 1 variable per line in liboctinterp.
Rik <rik@octave.org>
parents:
18076
diff
changeset
|
354 octave_value argy = args(1); |
6a71e5030df5
Follow coding convention of defining and initializing only 1 variable per line in liboctinterp.
Rik <rik@octave.org>
parents:
18076
diff
changeset
|
355 builtin_type_t xtyp = argx.builtin_type (); |
6a71e5030df5
Follow coding convention of defining and initializing only 1 variable per line in liboctinterp.
Rik <rik@octave.org>
parents:
18076
diff
changeset
|
356 builtin_type_t ytyp = argy.builtin_type (); |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
357 builtin_type_t rtyp; |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
358 if (xtyp == btyp_char && ytyp == btyp_char) |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
359 rtyp = btyp_char; |
20946 | 360 // FIXME: This is what should happen when boolNDArray has max() |
361 // else if (xtyp == btyp_bool && ytyp == btyp_bool) | |
362 // rtyp = btyp_bool; | |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
363 else |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
364 rtyp = btyp_mixed_numeric (xtyp, ytyp); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
365 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
366 switch (rtyp) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
367 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
368 case btyp_double: |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
369 { |
23583
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
370 if ((argx.issparse () |
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
371 && (argy.issparse () || argy.is_scalar_type ())) |
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
372 || (argy.issparse () && argx.is_scalar_type ())) |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
373 retval = do_minmax_bin_op<SparseMatrix> (argx, argy, ismin); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
374 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
375 retval = do_minmax_bin_op<NDArray> (argx, argy, ismin); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
376 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
377 break; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
378 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
379 case btyp_complex: |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
380 { |
23583
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
381 if ((argx.issparse () |
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
382 && (argy.issparse () || argy.is_scalar_type ())) |
b7747a2c88b2
maint: Deprecate is_sparse_type and replace with issparse.
Rik <rik@octave.org>
parents:
23577
diff
changeset
|
383 || (argy.issparse () && argx.is_scalar_type ())) |
17787
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
384 retval = do_minmax_bin_op<SparseComplexMatrix> (argx, argy, |
175b392e91fe
Use GNU style coding conventions for code in libinterp/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
385 ismin); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
386 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
387 retval = do_minmax_bin_op<ComplexNDArray> (argx, argy, ismin); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
388 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
389 break; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
390 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
391 case btyp_float: |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
392 retval = do_minmax_bin_op<FloatNDArray> (argx, argy, ismin); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
393 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
394 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
395 case btyp_float_complex: |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
396 retval = do_minmax_bin_op<FloatComplexNDArray> (argx, argy, ismin); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
397 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
398 |
16370
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
399 case btyp_char: |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
400 retval = do_minmax_bin_op<charNDArray> (argx, argy, ismin); |
7ce21619a4b9
min Matlab compatibility issue (bug #33530)
Axel Mathéi <axel.mathei@gmail.com>
parents:
15195
diff
changeset
|
401 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
402 |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
403 #define MAKE_INT_BRANCH(X) \ |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
404 case btyp_ ## X: \ |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
405 retval = do_minmax_bin_op<X ## NDArray> (argx, argy, ismin); \ |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
406 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
407 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
408 MAKE_INT_BRANCH (int8); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
409 MAKE_INT_BRANCH (int16); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
410 MAKE_INT_BRANCH (int32); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
411 MAKE_INT_BRANCH (int64); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
412 MAKE_INT_BRANCH (uint8); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
413 MAKE_INT_BRANCH (uint16); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
414 MAKE_INT_BRANCH (uint32); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
415 MAKE_INT_BRANCH (uint64); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
416 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
417 #undef MAKE_INT_BRANCH |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
418 |
20946 | 419 // FIXME: This is what should happen when boolNDArray has max() |
420 // case btyp_bool: | |
421 // retval = do_minmax_bin_op<boolNDArray> (argx, argy, ismin); | |
422 // break; | |
423 | |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
424 default: |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
425 error ("%s: cannot compute %s (%s, %s)", func, func, |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
426 argx.type_name ().c_str (), argy.type_name ().c_str ()); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
427 } |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
428 |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
429 // FIXME: Delete when boolNDArray has max() |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
430 if (xtyp == btyp_bool && ytyp == btyp_bool) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
431 retval(0) = retval(0).bool_array_value (); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
432 |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
433 } |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
434 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
435 return retval; |
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
436 } |
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7231
diff
changeset
|
437 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14501
diff
changeset
|
438 DEFUN (min, args, nargout, |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
439 doc: /* -*- texinfo -*- |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
440 @deftypefn {} {} min (@var{x}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
441 @deftypefnx {} {} min (@var{x}, [], @var{dim}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
442 @deftypefnx {} {[@var{w}, @var{iw}] =} min (@var{x}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
443 @deftypefnx {} {} min (@var{x}, @var{y}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
444 Find minimum values in the array @var{x}. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
445 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
446 For a vector argument, return the minimum value. For a matrix argument, |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
447 return a row vector with the minimum value of each column. For a |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
448 multi-dimensional array, @code{min} operates along the first non-singleton |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
449 dimension. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
450 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
451 If the optional third argument @var{dim} is present then operate along |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
452 this dimension. In this case the second argument is ignored and should be |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
453 set to the empty matrix. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
454 |
27955
179ece36a2eb
doc: Clarify two-input argument form for max() and min() (bug #57573).
Rik <rik@octave.org>
parents:
27923
diff
changeset
|
455 For two inputs (@var{x} and @var{y}), return the pairwise minimum according to |
179ece36a2eb
doc: Clarify two-input argument form for max() and min() (bug #57573).
Rik <rik@octave.org>
parents:
27923
diff
changeset
|
456 the rules for @ref{Broadcasting}. |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
457 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
458 Thus, |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
459 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
460 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
461 min (min (@var{x})) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
462 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
463 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
464 @noindent |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
465 returns the smallest element of the 2-D matrix @var{x}, and |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
466 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
467 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
468 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
469 min (2:5, pi) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
470 @result{} 2.0000 3.0000 3.1416 3.1416 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
471 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
472 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
473 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
474 @noindent |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
475 compares each element of the range @code{2:5} with @code{pi}, and returns a |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
476 row vector of the minimum values. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
477 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
478 For complex arguments, the magnitude of the elements are used for |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
479 comparison. If the magnitudes are identical, then the results are ordered |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
480 by phase angle in the range (-pi, pi]. Hence, |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
481 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
482 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
483 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
484 min ([-1 i 1 -i]) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
485 @result{} -i |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
486 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
487 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
488 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
489 @noindent |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
490 because all entries have magnitude 1, but -i has the smallest phase angle |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
491 with value -pi/2. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
492 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
493 If called with one input and two output arguments, @code{min} also returns |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
494 the first index of the minimum value(s). Thus, |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
495 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
496 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
497 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
498 [x, ix] = min ([1, 3, 0, 2, 0]) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
499 @result{} x = 0 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
500 ix = 3 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
501 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
502 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
503 @seealso{max, cummin, cummax} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
504 @end deftypefn */) |
2928 | 505 { |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
506 return do_minmax_body (args, nargout, true); |
2928 | 507 } |
508 | |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
509 /* |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
510 ## Test generic double class |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
511 %!assert (min ([1, 4, 2, 3]), 1) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
512 %!assert (min ([1; -10; 5; -2]), -10) |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
513 %!assert (min ([4, 2i 4.999; -2, 2, 3+4i]), [-2, 2, 4.999]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
514 ## Special routines for char arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
515 %!assert (min (["abc", "ABC"]), 65) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
516 %!assert (min (["abc"; "CBA"]), [67 66 65]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
517 ## Special routines for logical arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
518 %!assert (min (logical ([])), logical ([])) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
519 %!assert (min (logical ([0 0 1 0])), false) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
520 %!assert (min (logical ([0 0 1 0; 0 1 1 0])), logical ([0 0 1 0])) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
521 ## Single values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
522 %!assert (min (single ([1, 4, 2, 3])), single (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
523 %!assert (min (single ([1; -10; 5; -2])), single (-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
524 %!assert (min (single ([4, 2i 4.999; -2, 2, 3+4i])), single ([-2, 2, 4.999])) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
525 ## Integer values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
526 %!assert (min (uint8 ([1, 4, 2, 3])), uint8 (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
527 %!assert (min (uint8 ([1; -10; 5; -2])), uint8 (-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
528 %!assert (min (int8 ([1, 4, 2, 3])), int8 (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
529 %!assert (min (int8 ([1; -10; 5; -2])), int8 (-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
530 %!assert (min (uint16 ([1, 4, 2, 3])), uint16 (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
531 %!assert (min (uint16 ([1; -10; 5; -2])), uint16 (-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
532 %!assert (min (int16 ([1, 4, 2, 3])), int16 (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
533 %!assert (min (int16 ([1; -10; 5; -2])), int16 (-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
534 %!assert (min (uint32 ([1, 4, 2, 3])), uint32 (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
535 %!assert (min (uint32 ([1; -10; 5; -2])), uint32 (-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
536 %!assert (min (int32 ([1, 4, 2, 3])), int32 (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
537 %!assert (min (int32 ([1; -10; 5; -2])), int32 (-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
538 %!assert (min (uint64 ([1, 4, 2, 3])), uint64 (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
539 %!assert (min (uint64 ([1; -10; 5; -2])), uint64 (-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
540 %!assert (min (int64 ([1, 4, 2, 3])), int64 (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
541 %!assert (min (int64 ([1; -10; 5; -2])), int64 (-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
542 ## Sparse double values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
543 %!assert (min (sparse ([1, 4, 2, 3])), sparse (1)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
544 %!assert (min (sparse ([1; -10; 5; -2])), sparse(-10)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
545 ## FIXME: sparse doesn't order complex values by phase angle |
23690
8bba52bd04d2
* max.cc: Tag %!xtest tests with bug number.
John W. Eaton <jwe@octave.org>
parents:
23662
diff
changeset
|
546 %!test <51307> |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
547 %! assert (min (sparse ([4, 2i 4.999; -2, 2, 3+4i])), sparse ([-2, 2, 4.999])); |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
548 |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
549 ## Test dimension argument |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
550 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
551 %! x = reshape (1:8, [2,2,2]); |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
552 %! assert (min (x, [], 1), reshape ([1, 3, 5, 7], [1,2,2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
553 %! assert (min (x, [], 2), reshape ([1, 2, 5, 6], [2,1,2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
554 %! [y, i] = min (x, [], 3); |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
555 %! assert (ndims (y), 2); |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
556 %! assert (y, [1, 3; 2, 4]); |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
557 %! assert (ndims (i), 2); |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
558 %! assert (i, [1, 1; 1, 1]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
559 |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
560 ## Test 2-output forms for various arg types |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
561 ## Special routines for char arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
562 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
563 %! [y, i] = min (["abc", "ABC"]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
564 %! assert (y, 65); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
565 %! assert (i, 4); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
566 ## Special routines for logical arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
567 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
568 %! x = logical ([0 0 1 0]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
569 %! [y, i] = min (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
570 %! assert (y, false); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
571 %! assert (i, 1); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
572 ## Special handling of ranges |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
573 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
574 %! rng = 1:2:10; |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
575 %! [y, i] = min (rng); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
576 %! assert (y, 1); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
577 %! assert (i, 1); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
578 %! rng = 10:-2:1; |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
579 %! [y, i] = min (rng); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
580 %! assert (y, 2); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
581 %! assert (i, 5); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
582 |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
583 ## Test 2-input calling form for various arg types |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
584 ## Test generic double class |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
585 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
586 %! x = [1, 2, 3, 4]; y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
587 %! assert (min (x, y), [1 2 2 1]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
588 %! assert (min (x, 3), [1 2 3 3]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
589 %! assert (min (2, x), [1 2 2 2]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
590 %! assert (min (x, 2.1i), [1 2 2.1i 2.1i]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
591 ## FIXME: Ordering of complex results with equal magnitude is not by phase |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
592 ## angle in the 2-input form. Instead, it is in the order in which it |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
593 ## appears in the argument list. |
23690
8bba52bd04d2
* max.cc: Tag %!xtest tests with bug number.
John W. Eaton <jwe@octave.org>
parents:
23662
diff
changeset
|
594 %!test <51307> |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
595 %! x = [1, 2, 3, 4]; y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
596 %! assert (min (x, 2i), [2i 2i 3 4]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
597 ## Special routines for char arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
598 %!assert (min ("abc", "b"), [97 98 98]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
599 %!assert (min ("b", "cba"), [98 98 97]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
600 ## Special handling for logical arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
601 %!assert (min ([true false], false), [false false]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
602 %!assert (min (true, [true false]), [true false]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
603 ## Single values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
604 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
605 %! x = single ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
606 %! assert (min (x, y), single ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
607 %! assert (min (x, 3), single ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
608 %! assert (min (2, x), single ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
609 %! assert (min (x, 2.1i), single ([1 2 2.1i 2.1i])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
610 ## Integer values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
611 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
612 %! x = uint8 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
613 %! assert (min (x, y), uint8 ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
614 %! assert (min (x, 3), uint8 ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
615 %! assert (min (2, x), uint8 ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
616 %! x = int8 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
617 %! assert (min (x, y), int8 ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
618 %! assert (min (x, 3), int8 ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
619 %! assert (min (2, x), int8 ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
620 %! x = uint16 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
621 %! assert (min (x, y), uint16 ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
622 %! assert (min (x, 3), uint16 ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
623 %! assert (min (2, x), uint16 ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
624 %! x = int16 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
625 %! assert (min (x, y), int16 ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
626 %! assert (min (x, 3), int16 ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
627 %! assert (min (2, x), int16 ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
628 %! x = uint32 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
629 %! assert (min (x, y), uint32 ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
630 %! assert (min (x, 3), uint32 ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
631 %! assert (min (2, x), uint32 ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
632 %! x = int32 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
633 %! assert (min (x, y), int32 ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
634 %! assert (min (x, 3), int32 ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
635 %! assert (min (2, x), int32 ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
636 %! x = uint64 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
637 %! assert (min (x, y), uint64 ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
638 %! assert (min (x, 3), uint64 ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
639 %! assert (min (2, x), uint64 ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
640 %! x = int64 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
641 %! assert (min (x, y), int64 ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
642 %! assert (min (x, 3), int64 ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
643 %! assert (min (2, x), int64 ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
644 ## Sparse double values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
645 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
646 %! x = sparse ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
647 %! assert (min (x, y), sparse ([1 2 2 1])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
648 %! assert (min (x, 3), sparse ([1 2 3 3])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
649 %! assert (min (2, x), sparse ([1 2 2 2])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
650 %! assert (min (x, 2.1i), sparse ([1 2 2.1i 2.1i])); |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
651 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
652 %!error min () |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
653 %!error min (1, 2, 3, 4) |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
654 %!error <DIM must be a valid dimension> min ([1 2; 3 4], [], -3) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
655 %!warning <second argument is ignored> min ([1 2 3 4], 2, 2); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
656 %!error <wrong type argument 'cell'> min ({1 2 3 4}) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
657 %!error <cannot compute min \(cell, scalar\)> min ({1, 2, 3}, 2) |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
658 */ |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
659 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14501
diff
changeset
|
660 DEFUN (max, args, nargout, |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
661 doc: /* -*- texinfo -*- |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
662 @deftypefn {} {} max (@var{x}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
663 @deftypefnx {} {} max (@var{x}, [], @var{dim}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
664 @deftypefnx {} {[@var{w}, @var{iw}] =} max (@var{x}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
665 @deftypefnx {} {} max (@var{x}, @var{y}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
666 Find maximum values in the array @var{x}. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
667 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
668 For a vector argument, return the maximum value. For a matrix argument, |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
669 return a row vector with the maximum value of each column. For a |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
670 multi-dimensional array, @code{max} operates along the first non-singleton |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
671 dimension. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
672 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
673 If the optional third argument @var{dim} is present then operate along |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
674 this dimension. In this case the second argument is ignored and should be |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
675 set to the empty matrix. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
676 |
27955
179ece36a2eb
doc: Clarify two-input argument form for max() and min() (bug #57573).
Rik <rik@octave.org>
parents:
27923
diff
changeset
|
677 For two inputs (@var{x} and @var{y}), return the pairwise maximum according to |
179ece36a2eb
doc: Clarify two-input argument form for max() and min() (bug #57573).
Rik <rik@octave.org>
parents:
27923
diff
changeset
|
678 the rules for @ref{Broadcasting}. |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
679 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
680 Thus, |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
681 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
682 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
683 max (max (@var{x})) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
684 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
685 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
686 @noindent |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
687 returns the largest element of the 2-D matrix @var{x}, and |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
688 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
689 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
690 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
691 max (2:5, pi) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
692 @result{} 3.1416 3.1416 4.0000 5.0000 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
693 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
694 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
695 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
696 @noindent |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
697 compares each element of the range @code{2:5} with @code{pi}, and returns a |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
698 row vector of the maximum values. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
699 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
700 For complex arguments, the magnitude of the elements are used for |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
701 comparison. If the magnitudes are identical, then the results are ordered |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
702 by phase angle in the range (-pi, pi]. Hence, |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
703 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
704 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
705 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
706 max ([-1 i 1 -i]) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
707 @result{} -1 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
708 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
709 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
710 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
711 @noindent |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
712 because all entries have magnitude 1, but -1 has the largest phase angle |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
713 with value pi. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
714 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
715 If called with one input and two output arguments, @code{max} also returns |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
716 the first index of the maximum value(s). Thus, |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
717 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
718 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
719 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
720 [x, ix] = max ([1, 3, 5, 2, 5]) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
721 @result{} x = 5 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
722 ix = 3 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
723 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
724 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
725 @seealso{min, cummax, cummin} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
726 @end deftypefn */) |
2928 | 727 { |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
728 return do_minmax_body (args, nargout, false); |
2928 | 729 } |
730 | |
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11553
diff
changeset
|
731 /* |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
732 ## Test generic double class |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
733 %!assert (max ([1, 4, 2, 3]), 4) |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
734 %!assert (max ([1; -10; 5; -2]), 5) |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
735 %!assert (max ([4, 2i 4.999; -2, 2, 3+4i]), [4, 2i, 3+4i]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
736 ## Special routines for char arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
737 %!assert (max (["abc", "ABC"]), 99) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
738 %!assert (max (["abc"; "CBA"]), [97 98 99]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
739 ## Special routines for logical arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
740 %!assert (max (logical ([])), logical ([])) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
741 %!assert (max (logical ([0 0 1 0])), true) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
742 %!assert (max (logical ([0 0 1 0; 0 1 0 0])), logical ([0 1 1 0])) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
743 ## Single values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
744 %!assert (max (single ([1, 4, 2, 3])), single (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
745 %!assert (max (single ([1; -10; 5; -2])), single (5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
746 %!assert (max (single ([4, 2i 4.999; -2, 2, 3+4i])), single ([4, 2i, 3+4i])) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
747 ## Integer values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
748 %!assert (max (uint8 ([1, 4, 2, 3])), uint8 (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
749 %!assert (max (uint8 ([1; -10; 5; -2])), uint8 (5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
750 %!assert (max (int8 ([1, 4, 2, 3])), int8 (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
751 %!assert (max (int8 ([1; -10; 5; -2])), int8 (5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
752 %!assert (max (uint16 ([1, 4, 2, 3])), uint16 (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
753 %!assert (max (uint16 ([1; -10; 5; -2])), uint16 (5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
754 %!assert (max (int16 ([1, 4, 2, 3])), int16 (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
755 %!assert (max (int16 ([1; -10; 5; -2])), int16 (5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
756 %!assert (max (uint32 ([1, 4, 2, 3])), uint32 (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
757 %!assert (max (uint32 ([1; -10; 5; -2])), uint32 (5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
758 %!assert (max (int32 ([1, 4, 2, 3])), int32 (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
759 %!assert (max (int32 ([1; -10; 5; -2])), int32 (5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
760 %!assert (max (uint64 ([1, 4, 2, 3])), uint64 (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
761 %!assert (max (uint64 ([1; -10; 5; -2])), uint64 (5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
762 %!assert (max (int64 ([1, 4, 2, 3])), int64 (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
763 %!assert (max (int64 ([1; -10; 5; -2])), int64 (5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
764 ## Sparse double values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
765 %!assert (max (sparse ([1, 4, 2, 3])), sparse (4)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
766 %!assert (max (sparse ([1; -10; 5; -2])), sparse(5)) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
767 %!assert (max (sparse ([4, 2i 4.999; -2, 2, 3+4i])), sparse ([4, 2i, 3+4i])) |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
768 |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
769 ## Test dimension argument |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
770 %!test |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
771 %! x = reshape (1:8, [2,2,2]); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
772 %! assert (min (x, [], 1), reshape ([1, 3, 5, 7], [1,2,2])); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
773 %! assert (min (x, [], 2), reshape ([1, 2, 5, 6], [2,1,2])); |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
774 %! [y, i] = min (x, [], 3); |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
775 %! assert (ndims (y), 2); |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
776 %! assert (y, [1, 3; 2, 4]); |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
777 %! assert (ndims (i), 2); |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
778 %! assert (i, [1, 1; 1, 1]); |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
779 |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
780 ## Test 2-output forms for various arg types |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
781 ## Special routines for char arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
782 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
783 %! [y, i] = max (["abc", "ABC"]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
784 %! assert (y, 99); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
785 %! assert (i, 3); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
786 ## Special routines for logical arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
787 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
788 %! x = logical ([0 0 1 0]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
789 %! [y, i] = max (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
790 %! assert (y, true); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
791 %! assert (i, 3); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
792 ## Special handling of ranges |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
793 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
794 %! rng = 1:2:10; |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
795 %! [y, i] = max (rng); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
796 %! assert (y, 9); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
797 %! assert (i, 5); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
798 %! rng = 10:-2:1; |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
799 %! [y, i] = max (rng); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
800 %! assert (y, 10); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
801 %! assert (i, 1); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
802 |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
803 ## Test 2-input calling form for various arg types |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
804 ## Test generic double class |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
805 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
806 %! x = [1, 2, 3, 4]; y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
807 %! assert (max (x, y), [4 3 3 4]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
808 %! assert (max (x, 3), [3 3 3 4]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
809 %! assert (max (2, x), [2 2 3 4]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
810 %! assert (max (x, 2.1i), [2.1i 2.1i 3 4]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
811 ## FIXME: Ordering of complex results with equal magnitude is not by phase |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
812 ## angle in the 2-input form. Instead, it is in the order in which it |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
813 ## appears in the argument list. |
23690
8bba52bd04d2
* max.cc: Tag %!xtest tests with bug number.
John W. Eaton <jwe@octave.org>
parents:
23662
diff
changeset
|
814 %!test <51307> |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
815 %! x = [1, 2, 3, 4]; y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
816 %! assert (max (x, 2i), [2i 2i 3 4]); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
817 ## Special routines for char arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
818 %!assert (max ("abc", "b"), [98 98 99]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
819 %!assert (max ("b", "cba"), [99 98 98]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
820 ## Special handling for logical arrays |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
821 %!assert (max ([true false], false), [true false]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
822 %!assert (max (true, [false false]), [true true]) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
823 ## Single values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
824 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
825 %! x = single ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
826 %! assert (max (x, y), single ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
827 %! assert (max (x, 3), single ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
828 %! assert (max (2, x), single ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
829 %! assert (max (x, 2.1i), single ([2.1i 2.1i 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
830 ## Integer values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
831 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
832 %! x = uint8 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
833 %! assert (max (x, y), uint8 ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
834 %! assert (max (x, 3), uint8 ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
835 %! assert (max (2, x), uint8 ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
836 %! x = int8 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
837 %! assert (max (x, y), int8 ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
838 %! assert (max (x, 3), int8 ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
839 %! assert (max (2, x), int8 ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
840 %! x = uint16 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
841 %! assert (max (x, y), uint16 ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
842 %! assert (max (x, 3), uint16 ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
843 %! assert (max (2, x), uint16 ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
844 %! x = int16 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
845 %! assert (max (x, y), int16 ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
846 %! assert (max (x, 3), int16 ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
847 %! assert (max (2, x), int16 ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
848 %! x = uint32 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
849 %! assert (max (x, y), uint32 ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
850 %! assert (max (x, 3), uint32 ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
851 %! assert (max (2, x), uint32 ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
852 %! x = int32 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
853 %! assert (max (x, y), int32 ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
854 %! assert (max (x, 3), int32 ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
855 %! assert (max (2, x), int32 ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
856 %! x = uint64 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
857 %! assert (max (x, y), uint64 ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
858 %! assert (max (x, 3), uint64 ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
859 %! assert (max (2, x), uint64 ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
860 %! x = int64 ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
861 %! assert (max (x, y), int64 ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
862 %! assert (max (x, 3), int64 ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
863 %! assert (max (2, x), int64 ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
864 ## Sparse double values |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
865 %!test |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
866 %! x = sparse ([1, 2, 3, 4]); y = fliplr (x); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
867 %! assert (max (x, y), sparse ([4 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
868 %! assert (max (x, 3), sparse ([3 3 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
869 %! assert (max (2, x), sparse ([2 2 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
870 %! assert (max (x, 2.1i), sparse ([2.1i 2.1i 3 4])); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
871 |
18076 | 872 ## Test for bug #40743 |
23573
1b4f4ec53b4a
use new script to tag fixed bugs in tests
John W. Eaton <jwe@octave.org>
parents:
23572
diff
changeset
|
873 %!assert <*40743> (max (zeros (1,0), ones (1,1)), zeros (1,0)) |
1b4f4ec53b4a
use new script to tag fixed bugs in tests
John W. Eaton <jwe@octave.org>
parents:
23572
diff
changeset
|
874 %!assert <*40743> (max (sparse (zeros (1,0)), sparse (ones (1,1))), |
23552
654661539e20
* max.cc: Fix typo in test.
John W. Eaton <jwe@octave.org>
parents:
23450
diff
changeset
|
875 %! sparse (zeros (1,0))) |
18076 | 876 |
14501
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
877 %!error max () |
60e5cf354d80
Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents:
14360
diff
changeset
|
878 %!error max (1, 2, 3, 4) |
19412
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
879 %!error <DIM must be a valid dimension> max ([1 2; 3 4], [], -3) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
880 %!warning <second argument is ignored> max ([1 2 3 4], 2, 2); |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
881 %!error <wrong type argument 'cell'> max ({1 2 3 4}) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
882 %!error <cannot compute max \(cell, scalar\)> max ({1, 2, 3}, 2) |
78e424d31596
Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents:
18227
diff
changeset
|
883 |
7600
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
884 */ |
24abf5a702d9
Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents:
7505
diff
changeset
|
885 |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
21100
diff
changeset
|
886 template <typename ArrayType> |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
887 static octave_value_list |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
888 do_cumminmax_red_op (const octave_value& arg, |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
889 int nargout, int dim, bool ismin) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
890 { |
20892 | 891 octave_value_list retval (nargout > 1 ? 2 : 1); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
892 ArrayType array = octave_value_extract<ArrayType> (arg); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
893 |
20892 | 894 if (nargout <= 1) |
895 { | |
896 if (ismin) | |
897 retval(0) = array.cummin (dim); | |
898 else | |
899 retval(0) = array.cummax (dim); | |
900 } | |
901 else | |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
902 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
903 retval.resize (2); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
904 Array<octave_idx_type> idx; |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
905 if (ismin) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
906 retval(0) = array.cummin (idx, dim); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
907 else |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
908 retval(0) = array.cummax (idx, dim); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
909 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
910 retval(1) = octave_value (idx, true, true); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
911 } |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
912 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
913 return retval; |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
914 } |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
915 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
916 static octave_value_list |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
917 do_cumminmax_body (const octave_value_list& args, |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
918 int nargout, bool ismin) |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
919 { |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
920 int nargin = args.length (); |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
921 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
922 if (nargin < 1 || nargin > 2) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
923 print_usage (); |
20743
b6408331bfa2
eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents:
20555
diff
changeset
|
924 |
23450
855122b993da
maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents:
23220
diff
changeset
|
925 const char *func = (ismin ? "cummin" : "cummax"); |
20892 | 926 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
927 octave_value arg = args(0); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
928 int dim = -1; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
929 if (nargin == 2) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
930 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
931 dim = args(1).int_value (true) - 1; |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
932 |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
933 if (dim < 0) |
20831
35241c4b696c
eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents:
20802
diff
changeset
|
934 error ("%s: DIM must be a valid dimension", func); |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
935 } |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
936 |
20892 | 937 octave_value_list retval; |
938 | |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
939 switch (arg.builtin_type ()) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
940 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
941 case btyp_double: |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
942 retval = do_cumminmax_red_op<NDArray> (arg, nargout, dim, ismin); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
943 break; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
944 |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
945 case btyp_complex: |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
946 retval = do_cumminmax_red_op<ComplexNDArray> (arg, nargout, dim, |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
947 ismin); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
948 break; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
949 |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
950 case btyp_float: |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
951 retval = do_cumminmax_red_op<FloatNDArray> (arg, nargout, dim, ismin); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
952 break; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
953 |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
954 case btyp_float_complex: |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
955 retval = do_cumminmax_red_op<FloatComplexNDArray> (arg, nargout, dim, |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
956 ismin); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
957 break; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
958 |
22407
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
959 #define MAKE_INT_BRANCH(X) \ |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
960 case btyp_ ## X: \ |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
961 retval = do_cumminmax_red_op<X ## NDArray> (arg, nargout, dim, ismin); \ |
34ce5be04942
maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents:
22323
diff
changeset
|
962 break; |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
963 |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
964 MAKE_INT_BRANCH (int8); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
965 MAKE_INT_BRANCH (int16); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
966 MAKE_INT_BRANCH (int32); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
967 MAKE_INT_BRANCH (int64); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
968 MAKE_INT_BRANCH (uint8); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
969 MAKE_INT_BRANCH (uint16); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
970 MAKE_INT_BRANCH (uint32); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
971 MAKE_INT_BRANCH (uint64); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
972 |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
973 #undef MAKE_INT_BRANCH |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
974 |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
975 case btyp_bool: |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
976 { |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
977 retval = do_cumminmax_red_op<int8NDArray> (arg, nargout, dim, |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
978 ismin); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
979 if (retval.length () > 0) |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
980 retval(0) = retval(0).bool_array_value (); |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
981 } |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
982 break; |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
983 |
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
984 default: |
21100
e39e05d90788
Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents:
20946
diff
changeset
|
985 err_wrong_type_arg (func, arg); |
20802
8bb38ba1bad6
eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents:
20743
diff
changeset
|
986 } |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
987 |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
988 return retval; |
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
989 } |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
990 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14501
diff
changeset
|
991 DEFUN (cummin, args, nargout, |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
992 doc: /* -*- texinfo -*- |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
993 @deftypefn {} {} cummin (@var{x}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
994 @deftypefnx {} {} cummin (@var{x}, @var{dim}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
995 @deftypefnx {} {[@var{w}, @var{iw}] =} cummin (@var{x}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
996 Return the cumulative minimum values along dimension @var{dim}. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
997 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
998 If @var{dim} is unspecified it defaults to column-wise operation. For |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
999 example: |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1000 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1001 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1002 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1003 cummin ([5 4 6 2 3 1]) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1004 @result{} 5 4 4 2 2 1 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1005 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1006 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1007 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1008 If called with two output arguments the index of the minimum value is also |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1009 returned. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1010 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1011 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1012 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1013 [w, iw] = cummin ([5 4 6 2 3 1]) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1014 @result{} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1015 w = 5 4 4 2 2 1 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1016 iw = 1 2 2 4 4 6 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1017 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1018 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1019 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1020 @seealso{cummax, min, max} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1021 @end deftypefn */) |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
1022 { |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
1023 return do_cumminmax_body (args, nargout, true); |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
1024 } |
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
1025 |
17403
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1026 /* |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1027 %!assert (cummin ([1, 4, 2, 3]), [1 1 1 1]) |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1028 %!assert (cummin ([1; -10; 5; -2]), [1; -10; -10; -10]) |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1029 %!assert (cummin ([4, i; -2, 2]), [4, i; -2, i]) |
19591
6b09dd576521
Fix cummin/cummax operations on rows when NaN element present (bug #44009).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
19412
diff
changeset
|
1030 %!assert (cummin ([1 2; NaN 1], 2), [1 1; NaN 1]) |
17403
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1031 |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1032 %!test |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1033 %! x = reshape (1:8, [2,2,2]); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1034 %! assert (cummin (x, 1), reshape ([1 1 3 3 5 5 7 7], [2,2,2])); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1035 %! assert (cummin (x, 2), reshape ([1 2 1 2 5 6 5 6], [2,2,2])); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1036 %! [w, iw] = cummin (x, 3); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1037 %! assert (ndims (w), 3); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1038 %! assert (w, repmat ([1 3; 2 4], [1 1 2])); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1039 %! assert (ndims (iw), 3); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1040 %! assert (iw, ones (2,2,2)); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1041 |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1042 %!error cummin () |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1043 %!error cummin (1, 2, 3) |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1044 */ |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1045 |
15039
e753177cde93
maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents:
14501
diff
changeset
|
1046 DEFUN (cummax, args, nargout, |
21966
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1047 doc: /* -*- texinfo -*- |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1048 @deftypefn {} {} cummax (@var{x}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1049 @deftypefnx {} {} cummax (@var{x}, @var{dim}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1050 @deftypefnx {} {[@var{w}, @var{iw}] =} cummax (@dots{}) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1051 Return the cumulative maximum values along dimension @var{dim}. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1052 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1053 If @var{dim} is unspecified it defaults to column-wise operation. For |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1054 example: |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1055 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1056 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1057 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1058 cummax ([1 3 2 6 4 5]) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1059 @result{} 1 3 3 6 6 6 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1060 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1061 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1062 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1063 If called with two output arguments the index of the maximum value is also |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1064 returned. |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1065 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1066 @example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1067 @group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1068 [w, iw] = cummax ([1 3 2 6 4 5]) |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1069 @result{} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1070 w = 1 3 3 6 6 6 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1071 iw = 1 2 2 4 4 4 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1072 @end group |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1073 @end example |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1074 |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1075 @seealso{cummin, max, min} |
112b20240c87
move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents:
21724
diff
changeset
|
1076 @end deftypefn */) |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
1077 { |
9790
a5035bc7fbfb
rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
1078 return do_cumminmax_body (args, nargout, false); |
8777
724c0f46d9d4
implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7919
diff
changeset
|
1079 } |
17403
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1080 |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1081 /* |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1082 %!assert (cummax ([1, 4, 2, 3]), [1 4 4 4]) |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1083 %!assert (cummax ([1; -10; 5; -2]), [1; 1; 5; 5]) |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1084 %!assert (cummax ([4, i 4.9, -2, 2, 3+4i]), [4, 4, 4.9, 4.9, 4.9, 3+4i]) |
19591
6b09dd576521
Fix cummin/cummax operations on rows when NaN element present (bug #44009).
Lachlan Andrew <lachlanbis@gmail.com>
parents:
19412
diff
changeset
|
1085 %!assert (cummax ([1 NaN 0; NaN NaN 1], 2), [1 1 1; NaN NaN 1]) |
17403
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1086 |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1087 %!test |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1088 %! x = reshape (8:-1:1, [2,2,2]); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1089 %! assert (cummax (x, 1), reshape ([8 8 6 6 4 4 2 2], [2,2,2])); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1090 %! assert (cummax (x, 2), reshape ([8 7 8 7 4 3 4 3], [2,2,2])); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1091 %! [w, iw] = cummax (x, 3); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1092 %! assert (ndims (w), 3); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1093 %! assert (w, repmat ([8 6; 7 5], [1 1 2])); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1094 %! assert (ndims (iw), 3); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1095 %! assert (iw, ones (2,2,2)); |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1096 |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1097 %!error cummax () |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1098 %!error cummax (1, 2, 3) |
db8b90a56298
doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents:
16370
diff
changeset
|
1099 */ |