Mercurial > octave

annotate libinterp/corefcn/max.cc @ 27923:bd51beb6205e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update formatting of copyright notices * Use <https://octave.org/copyright/> instead of <https://octave.org/COPYRIGHT.html/>. * For consistency with other comments in the Octave sources, use C++-style comments for copyright blocks in C and C++ files. * Use delimiters above and below copyright blocks that are appropriate for the language used in the file. * Eliminate extra spacing inside copyright blocks. * lex.ll (looks_like_copyright): Also allow newlines and carriage returns before the word "Copyright". * scripts/mk-doc.pl (gethelp): Also skip empty comment lines. * bp-table.cc, type.m: Adjust tests.
author John W. Eaton <jwe@octave.org>
date Wed, 08 Jan 2020 11:59:41 -0500
parents 1891570abac8
children 179ece36a2eb
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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 //
bd51beb6205e update formatting of copyright notices
John W. Eaton <jwe@octave.org>
parents: 27919
diff changeset
3 // Copyright (C) 1996-2020 The Octave Project Developers
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
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
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
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
28 #endif
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
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
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
32 #include "lo-ieee.h"
3248
68259f410026 [project @ 1999-07-13 03:34:54 by jwe]
jwe
parents: 3243
diff changeset
33 #include "lo-mappers.h"
4844
9f7ef92b50b0 [project @ 2004-04-02 17:26:53 by jwe]
jwe
parents: 4522
diff changeset
34 #include "dNDArray.h"
9f7ef92b50b0 [project @ 2004-04-02 17:26:53 by jwe]
jwe
parents: 4522
diff changeset
35 #include "CNDArray.h"
4153
6b96ce9f5743 [project @ 2002-11-06 20:38:49 by jwe]
jwe
parents: 4102
diff changeset
36 #include "quit.h"
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
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
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
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
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
42
4844
9f7ef92b50b0 [project @ 2004-04-02 17:26:53 by jwe]
jwe
parents: 4522
diff changeset
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
9f7ef92b50b0 [project @ 2004-04-02 17:26:53 by jwe]
jwe
parents: 4522
diff changeset
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
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
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
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
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
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
57 if (ismin)
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
58 retval(0) = array.min (dim);
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
59 else
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
60 retval(0) = array.max (dim);
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
61 }
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
62 else
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
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
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
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
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
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
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
94 if (ismin)
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
95 retval(0) = NDArray (array.min (dim));
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
96 else
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
97 retval(0) = NDArray (array.max (dim));
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
98 }
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
99 else
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
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
e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman]
dbateman
parents: 7017
diff changeset
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
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
247 octave_value_list retval (nargout > 1 ? 2 : 1);
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
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
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
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
e8d953d03f6a [project @ 2007-11-26 20:42:09 by dbateman]
dbateman
parents: 7017
diff changeset
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 {
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
272 Range 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>
20228
00cf2847355d Deprecate Array::nelem() and Range::nelem() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents: 20172
diff changeset
284 (range.inc () < 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>
20228
00cf2847355d Deprecate Array::nelem() and Range::nelem() in favour of ::numel().
Carnë Draug <carandraug@octave.org>
parents: 20172
diff changeset
291 (range.inc () >= 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
6eff66fb8a02 style fixes for comments
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
360 // FIXME: This is what should happen when boolNDArray has max()
6eff66fb8a02 style fixes for comments
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
361 // else if (xtyp == btyp_bool && ytyp == btyp_bool)
6eff66fb8a02 style fixes for comments
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
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
6eff66fb8a02 style fixes for comments
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
419 // FIXME: This is what should happen when boolNDArray has max()
6eff66fb8a02 style fixes for comments
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
420 // case btyp_bool:
6eff66fb8a02 style fixes for comments
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
421 // retval = do_minmax_bin_op<boolNDArray> (argx, argy, ismin);
6eff66fb8a02 style fixes for comments
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
422 // break;
6eff66fb8a02 style fixes for comments
John W. Eaton <jwe@octave.org>
parents: 20940
diff changeset
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
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
455 For two matrices (or a matrix and a scalar), return the pairwise minimum.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
456
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
457 Thus,
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
458
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
459 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
460 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
461 @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
462
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
463 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
464 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
465
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
466 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
467 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
468 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
469 @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
470 @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
471 @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
472
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
473 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
474 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
475 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
476
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
477 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
478 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
479 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
480
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
481 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
482 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
483 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
484 @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
485 @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
486 @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
487
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
488 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
489 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
490 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
491
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
492 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
493 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
494
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
495 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
496 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
497 [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
498 @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
499 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
500 @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
501 @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
502 @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
503 @end deftypefn */)
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
504 {
9790
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
505 return do_minmax_body (args, nargout, true);
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
506 }
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
507
7600
24abf5a702d9 Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents: 7505
diff changeset
508 /*
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
509 ## 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
510 %!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
511 %!assert (min ([1; -10; 5; -2]), -10)
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
512 %!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
513 ## Special routines for char arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
514 %!assert (min (["abc", "ABC"]), 65)
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
515 %!assert (min (["abc"; "CBA"]), [67 66 65])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
516 ## Special routines for logical arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
517 %!assert (min (logical ([])), logical ([]))
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
518 %!assert (min (logical ([0 0 1 0])), false)
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
519 %!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
520 ## Single values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
521 %!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
522 %!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
523 %!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
524 ## Integer values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
525 %!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
526 %!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
527 %!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
528 %!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
529 %!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
530 %!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
531 %!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
532 %!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
533 %!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
534 %!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
535 %!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
536 %!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
537 %!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
538 %!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
539 %!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
540 %!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
541 ## Sparse double values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
542 %!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
543 %!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
544 ## 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
545 %!test <51307>
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
546 %! 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
547
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
548 ## Test dimension argument
7600
24abf5a702d9 Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents: 7505
diff changeset
549 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14360
diff changeset
550 %! x = reshape (1:8, [2,2,2]);
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
551 %! 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
552 %! 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
553 %! [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
554 %! assert (ndims (y), 2);
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
555 %! 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
556 %! assert (ndims (i), 2);
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
557 %! assert (i, [1, 1; 1, 1]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
558
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
559 ## Test 2-output forms for various arg types
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
560 ## Special routines for char arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
561 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
562 %! [y, i] = min (["abc", "ABC"]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
563 %! assert (y, 65);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
564 %! assert (i, 4);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
565 ## Special routines for logical arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
566 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
567 %! x = logical ([0 0 1 0]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
568 %! [y, i] = min (x);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
569 %! assert (y, false);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
570 %! assert (i, 1);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
571 ## Special handling of ranges
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
572 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
573 %! rng = 1:2:10;
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
574 %! [y, i] = min (rng);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
575 %! assert (y, 1);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
576 %! assert (i, 1);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
577 %! rng = 10:-2:1;
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
578 %! [y, i] = min (rng);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
579 %! assert (y, 2);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
580 %! assert (i, 5);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
581
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
582 ## 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
583 ## Test generic double class
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
584 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
585 %! x = [1, 2, 3, 4]; y = fliplr (x);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
586 %! assert (min (x, y), [1 2 2 1]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
587 %! assert (min (x, 3), [1 2 3 3]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
588 %! assert (min (2, x), [1 2 2 2]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
589 %! 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
590 ## 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
591 ## 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
592 ## 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
593 %!test <51307>
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
594 %! x = [1, 2, 3, 4]; y = fliplr (x);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
595 %! assert (min (x, 2i), [2i 2i 3 4]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
596 ## Special routines for char arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
597 %!assert (min ("abc", "b"), [97 98 98])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
598 %!assert (min ("b", "cba"), [98 98 97])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
599 ## Special handling for logical arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
600 %!assert (min ([true false], false), [false false])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
601 %!assert (min (true, [true false]), [true false])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
602 ## Single values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
603 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
604 %! 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
605 %! 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
606 %! 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
607 %! 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
608 %! 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
609 ## Integer values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
610 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
611 %! 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
612 %! 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
613 %! 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
614 %! 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
615 %! 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
616 %! 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
617 %! 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
618 %! 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
619 %! 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
620 %! 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
621 %! 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
622 %! 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
623 %! 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
624 %! 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
625 %! 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
626 %! 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
627 %! 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
628 %! 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
629 %! 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
630 %! 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
631 %! 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
632 %! 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
633 %! 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
634 %! 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
635 %! 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
636 %! 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
637 %! 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
638 %! 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
639 %! 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
640 %! 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
641 %! 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
642 %! 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
643 ## Sparse double values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
644 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
645 %! 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
646 %! 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
647 %! 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
648 %! 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
649 %! 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
650
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14360
diff changeset
651 %!error min ()
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14360
diff changeset
652 %!error min (1, 2, 3, 4)
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
653 %!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
654 %!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
655 %!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
656 %!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
657 */
24abf5a702d9 Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents: 7505
diff changeset
658
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14501
diff changeset
659 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
660 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
661 @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
662 @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
663 @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
664 @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
665 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
666
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
667 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
668 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
669 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
670 dimension.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
671
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
672 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
673 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
674 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
675
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
676 For two matrices (or a matrix and a scalar), return the pairwise maximum.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
677
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
678 Thus,
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 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
681 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
682 @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
683
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
684 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
685 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
686
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
687 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
688 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
689 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
690 @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
691 @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
692 @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
693
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
694 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
695 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
696 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
697
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
698 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
699 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
700 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
701
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
702 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
703 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
704 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
705 @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
706 @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
707 @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
708
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
709 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
710 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
711 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
712
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
713 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
714 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
715
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
716 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
717 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
718 [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
719 @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
720 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
721 @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
722 @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
723 @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
724 @end deftypefn */)
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
725 {
9790
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
726 return do_minmax_body (args, nargout, false);
2928
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
727 }
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe]
jwe
parents:
diff changeset
728
11586
12df7854fa7c strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents: 11553
diff changeset
729 /*
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
730 ## 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
731 %!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
732 %!assert (max ([1; -10; 5; -2]), 5)
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
733 %!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
734 ## Special routines for char arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
735 %!assert (max (["abc", "ABC"]), 99)
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
736 %!assert (max (["abc"; "CBA"]), [97 98 99])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
737 ## Special routines for logical arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
738 %!assert (max (logical ([])), logical ([]))
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
739 %!assert (max (logical ([0 0 1 0])), true)
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
740 %!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
741 ## Single values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
742 %!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
743 %!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
744 %!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
745 ## Integer values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
746 %!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
747 %!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
748 %!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
749 %!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
750 %!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
751 %!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
752 %!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
753 %!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
754 %!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
755 %!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
756 %!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
757 %!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
758 %!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
759 %!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
760 %!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
761 %!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
762 ## Sparse double values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
763 %!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
764 %!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
765 %!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
766
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
767 ## Test dimension argument
7600
24abf5a702d9 Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents: 7505
diff changeset
768 %!test
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14360
diff changeset
769 %! 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
770 %! 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
771 %! 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
772 %! [y, i] = min (x, [], 3);
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
773 %! assert (ndims (y), 2);
7600
24abf5a702d9 Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents: 7505
diff changeset
774 %! assert (y, [1, 3; 2, 4]);
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
775 %! assert (ndims (i), 2);
7600
24abf5a702d9 Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents: 7505
diff changeset
776 %! assert (i, [1, 1; 1, 1]);
24abf5a702d9 Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents: 7505
diff changeset
777
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
778 ## Test 2-output forms for various arg types
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
779 ## Special routines for char arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
780 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
781 %! [y, i] = max (["abc", "ABC"]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
782 %! assert (y, 99);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
783 %! assert (i, 3);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
784 ## Special routines for logical arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
785 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
786 %! x = logical ([0 0 1 0]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
787 %! [y, i] = max (x);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
788 %! assert (y, true);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
789 %! assert (i, 3);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
790 ## Special handling of ranges
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
791 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
792 %! rng = 1:2:10;
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
793 %! [y, i] = max (rng);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
794 %! assert (y, 9);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
795 %! assert (i, 5);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
796 %! rng = 10:-2:1;
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
797 %! [y, i] = max (rng);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
798 %! assert (y, 10);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
799 %! assert (i, 1);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
800
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
801 ## 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
802 ## Test generic double class
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
803 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
804 %! x = [1, 2, 3, 4]; y = fliplr (x);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
805 %! assert (max (x, y), [4 3 3 4]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
806 %! assert (max (x, 3), [3 3 3 4]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
807 %! assert (max (2, x), [2 2 3 4]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
808 %! 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
809 ## 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
810 ## 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
811 ## 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
812 %!test <51307>
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
813 %! x = [1, 2, 3, 4]; y = fliplr (x);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
814 %! assert (max (x, 2i), [2i 2i 3 4]);
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
815 ## Special routines for char arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
816 %!assert (max ("abc", "b"), [98 98 99])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
817 %!assert (max ("b", "cba"), [99 98 98])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
818 ## Special handling for logical arrays
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
819 %!assert (max ([true false], false), [true false])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
820 %!assert (max (true, [false false]), [true true])
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
821 ## Single values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
822 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
823 %! 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
824 %! 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
825 %! 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
826 %! 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
827 %! 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
828 ## Integer values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
829 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
830 %! 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
831 %! 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
832 %! 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
833 %! 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
834 %! 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
835 %! 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
836 %! 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
837 %! 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
838 %! 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
839 %! 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
840 %! 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
841 %! 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
842 %! 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
843 %! 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
844 %! 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
845 %! 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
846 %! 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
847 %! 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
848 %! 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
849 %! 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
850 %! 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
851 %! 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
852 %! 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
853 %! 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
854 %! 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
855 %! 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
856 %! 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
857 %! 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
858 %! 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
859 %! 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
860 %! 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
861 %! 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
862 ## Sparse double values
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
863 %!test
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
864 %! 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
865 %! 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
866 %! 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
867 %! 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
868 %! 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
869
18076
42e6cdc76f4b max.cc: Add %!test for bug #40743.
Rik <rik@octave.org>
parents: 17787
diff changeset
870 ## 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
871 %!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
872 %!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
873 %! sparse (zeros (1,0)))
18076
42e6cdc76f4b max.cc: Add %!test for bug #40743.
Rik <rik@octave.org>
parents: 17787
diff changeset
874
14501
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14360
diff changeset
875 %!error max ()
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions.
Rik <octave@nomad.inbox5.com>
parents: 14360
diff changeset
876 %!error max (1, 2, 3, 4)
19412
78e424d31596 Overhaul max/min functions (fixes bug #43712).
Rik <rik@octave.org>
parents: 18227
diff changeset
877 %!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
878 %!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
879 %!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
880 %!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
881
7600
24abf5a702d9 Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents: 7505
diff changeset
882 */
24abf5a702d9 Chop trailing singletons in min/max functions
David Bateman <dbateman@free.fr>
parents: 7505
diff changeset
883
21139
538b57866b90 consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents: 21100
diff changeset
884 template <typename ArrayType>
9790
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
885 static octave_value_list
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
886 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
887 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
888 {
20892
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
889 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
890 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
891
20892
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
892 if (nargout <= 1)
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
893 {
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
894 if (ismin)
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
895 retval(0) = array.cummin (dim);
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
896 else
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
897 retval(0) = array.cummax (dim);
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
898 }
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
899 else
9790
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
900 {
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
901 retval.resize (2);
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
902 Array<octave_idx_type> idx;
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
903 if (ismin)
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
904 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
905 else
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
906 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
907
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
908 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
909 }
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
910
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
911 return retval;
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
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
914 static octave_value_list
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
915 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
916 int nargout, bool ismin)
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
917 {
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
918 int nargin = args.length ();
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
919
20802
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
920 if (nargin < 1 || nargin > 2)
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
921 print_usage ();
20743
b6408331bfa2 eliminate more uses of error_state
John W. Eaton <jwe@octave.org>
parents: 20555
diff changeset
922
23450
855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)".
Rik <rik@octave.org>
parents: 23220
diff changeset
923 const char *func = (ismin ? "cummin" : "cummax");
20892
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
924
20802
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
925 octave_value arg = args(0);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
926 int dim = -1;
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
927 if (nargin == 2)
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
928 {
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
929 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
930
20802
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
931 if (dim < 0)
20831
35241c4b696c eliminate return statements after calls to error
John W. Eaton <jwe@octave.org>
parents: 20802
diff changeset
932 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
933 }
20802
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
934
20892
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
935 octave_value_list retval;
c07bee629973 2015 Code Sprint: use ovl ().
Rik <rik@octave.org>
parents: 20853
diff changeset
936
20802
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
937 switch (arg.builtin_type ())
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
938 {
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
939 case btyp_double:
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
940 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
941 break;
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
942
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
943 case btyp_complex:
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
944 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
945 ismin);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
946 break;
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
947
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
948 case btyp_float:
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
949 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
950 break;
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
951
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
952 case btyp_float_complex:
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
953 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
954 ismin);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
955 break;
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
956
22407
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22323
diff changeset
957 #define MAKE_INT_BRANCH(X) \
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22323
diff changeset
958 case btyp_ ## X: \
34ce5be04942 maint: Style check C++ code in libinterp/.
Rik <rik@octave.org>
parents: 22323
diff changeset
959 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
960 break;
20802
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
961
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
962 MAKE_INT_BRANCH (int8);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
963 MAKE_INT_BRANCH (int16);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
964 MAKE_INT_BRANCH (int32);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
965 MAKE_INT_BRANCH (int64);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
966 MAKE_INT_BRANCH (uint8);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
967 MAKE_INT_BRANCH (uint16);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
968 MAKE_INT_BRANCH (uint32);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
969 MAKE_INT_BRANCH (uint64);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
970
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
971 #undef MAKE_INT_BRANCH
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 case btyp_bool:
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 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
976 ismin);
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
977 if (retval.length () > 0)
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
978 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
979 }
8bb38ba1bad6 eliminate return statements after calls to print_usage
John W. Eaton <jwe@octave.org>
parents: 20743
diff changeset
980 break;
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 default:
21100
e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme.
Rik <rik@octave.org>
parents: 20946
diff changeset
983 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
984 }
9790
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
985
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
986 return retval;
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
987 }
8777
724c0f46d9d4 implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents: 7919
diff changeset
988
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14501
diff changeset
989 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
990 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
991 @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
992 @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
993 @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
994 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
995
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
996 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
997 example:
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
998
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 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1001 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
1002 @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
1003 @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
1004 @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
1005
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1006 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
1007 returned.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1008
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1009 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1010 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1011 [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
1012 @result{}
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 = 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
1014 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
1015 @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
1016 @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
1017
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1018 @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
1019 @end deftypefn */)
8777
724c0f46d9d4 implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents: 7919
diff changeset
1020 {
9790
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
1021 return do_cumminmax_body (args, nargout, true);
8777
724c0f46d9d4 implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents: 7919
diff changeset
1022 }
724c0f46d9d4 implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents: 7919
diff changeset
1023
17403
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1024 /*
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1025 %!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
1026 %!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
1027 %!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
1028 %!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
1029
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1030 %!test
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1031 %! x = reshape (1:8, [2,2,2]);
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1032 %! 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
1033 %! 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
1034 %! [w, iw] = cummin (x, 3);
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1035 %! assert (ndims (w), 3);
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1036 %! 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
1037 %! assert (ndims (iw), 3);
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1038 %! assert (iw, ones (2,2,2));
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1039
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1040 %!error cummin ()
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1041 %!error cummin (1, 2, 3)
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1042 */
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1043
15039
e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory
Rik <rik@octave.org>
parents: 14501
diff changeset
1044 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
1045 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
1046 @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
1047 @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
1048 @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
1049 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
1050
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1051 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
1052 example:
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1053
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 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1056 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
1057 @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
1058 @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
1059 @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
1060
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1061 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
1062 returned.
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1063
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1064 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1065 @group
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1066 [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
1067 @result{}
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 = 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
1069 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
1070 @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
1071 @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
1072
112b20240c87 move docstrings in C++ files out of C strings and into comments
John W. Eaton <jwe@octave.org>
parents: 21724
diff changeset
1073 @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
1074 @end deftypefn */)
8777
724c0f46d9d4 implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents: 7919
diff changeset
1075 {
9790
a5035bc7fbfb rewrite dispatch part & slightly improve min,max,cummin,cummax
Jaroslav Hajek <highegg@gmail.com>
parents: 9732
diff changeset
1076 return do_cumminmax_body (args, nargout, false);
8777
724c0f46d9d4 implement cummin/cummax functions
Jaroslav Hajek <highegg@gmail.com>
parents: 7919
diff changeset
1077 }
17403
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1078
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1079 /*
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1080 %!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
1081 %!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
1082 %!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
1083 %!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
1084
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1085 %!test
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1086 %! x = reshape (8:-1:1, [2,2,2]);
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1087 %! 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
1088 %! 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
1089 %! [w, iw] = cummax (x, 3);
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1090 %! assert (ndims (w), 3);
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1091 %! 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
1092 %! assert (ndims (iw), 3);
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1093 %! assert (iw, ones (2,2,2));
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1094
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1095 %!error cummax ()
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1096 %!error cummax (1, 2, 3)
db8b90a56298 doc: Reword docstrings for cummax, cummin.
Rik <rik@octave.org>
parents: 16370
diff changeset
1097 */