Mercurial > octave-nkf
annotate src/data.cc @ 9758:09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Use double spaces after a period at start of new sentence
Do not use @iftex blocks where @tex block is sufficient
| author | Rik <rdrider0-list@yahoo.com> |
|---|---|
| date | Fri, 23 Oct 2009 09:28:14 -0700 |
| parents | fa63a34827e0 |
| children | 7fc1c8c47b86 |
| rev | line source |
|---|---|
| 523 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, |
|
9428
b317debeb828
data.cc (Fones, Fzeros, Ftrue, Ffalse): update docstring
John W. Eaton <jwe@octave.org>
parents:
9351
diff
changeset
|
4 2003, 2004, 2005, 2006, 2007, 2008, 2009 John W. Eaton |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
5 Copyright (C) 2009 Jaroslav Hajek |
|
9513
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6 Copyright (C) 2009 VZLU Prague |
| 523 | 7 |
| 8 This file is part of Octave. | |
| 9 | |
| 10 Octave is free software; you can redistribute it and/or modify it | |
| 11 under the terms of the GNU General Public License as published by the | |
| 7016 | 12 Free Software Foundation; either version 3 of the License, or (at your |
| 13 option) any later version. | |
| 523 | 14 |
| 15 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 18 for more details. | |
| 19 | |
| 20 You should have received a copy of the GNU General Public License | |
| 7016 | 21 along with Octave; see the file COPYING. If not, see |
| 22 <http://www.gnu.org/licenses/>. | |
| 523 | 23 |
| 24 */ | |
| 25 | |
| 26 #ifdef HAVE_CONFIG_H | |
| 1192 | 27 #include <config.h> |
| 523 | 28 #endif |
| 29 | |
| 7078 | 30 #include "systime.h" |
| 31 | |
| 32 #ifdef HAVE_SYS_TYPES_H | |
| 33 #include <sys/types.h> | |
| 34 #endif | |
| 35 | |
| 36 #ifdef HAVE_SYS_RESOURCE_H | |
| 37 #include <sys/resource.h> | |
| 38 #endif | |
| 39 | |
| 2184 | 40 #include <cfloat> |
| 41 | |
| 1728 | 42 #include <string> |
| 43 | |
| 2184 | 44 #include "lo-ieee.h" |
| 7231 | 45 #include "lo-math.h" |
| 1755 | 46 #include "str-vec.h" |
| 4153 | 47 #include "quit.h" |
|
9658
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
48 #include "mx-base.h" |
| 1755 | 49 |
| 6953 | 50 #include "Cell.h" |
| 1352 | 51 #include "defun.h" |
| 52 #include "error.h" | |
| 53 #include "gripes.h" | |
| 6953 | 54 #include "oct-map.h" |
| 55 #include "oct-obj.h" | |
| 2366 | 56 #include "ov.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
57 #include "ov-float.h" |
| 5476 | 58 #include "ov-complex.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
59 #include "ov-flt-complex.h" |
| 5476 | 60 #include "ov-cx-mat.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
61 #include "ov-flt-cx-mat.h" |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
62 #include "ov-cx-sparse.h" |
| 6953 | 63 #include "parse.h" |
| 64 #include "pt-mat.h" | |
| 523 | 65 #include "utils.h" |
| 6953 | 66 #include "variables.h" |
| 7045 | 67 #include "pager.h" |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
68 #include "xnorm.h" |
| 523 | 69 |
|
7914
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
70 #if ! defined (HAVE_HYPOTF) && defined (HAVE__HYPOTF) |
|
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
71 #define hypotf _hypotf |
|
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
72 #define HAVE_HYPOTF 1 |
|
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
73 #endif |
|
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
74 |
| 4015 | 75 #define ANY_ALL(FCN) \ |
| 76 \ | |
| 4233 | 77 octave_value retval; \ |
| 4015 | 78 \ |
| 79 int nargin = args.length (); \ | |
| 80 \ | |
| 4021 | 81 if (nargin == 1 || nargin == 2) \ |
| 4015 | 82 { \ |
| 4021 | 83 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \ |
| 84 \ | |
| 85 if (! error_state) \ | |
| 86 { \ | |
| 4556 | 87 if (dim >= -1) \ |
| 4015 | 88 retval = args(0).FCN (dim); \ |
| 4021 | 89 else \ |
| 90 error (#FCN ": invalid dimension argument = %d", dim + 1); \ | |
| 91 } \ | |
| 4015 | 92 else \ |
| 4021 | 93 error (#FCN ": expecting dimension argument to be an integer"); \ |
| 4015 | 94 } \ |
| 4021 | 95 else \ |
| 5823 | 96 print_usage (); \ |
| 4015 | 97 \ |
| 98 return retval | |
| 99 | |
| 1957 | 100 DEFUN (all, args, , |
| 3369 | 101 "-*- texinfo -*-\n\ |
| 4015 | 102 @deftypefn {Built-in Function} {} all (@var{x}, @var{dim})\n\ |
| 3369 | 103 The function @code{all} behaves like the function @code{any}, except\n\ |
| 104 that it returns true only if all the elements of a vector, or all the\n\ | |
| 4015 | 105 elements along dimension @var{dim} of a matrix, are nonzero.\n\ |
| 3369 | 106 @end deftypefn") |
| 523 | 107 { |
| 4015 | 108 ANY_ALL (all); |
| 523 | 109 } |
| 110 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
111 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
112 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
113 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
114 %! x = ones (3); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
115 %! x(1,1) = 0; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
116 %! assert((all (all (rand (3) + 1) == [1, 1, 1]) == 1 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
117 %! && all (all (x) == [0, 1, 1]) == 1 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
118 %! && all (x, 1) == [0, 1, 1] |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
119 %! && all (x, 2) == [0; 1; 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
120 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
121 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
122 %! x = ones (3, 'single'); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
123 %! x(1,1) = 0; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
124 %! assert((all (all (single (rand (3) + 1)) == [1, 1, 1]) == 1 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
125 %! && all (all (x) == [0, 1, 1]) == 1 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
126 %! && all (x, 1) == [0, 1, 1] |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
127 %! && all (x, 2) == [0; 1; 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
128 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
129 %!error <Invalid call to all.*> all (); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
130 %!error <Invalid call to all.*> all (1, 2, 3); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
131 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
132 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
133 |
| 1957 | 134 DEFUN (any, args, , |
| 3369 | 135 "-*- texinfo -*-\n\ |
| 4015 | 136 @deftypefn {Built-in Function} {} any (@var{x}, @var{dim})\n\ |
| 3369 | 137 For a vector argument, return 1 if any element of the vector is\n\ |
| 138 nonzero.\n\ | |
| 139 \n\ | |
| 140 For a matrix argument, return a row vector of ones and\n\ | |
| 141 zeros with each element indicating whether any of the elements of the\n\ | |
| 142 corresponding column of the matrix are nonzero. For example,\n\ | |
| 143 \n\ | |
| 144 @example\n\ | |
| 145 @group\n\ | |
| 146 any (eye (2, 4))\n\ | |
| 147 @result{} [ 1, 1, 0, 0 ]\n\ | |
| 148 @end group\n\ | |
| 149 @end example\n\ | |
| 150 \n\ | |
| 4015 | 151 If the optional argument @var{dim} is supplied, work along dimension\n\ |
| 152 @var{dim}. For example,\n\ | |
| 3369 | 153 \n\ |
| 154 @example\n\ | |
| 4015 | 155 @group\n\ |
| 156 any (eye (2, 4), 2)\n\ | |
| 157 @result{} [ 1; 1 ]\n\ | |
| 158 @end group\n\ | |
| 3369 | 159 @end example\n\ |
| 160 @end deftypefn") | |
| 523 | 161 { |
| 4015 | 162 ANY_ALL (any); |
| 523 | 163 } |
| 164 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
165 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
166 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
167 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
168 %! x = zeros (3); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
169 %! x(3,3) = 1; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
170 %! assert((all (any (x) == [0, 0, 1]) == 1 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
171 %! && all (any (ones (3)) == [1, 1, 1]) == 1 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
172 %! && any (x, 1) == [0, 0, 1] |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
173 %! && any (x, 2) == [0; 0; 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
174 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
175 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
176 %! x = zeros (3,'single'); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
177 %! x(3,3) = 1; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
178 %! assert((all (any (x) == [0, 0, 1]) == 1 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
179 %! && all (any (ones (3, 'single')) == [1, 1, 1]) == 1 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
180 %! && any (x, 1) == [0, 0, 1] |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
181 %! && any (x, 2) == [0; 0; 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
182 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
183 %!error <Invalid call to any.*> any (); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
184 %!error <Invalid call to any.*> any (1, 2, 3); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
185 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
186 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
187 |
| 649 | 188 // These mapping functions may also be useful in other places, eh? |
| 189 | |
| 190 typedef double (*d_dd_fcn) (double, double); | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
191 typedef float (*f_ff_fcn) (float, float); |
| 649 | 192 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
193 static NDArray |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
194 map_d_m (d_dd_fcn f, double x, const NDArray& y) |
| 649 | 195 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
196 NDArray retval (y.dims ()); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
197 double *r_data = retval.fortran_vec (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
198 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
199 const double *y_data = y.data (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
200 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
201 octave_idx_type nel = y.numel (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
202 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
203 for (octave_idx_type i = 0; i < nel; i++) |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
204 { |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
205 OCTAVE_QUIT; |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
206 r_data[i] = f (x, y_data[i]); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
207 } |
| 649 | 208 |
| 209 return retval; | |
| 210 } | |
| 211 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
212 static FloatNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
213 map_f_fm (f_ff_fcn f, float x, const FloatNDArray& y) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
214 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
215 FloatNDArray retval (y.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
216 float *r_data = retval.fortran_vec (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
217 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
218 const float *y_data = y.data (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
219 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
220 octave_idx_type nel = y.numel (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
221 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
222 for (octave_idx_type i = 0; i < nel; i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
223 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
224 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
225 r_data[i] = f (x, y_data[i]); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
226 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
227 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
228 return retval; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
229 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
230 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
231 static NDArray |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
232 map_m_d (d_dd_fcn f, const NDArray& x, double y) |
| 649 | 233 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
234 NDArray retval (x.dims ()); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
235 double *r_data = retval.fortran_vec (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
236 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
237 const double *x_data = x.data (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
238 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
239 octave_idx_type nel = x.numel (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
240 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
241 for (octave_idx_type i = 0; i < nel; i++) |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
242 { |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
243 OCTAVE_QUIT; |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
244 r_data[i] = f (x_data[i], y); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
245 } |
| 649 | 246 |
| 247 return retval; | |
| 248 } | |
| 249 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
250 static FloatNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
251 map_fm_f (f_ff_fcn f, const FloatNDArray& x, float y) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
252 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
253 FloatNDArray retval (x.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
254 float *r_data = retval.fortran_vec (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
255 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
256 const float *x_data = x.data (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
257 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
258 octave_idx_type nel = x.numel (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
259 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
260 for (octave_idx_type i = 0; i < nel; i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
261 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
262 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
263 r_data[i] = f (x_data[i], y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
264 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
265 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
266 return retval; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
267 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
268 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
269 static NDArray |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
270 map_m_m (d_dd_fcn f, const NDArray& x, const NDArray& y) |
| 649 | 271 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
272 assert (x.dims () == y.dims ()); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
273 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
274 NDArray retval (x.dims ()); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
275 double *r_data = retval.fortran_vec (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
276 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
277 const double *x_data = x.data (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
278 const double *y_data = y.data (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
279 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
280 octave_idx_type nel = x.numel (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
281 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
282 for (octave_idx_type i = 0; i < nel; i++) |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
283 { |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
284 OCTAVE_QUIT; |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
285 r_data[i] = f (x_data[i], y_data[i]); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
286 } |
| 649 | 287 |
| 288 return retval; | |
| 289 } | |
| 290 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
291 static FloatNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
292 map_fm_fm (f_ff_fcn f, const FloatNDArray& x, const FloatNDArray& y) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
293 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
294 assert (x.dims () == y.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
295 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
296 FloatNDArray retval (x.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
297 float *r_data = retval.fortran_vec (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
298 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
299 const float *x_data = x.data (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
300 const float *y_data = y.data (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
301 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
302 octave_idx_type nel = x.numel (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
303 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
304 for (octave_idx_type i = 0; i < nel; i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
305 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
306 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
307 r_data[i] = f (x_data[i], y_data[i]); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
308 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
309 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
310 return retval; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
311 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
312 |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
313 static SparseMatrix |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
314 map_d_s (d_dd_fcn f, double x, const SparseMatrix& y) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
315 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
316 octave_idx_type nr = y.rows (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
317 octave_idx_type nc = y.columns (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
318 SparseMatrix retval; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
319 double f_zero = f (x, 0.); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
320 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
321 if (f_zero != 0) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
322 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
323 retval = SparseMatrix (nr, nc, f_zero); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
324 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
325 for (octave_idx_type j = 0; j < nc; j++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
326 for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
327 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
328 OCTAVE_QUIT; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
329 retval.data (y.ridx(i) + j * nr) = f (x, y.data (i)); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
330 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
331 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
332 retval.maybe_compress (true); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
333 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
334 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
335 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
336 octave_idx_type nz = y.nnz (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
337 retval = SparseMatrix (nr, nc, nz); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
338 octave_idx_type ii = 0; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
339 retval.cidx (ii) = 0; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
340 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
341 for (octave_idx_type j = 0; j < nc; j++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
342 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
343 for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
344 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
345 OCTAVE_QUIT; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
346 double val = f (x, y.data (i)); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
347 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
348 if (val != 0.0) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
349 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
350 retval.data (ii) = val; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
351 retval.ridx (ii++) = y.ridx (i); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
352 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
353 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
354 retval.cidx (j + 1) = ii; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
355 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
356 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
357 retval.maybe_compress (false); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
358 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
359 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
360 return retval; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
361 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
362 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
363 static SparseMatrix |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
364 map_s_d (d_dd_fcn f, const SparseMatrix& x, double y) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
365 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
366 octave_idx_type nr = x.rows (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
367 octave_idx_type nc = x.columns (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
368 SparseMatrix retval; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
369 double f_zero = f (0., y); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
370 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
371 if (f_zero != 0) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
372 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
373 retval = SparseMatrix (nr, nc, f_zero); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
374 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
375 for (octave_idx_type j = 0; j < nc; j++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
376 for (octave_idx_type i = x.cidx (j); i < x.cidx (j+1); i++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
377 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
378 OCTAVE_QUIT; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
379 retval.data (x.ridx(i) + j * nr) = f (x.data (i), y); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
380 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
381 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
382 retval.maybe_compress (true); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
383 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
384 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
385 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
386 octave_idx_type nz = x.nnz (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
387 retval = SparseMatrix (nr, nc, nz); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
388 octave_idx_type ii = 0; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
389 retval.cidx (ii) = 0; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
390 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
391 for (octave_idx_type j = 0; j < nc; j++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
392 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
393 for (octave_idx_type i = x.cidx (j); i < x.cidx (j+1); i++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
394 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
395 OCTAVE_QUIT; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
396 double val = f (x.data (i), y); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
397 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
398 if (val != 0.0) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
399 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
400 retval.data (ii) = val; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
401 retval.ridx (ii++) = x.ridx (i); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
402 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
403 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
404 retval.cidx (j + 1) = ii; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
405 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
406 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
407 retval.maybe_compress (false); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
408 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
409 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
410 return retval; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
411 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
412 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
413 static SparseMatrix |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
414 map_s_s (d_dd_fcn f, const SparseMatrix& x, const SparseMatrix& y) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
415 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
416 octave_idx_type nr = x.rows (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
417 octave_idx_type nc = x.columns (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
418 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
419 octave_idx_type y_nr = y.rows (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
420 octave_idx_type y_nc = y.columns (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
421 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
422 assert (nr == y_nr && nc == y_nc); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
423 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
424 SparseMatrix retval; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
425 double f_zero = f (0., 0.); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
426 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
427 if (f_zero != 0) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
428 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
429 retval = SparseMatrix (nr, nc, f_zero); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
430 octave_idx_type k1 = 0, k2 = 0; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
431 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
432 for (octave_idx_type j = 0; j < nc; j++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
433 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
434 while (k1 < x.cidx(j+1) && k2 < y.cidx(j+1)) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
435 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
436 OCTAVE_QUIT; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
437 if (k1 >= x.cidx(j+1)) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
438 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
439 retval.data (y.ridx(k2) + j * nr) = f (0.0, y.data (k2)); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
440 k2++; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
441 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
442 else if (k2 >= y.cidx(j+1)) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
443 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
444 retval.data (x.ridx(k1) + j * nr) = f (x.data (k1), 0.0); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
445 k1++; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
446 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
447 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
448 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
449 octave_idx_type rx = x.ridx(k1); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
450 octave_idx_type ry = y.ridx(k2); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
451 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
452 if (rx < ry) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
453 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
454 retval.data (rx + j * nr) = f (x.data (k1), 0.0); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
455 k1++; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
456 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
457 else if (rx > ry) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
458 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
459 retval.data (ry + j * nr) = f (0.0, y.data (k2)); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
460 k2++; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
461 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
462 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
463 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
464 retval.data (ry + j * nr) = f (x.data (k1), y.data (k2)); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
465 k1++; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
466 k2++; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
467 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
468 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
469 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
470 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
471 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
472 retval.maybe_compress (true); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
473 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
474 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
475 { |
| 7631 | 476 octave_idx_type nz = x.nnz () + y.nnz (); |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
477 retval = SparseMatrix (nr, nc, nz); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
478 octave_idx_type ii = 0; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
479 retval.cidx (ii) = 0; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
480 octave_idx_type k1 = 0, k2 = 0; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
481 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
482 for (octave_idx_type j = 0; j < nc; j++) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
483 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
484 while (k1 < x.cidx(j+1) && k2 < y.cidx(j+1)) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
485 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
486 OCTAVE_QUIT; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
487 double val; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
488 octave_idx_type r; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
489 if (k1 >= x.cidx(j+1)) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
490 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
491 r = y.ridx (k2); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
492 val = f (0.0, y.data (k2++)); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
493 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
494 else if (k2 >= y.cidx(j+1)) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
495 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
496 r = x.ridx (k1); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
497 val = f (x.data (k1++), 0.0); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
498 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
499 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
500 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
501 octave_idx_type rx = x.ridx(k1); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
502 octave_idx_type ry = y.ridx(k2); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
503 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
504 if (rx < ry) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
505 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
506 r = x.ridx (k1); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
507 val = f (x.data (k1++), 0.0); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
508 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
509 else if (rx > ry) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
510 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
511 r = y.ridx (k2); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
512 val = f (0.0, y.data (k2++)); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
513 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
514 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
515 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
516 r = y.ridx (k2); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
517 val = f (x.data (k1++), y.data (k2++)); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
518 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
519 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
520 if (val != 0.0) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
521 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
522 retval.data (ii) = val; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
523 retval.ridx (ii++) = r; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
524 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
525 } |
| 7631 | 526 retval.cidx (j + 1) = ii; |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
527 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
528 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
529 retval.maybe_compress (false); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
530 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
531 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
532 return retval; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
533 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
534 |
| 1957 | 535 DEFUN (atan2, args, , |
| 3428 | 536 "-*- texinfo -*-\n\ |
| 537 @deftypefn {Mapping Function} {} atan2 (@var{y}, @var{x})\n\ | |
| 538 Compute atan (@var{y} / @var{x}) for corresponding elements of @var{y}\n\ | |
|
9155
ad20b967e1c9
Update section 17.3 (Trigonometry) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9142
diff
changeset
|
539 and @var{x}. Signal an error if @var{y} and @var{x} do not match in size\n\ |
|
ad20b967e1c9
Update section 17.3 (Trigonometry) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9142
diff
changeset
|
540 and orientation.\n\ |
| 3439 | 541 @end deftypefn") |
| 649 | 542 { |
| 4233 | 543 octave_value retval; |
| 649 | 544 |
| 712 | 545 int nargin = args.length (); |
| 546 | |
| 547 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ()) | |
| 649 | 548 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
549 if (args(0).is_integer_type () || args(1).is_integer_type ()) |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
550 error ("atan2: not defined for integer types"); |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
551 else |
| 649 | 552 { |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
553 octave_value arg_y = args(0); |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
554 octave_value arg_x = args(1); |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
555 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
556 dim_vector y_dims = arg_y.dims (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
557 dim_vector x_dims = arg_x.dims (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
558 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
559 bool y_is_scalar = y_dims.all_ones (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
560 bool x_is_scalar = x_dims.all_ones (); |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
561 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
562 bool is_float = arg_y.is_single_type () || arg_x.is_single_type (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
563 |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
564 if (y_is_scalar && x_is_scalar) |
| 649 | 565 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
566 if (is_float) |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
567 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
568 float y = arg_y.float_value (); |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
569 |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
570 if (! error_state) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
571 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
572 float x = arg_x.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
573 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
574 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
575 retval = atan2f (y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
576 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
577 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
578 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
579 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
580 double y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
581 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
582 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
583 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
584 double x = arg_x.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
585 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
586 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
587 retval = atan2 (y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
588 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
589 } |
| 649 | 590 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
591 else if (y_is_scalar) |
| 649 | 592 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
593 if (is_float) |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
594 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
595 float y = arg_y.float_value (); |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
596 |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
597 if (! error_state) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
598 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
599 // Even if x is sparse return a full matrix here |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
600 FloatNDArray x = arg_x.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
601 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
602 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
603 retval = map_f_fm (atan2f, y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
604 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
605 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
606 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
607 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
608 double y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
609 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
610 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
611 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
612 // Even if x is sparse return a full matrix here |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
613 NDArray x = arg_x.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
614 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
615 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
616 retval = map_d_m (atan2, y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
617 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
618 } |
| 649 | 619 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
620 else if (x_is_scalar) |
| 649 | 621 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
622 if (arg_y.is_sparse_type ()) |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
623 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
624 SparseMatrix y = arg_y.sparse_matrix_value (); |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
625 |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
626 if (! error_state) |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
627 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
628 double x = arg_x.double_value (); |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
629 |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
630 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
631 retval = map_s_d (atan2, y, x); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
632 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
633 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
634 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
635 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
636 FloatNDArray y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
637 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
638 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
639 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
640 float x = arg_x.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
641 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
642 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
643 retval = map_fm_f (atan2f, y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
644 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
645 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
646 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
647 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
648 NDArray y = arg_y.array_value (); |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
649 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
650 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
651 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
652 double x = arg_x.double_value (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
653 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
654 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
655 retval = map_m_d (atan2, y, x); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
656 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
657 } |
| 649 | 658 } |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
659 else if (y_dims == x_dims) |
| 649 | 660 { |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
661 // Even if y is sparse return a full matrix here |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
662 if (arg_x.is_sparse_type ()) |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
663 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
664 SparseMatrix y = arg_y.sparse_matrix_value (); |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
665 |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
666 if (! error_state) |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
667 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
668 SparseMatrix x = arg_x.sparse_matrix_value (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
669 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
670 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
671 retval = map_s_s (atan2, y, x); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
672 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
673 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
674 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
675 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
676 FloatNDArray y = arg_y.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
677 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
678 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
679 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
680 FloatNDArray x = arg_x.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
681 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
682 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
683 retval = map_fm_fm (atan2f, y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
684 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
685 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
686 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
687 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
688 NDArray y = arg_y.array_value (); |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
689 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
690 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
691 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
692 NDArray x = arg_x.array_value (); |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
693 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
694 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
695 retval = map_m_m (atan2, y, x); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
696 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
697 } |
| 649 | 698 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
699 else |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
700 error ("atan2: nonconformant matrices"); |
| 649 | 701 } |
| 702 } | |
| 712 | 703 else |
| 5823 | 704 print_usage (); |
| 649 | 705 |
| 706 return retval; | |
| 707 } | |
| 708 | |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
709 /* |
| 7741 | 710 %!assert (size (atan2 (zeros (0, 2), zeros (0, 2))), [0, 2]) |
| 711 %!assert (size (atan2 (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4]) | |
| 712 %!assert (size (atan2 (rand (2, 3, 4), 1)), [2, 3, 4]) | |
| 713 %!assert (size (atan2 (1, rand (2, 3, 4))), [2, 3, 4]) | |
| 714 %!assert (size (atan2 (1, 2)), [1, 1]) | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
715 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
716 %!test |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
717 %! rt2 = sqrt (2); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
718 %! rt3 = sqrt (3); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
719 %! v = [0, pi/6, pi/4, pi/3, -pi/3, -pi/4, -pi/6, 0]; |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
720 %! y = [0, rt3, 1, rt3, -rt3, -1, -rt3, 0]; |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
721 %! x = [1, 3, 1, 1, 1, 1, 3, 1]; |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
722 %! assert(atan2 (y, x), v, sqrt (eps)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
723 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
724 %!test |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
725 %! rt2 = sqrt (2); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
726 %! rt3 = sqrt (3); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
727 %! v = single([0, pi/6, pi/4, pi/3, -pi/3, -pi/4, -pi/6, 0]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
728 %! y = single([0, rt3, 1, rt3, -rt3, -1, -rt3, 0]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
729 %! x = single([1, 3, 1, 1, 1, 1, 3, 1]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
730 %! assert(atan2 (y, x), v, sqrt (eps('single'))); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
731 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
732 %!error <Invalid call to atan2.*> atan2 (); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
733 %!error <Invalid call to atan2.*> atan2 (1, 2, 3); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
734 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
735 */ |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
736 |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
737 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
738 |
| 7631 | 739 DEFUN (hypot, args, , |
| 740 "-*- texinfo -*-\n\ | |
|
9141
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
741 @deftypefn {Built-in Function} {} hypot (@var{x}, @var{y})\n\ |
|
9165
8c71a86c4bf4
Update section 17.5 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9163
diff
changeset
|
742 Compute the element-by-element square root of the sum of the squares of\n\ |
|
8c71a86c4bf4
Update section 17.5 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9163
diff
changeset
|
743 @var{x} and @var{y}. This is equivalent to\n\ |
|
8c71a86c4bf4
Update section 17.5 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9163
diff
changeset
|
744 @code{sqrt (@var{x}.^2 + @var{y}.^2)}, but calculated in a manner that\n\ |
|
8c71a86c4bf4
Update section 17.5 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9163
diff
changeset
|
745 avoids overflows for large values of @var{x} or @var{y}.\n\ |
| 7631 | 746 @end deftypefn") |
| 747 { | |
| 748 octave_value retval; | |
| 749 | |
| 750 int nargin = args.length (); | |
| 751 | |
| 752 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ()) | |
| 753 { | |
| 754 if (args(0).is_integer_type () || args(1).is_integer_type ()) | |
| 755 error ("hypot: not defined for integer types"); | |
| 756 else | |
| 757 { | |
| 758 octave_value arg_x = args(0); | |
| 759 octave_value arg_y = args(1); | |
| 760 | |
| 761 dim_vector x_dims = arg_x.dims (); | |
| 762 dim_vector y_dims = arg_y.dims (); | |
| 763 | |
| 764 bool x_is_scalar = x_dims.all_ones (); | |
| 765 bool y_is_scalar = y_dims.all_ones (); | |
| 766 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
767 bool is_float = arg_y.is_single_type () || arg_x.is_single_type (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
768 |
| 7631 | 769 if (y_is_scalar && x_is_scalar) |
| 770 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
771 if (is_float) |
| 7631 | 772 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
773 float x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
774 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
775 x = abs (arg_x.float_complex_value ()); |
| 7631 | 776 else |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
777 x = arg_x.float_value (); |
| 7631 | 778 |
| 779 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
780 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
781 float y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
782 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
783 y = abs (arg_y.float_complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
784 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
785 y = arg_y.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
786 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
787 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
788 retval = hypotf (x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
789 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
790 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
791 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
792 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
793 double x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
794 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
795 x = abs (arg_x.complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
796 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
797 x = arg_x.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
798 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
799 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
800 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
801 double y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
802 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
803 y = abs (arg_y.complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
804 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
805 y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
806 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
807 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
808 retval = hypot (x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
809 } |
| 7631 | 810 } |
| 811 } | |
| 812 else if (y_is_scalar) | |
| 813 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
814 if (is_float) |
| 7631 | 815 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
816 FloatNDArray x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
817 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
818 x = arg_x.float_complex_array_value ().abs (); |
| 7631 | 819 else |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
820 x = arg_x.float_array_value (); |
| 7631 | 821 |
| 822 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
823 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
824 float y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
825 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
826 y = abs (arg_y.float_complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
827 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
828 y = arg_y.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
829 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
830 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
831 retval = map_fm_f (hypotf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
832 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
833 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
834 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
835 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
836 NDArray x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
837 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
838 x = arg_x.complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
839 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
840 x = arg_x.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
841 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
842 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
843 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
844 double y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
845 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
846 y = abs (arg_y.complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
847 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
848 y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
849 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
850 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
851 retval = map_m_d (hypot, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
852 } |
| 7631 | 853 } |
| 854 } | |
| 855 else if (x_is_scalar) | |
| 856 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
857 if (is_float) |
| 7631 | 858 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
859 float x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
860 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
861 x = abs (arg_x.float_complex_value ()); |
| 7631 | 862 else |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
863 x = arg_x.float_value (); |
| 7631 | 864 |
| 865 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
866 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
867 FloatNDArray y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
868 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
869 y = arg_y.float_complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
870 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
871 y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
872 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
873 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
874 retval = map_f_fm (hypotf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
875 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
876 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
877 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
878 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
879 double x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
880 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
881 x = abs (arg_x.complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
882 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
883 x = arg_x.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
884 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
885 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
886 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
887 NDArray y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
888 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
889 y = arg_y.complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
890 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
891 y = arg_y.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
892 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
893 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
894 retval = map_d_m (hypot, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
895 } |
| 7631 | 896 } |
| 897 } | |
| 898 else if (y_dims == x_dims) | |
| 899 { | |
| 900 if (arg_x.is_sparse_type () && arg_y.is_sparse_type ()) | |
| 901 { | |
| 902 SparseMatrix x; | |
| 903 if (arg_x.is_complex_type ()) | |
| 904 x = arg_x.sparse_complex_matrix_value ().abs (); | |
| 905 else | |
| 906 x = arg_x.sparse_matrix_value (); | |
| 907 | |
| 908 if (! error_state) | |
| 909 { | |
| 910 SparseMatrix y; | |
| 911 if (arg_y.is_complex_type ()) | |
| 912 y = arg_y.sparse_complex_matrix_value ().abs (); | |
| 913 else | |
| 914 y = arg_y.sparse_matrix_value (); | |
| 915 | |
| 916 if (! error_state) | |
| 917 retval = map_s_s (hypot, x, y); | |
| 918 } | |
| 919 } | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
920 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
921 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
922 FloatNDArray x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
923 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
924 x = arg_x.float_complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
925 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
926 x = arg_x.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
927 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
928 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
929 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
930 FloatNDArray y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
931 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
932 y = arg_y.float_complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
933 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
934 y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
935 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
936 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
937 retval = map_fm_fm (hypotf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
938 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
939 } |
| 7631 | 940 else |
| 941 { | |
| 942 NDArray x; | |
| 943 if (arg_x.is_complex_type ()) | |
| 944 x = arg_x.complex_array_value ().abs (); | |
| 945 else | |
| 946 x = arg_x.array_value (); | |
| 947 | |
| 948 if (! error_state) | |
| 949 { | |
| 950 NDArray y; | |
| 951 if (arg_y.is_complex_type ()) | |
| 952 y = arg_y.complex_array_value ().abs (); | |
| 953 else | |
| 954 y = arg_y.array_value (); | |
| 955 | |
| 956 if (! error_state) | |
| 957 retval = map_m_m (hypot, x, y); | |
| 958 } | |
| 959 } | |
| 960 } | |
| 961 else | |
| 962 error ("hypot: nonconformant matrices"); | |
| 963 } | |
| 964 } | |
| 965 else | |
| 966 print_usage (); | |
| 967 | |
| 968 return retval; | |
| 969 } | |
| 970 | |
| 971 /* | |
| 7741 | 972 %!assert (size (hypot (zeros (0, 2), zeros (0, 2))), [0, 2]) |
| 973 %!assert (size (hypot (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4]) | |
| 974 %!assert (size (hypot (rand (2, 3, 4), 1)), [2, 3, 4]) | |
| 975 %!assert (size (hypot (1, rand (2, 3, 4))), [2, 3, 4]) | |
| 976 %!assert (size (hypot (1, 2)), [1, 1]) | |
| 977 %!assert (hypot (1:10, 1:10), sqrt(2) * [1:10], 16*eps) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
978 %!assert (hypot (single(1:10), single(1:10)), single(sqrt(2) * [1:10])); |
| 7631 | 979 */ |
| 980 | |
| 7740 | 981 template<typename T, typename ET> |
| 982 void | |
| 983 map_2_xlog2 (const Array<T>& x, Array<T>& f, Array<ET>& e) | |
| 984 { | |
| 985 f = Array<T>(x.dims ()); | |
| 986 e = Array<ET>(x.dims ()); | |
| 987 for (octave_idx_type i = 0; i < x.numel (); i++) | |
| 988 { | |
| 989 int exp; | |
| 990 f.xelem (i) = xlog2 (x(i), exp); | |
| 991 e.xelem (i) = exp; | |
| 992 } | |
| 993 } | |
| 994 | |
| 995 DEFUN (log2, args, nargout, | |
| 996 "-*- texinfo -*-\n\ | |
| 997 @deftypefn {Mapping Function} {} log2 (@var{x})\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
998 @deftypefnx {Mapping Function} {[@var{f}, @var{e}] =} log2 (@var{x})\n\ |
|
9141
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
999 Compute the base-2 logarithm of each element of @var{x}.\n\ |
|
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1000 \n\ |
|
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1001 If called with two output arguments, split @var{x} into\n\ |
|
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1002 binary mantissa and exponent so that\n\ |
|
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1003 @tex\n\ |
|
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1004 ${1 \\over 2} \\le \\left| f \\right| < 1$\n\ |
|
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1005 @end tex\n\ |
|
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1006 @ifnottex\n\ |
|
9142
b38c45d1fc08
Remove trailing space from two doc strings to eliminate compile warning
Rik <rdrider0-list@yahoo.com>
parents:
9141
diff
changeset
|
1007 @code{1/2 <= abs(f) < 1}\n\ |
|
9141
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1008 @end ifnottex\n\ |
|
9167
1231b1762a9a
Simplify TeXinfo and eliminate use of @iftex in arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9165
diff
changeset
|
1009 and @var{e} is an integer. If\n\ |
|
1231b1762a9a
Simplify TeXinfo and eliminate use of @iftex in arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9165
diff
changeset
|
1010 @tex\n\ |
|
1231b1762a9a
Simplify TeXinfo and eliminate use of @iftex in arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9165
diff
changeset
|
1011 $x = 0$, $f = e = 0$.\n\ |
|
1231b1762a9a
Simplify TeXinfo and eliminate use of @iftex in arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9165
diff
changeset
|
1012 @end tex\n\ |
|
1231b1762a9a
Simplify TeXinfo and eliminate use of @iftex in arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9165
diff
changeset
|
1013 @ifnottex\n\ |
|
1231b1762a9a
Simplify TeXinfo and eliminate use of @iftex in arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9165
diff
changeset
|
1014 @code{x = 0}, @code{f = e = 0}.\n\ |
|
1231b1762a9a
Simplify TeXinfo and eliminate use of @iftex in arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9165
diff
changeset
|
1015 @end ifnottex\n\ |
|
9141
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1016 @seealso{pow2, log, log10, exp}\n\ |
| 7740 | 1017 @end deftypefn") |
| 1018 { | |
| 1019 octave_value_list retval; | |
| 1020 | |
| 1021 if (args.length () == 1) | |
| 1022 { | |
| 1023 if (nargout < 2) | |
| 1024 retval(0) = args(0).log2 (); | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1025 else if (args(0).is_single_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1026 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1027 if (args(0).is_real_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1028 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1029 FloatNDArray f; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1030 FloatNDArray x = args(0).float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1031 // FIXME -- should E be an int value? |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1032 FloatMatrix e; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1033 map_2_xlog2 (x, f, e); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1034 retval (1) = e; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1035 retval (0) = f; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1036 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1037 else if (args(0).is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1038 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1039 FloatComplexNDArray f; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1040 FloatComplexNDArray x = args(0).float_complex_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1041 // FIXME -- should E be an int value? |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1042 FloatNDArray e; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1043 map_2_xlog2 (x, f, e); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1044 retval (1) = e; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1045 retval (0) = f; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1046 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1047 } |
| 7740 | 1048 else if (args(0).is_real_type ()) |
| 1049 { | |
| 1050 NDArray f; | |
| 1051 NDArray x = args(0).array_value (); | |
| 1052 // FIXME -- should E be an int value? | |
| 1053 Matrix e; | |
| 1054 map_2_xlog2 (x, f, e); | |
| 1055 retval (1) = e; | |
| 1056 retval (0) = f; | |
| 1057 } | |
| 1058 else if (args(0).is_complex_type ()) | |
| 1059 { | |
| 1060 ComplexNDArray f; | |
| 1061 ComplexNDArray x = args(0).complex_array_value (); | |
| 1062 // FIXME -- should E be an int value? | |
| 1063 NDArray e; | |
| 1064 map_2_xlog2 (x, f, e); | |
| 1065 retval (1) = e; | |
| 1066 retval (0) = f; | |
| 1067 } | |
| 1068 else | |
| 1069 gripe_wrong_type_arg ("log2", args(0)); | |
| 1070 } | |
| 1071 else | |
| 1072 print_usage (); | |
| 1073 | |
| 1074 return retval; | |
| 1075 } | |
| 1076 | |
| 1077 /* | |
| 7741 | 1078 %!assert(log2 ([1/4, 1/2, 1, 2, 4]), [-2, -1, 0, 1, 2]); |
| 1079 %!assert(log2(Inf), Inf); | |
| 1080 %!assert(isnan(log2(NaN))); | |
| 1081 %!assert(log2(4*i), 2 + log2(1*i)); | |
| 1082 %!assert(log2(complex(0,Inf)), Inf + log2(i)); | |
| 1083 | |
| 7740 | 1084 %!test |
| 1085 %! [f, e] = log2 ([0,-1; 2,-4; Inf,-Inf]); | |
| 1086 %! assert (f, [0,-0.5; 0.5,-0.5; Inf,-Inf]); | |
|
9319
0d9178575dd7
fix log2 with 2 outargs, loosen tests to meet IEEE
Jaroslav Hajek <highegg@gmail.com>
parents:
9309
diff
changeset
|
1087 %! assert (e(1:2,:), [0,1;2,3]) |
| 7741 | 1088 |
| 7740 | 1089 %!test |
| 1090 %! [f, e] = log2 (complex (zeros (3, 2), [0,-1; 2,-4; Inf,-Inf])); | |
| 1091 %! assert (f, complex (zeros (3, 2), [0,-0.5; 0.5,-0.5; Inf,-Inf])); | |
|
9319
0d9178575dd7
fix log2 with 2 outargs, loosen tests to meet IEEE
Jaroslav Hajek <highegg@gmail.com>
parents:
9309
diff
changeset
|
1092 %! assert (e(1:2,:), [0,1; 2,3]); |
| 7740 | 1093 */ |
| 1094 | |
| 4311 | 1095 DEFUN (fmod, args, , |
| 1096 "-*- texinfo -*-\n\ | |
| 1097 @deftypefn {Mapping Function} {} fmod (@var{x}, @var{y})\n\ | |
| 4685 | 1098 Compute the floating point remainder of dividing @var{x} by @var{y}\n\ |
| 1099 using the C library function @code{fmod}. The result has the same\n\ | |
|
9141
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1100 sign as @var{x}. If @var{y} is zero, the result is implementation-dependent.\n\ |
|
c1fff751b5a8
Update section 17.1 (Utility Functions) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9066
diff
changeset
|
1101 @seealso{mod, rem}\n\ |
| 4311 | 1102 @end deftypefn") |
| 1103 { | |
| 1104 octave_value retval; | |
| 1105 | |
| 1106 int nargin = args.length (); | |
| 1107 | |
| 1108 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ()) | |
| 1109 { | |
|
9562
b8db3595f706
fix order of args in fmod
Jaroslav Hajek <highegg@gmail.com>
parents:
9555
diff
changeset
|
1110 octave_value arg_x = args(0); |
|
b8db3595f706
fix order of args in fmod
Jaroslav Hajek <highegg@gmail.com>
parents:
9555
diff
changeset
|
1111 octave_value arg_y = args(1); |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1112 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1113 dim_vector y_dims = arg_y.dims (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1114 dim_vector x_dims = arg_x.dims (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1115 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1116 bool y_is_scalar = y_dims.all_ones (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1117 bool x_is_scalar = x_dims.all_ones (); |
| 4311 | 1118 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1119 bool is_float = arg_y.is_single_type () || arg_x.is_single_type (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1120 |
| 4311 | 1121 if (y_is_scalar && x_is_scalar) |
| 1122 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1123 if (is_float) |
| 4311 | 1124 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1125 float y = arg_y.float_value (); |
| 4311 | 1126 |
| 1127 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1128 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1129 float x = arg_x.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1130 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1131 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1132 retval = fmod (x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1133 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1134 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1135 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1136 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1137 double y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1138 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1139 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1140 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1141 double x = arg_x.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1142 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1143 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1144 retval = fmod (x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1145 } |
| 4311 | 1146 } |
| 1147 } | |
| 1148 else if (y_is_scalar) | |
| 1149 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1150 if (is_float) |
| 4311 | 1151 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1152 float y = arg_y.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1153 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1154 if (! error_state) |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1155 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1156 FloatNDArray x = arg_x.float_array_value (); |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1157 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1158 if (! error_state) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1159 retval = map_fm_f (fmodf, x, y); |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1160 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1161 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1162 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1163 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1164 double y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1165 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1166 if (! error_state) |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1167 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1168 if (arg_x.is_sparse_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1169 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1170 SparseMatrix x = arg_x.sparse_matrix_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1171 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1172 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1173 retval = map_s_d (fmod, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1174 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1175 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1176 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1177 NDArray x = arg_x.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1178 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1179 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1180 retval = map_m_d (fmod, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1181 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1182 } |
| 4311 | 1183 } |
| 1184 } | |
| 1185 else if (x_is_scalar) | |
| 1186 { | |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1187 if (arg_y.is_sparse_type ()) |
| 4311 | 1188 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1189 SparseMatrix y = arg_y.sparse_matrix_value (); |
| 4311 | 1190 |
| 1191 if (! error_state) | |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1192 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1193 double x = arg_x.double_value (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1194 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1195 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1196 retval = map_d_s (fmod, x, y); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1197 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1198 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1199 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1200 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1201 FloatNDArray y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1202 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1203 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1204 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1205 float x = arg_x.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1206 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1207 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1208 retval = map_f_fm (fmodf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1209 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1210 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1211 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1212 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1213 NDArray y = arg_y.array_value (); |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1214 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1215 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1216 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1217 double x = arg_x.double_value (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1218 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1219 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1220 retval = map_d_m (fmod, x, y); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1221 } |
| 4311 | 1222 } |
| 1223 } | |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1224 else if (y_dims == x_dims) |
| 4311 | 1225 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1226 if (arg_y.is_sparse_type () || arg_x.is_sparse_type ()) |
| 4311 | 1227 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1228 SparseMatrix y = arg_y.sparse_matrix_value (); |
| 4311 | 1229 |
| 1230 if (! error_state) | |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1231 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1232 SparseMatrix x = arg_x.sparse_matrix_value (); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1233 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1234 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1235 retval = map_s_s (fmod, x, y); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1236 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1237 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1238 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1239 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1240 FloatNDArray y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1241 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1242 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1243 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1244 FloatNDArray x = arg_x.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1245 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1246 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1247 retval = map_fm_fm (fmodf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1248 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1249 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1250 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1251 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1252 NDArray y = arg_y.array_value (); |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1253 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1254 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1255 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1256 NDArray x = arg_x.array_value (); |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1257 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1258 if (! error_state) |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1259 retval = map_m_m (fmod, x, y); |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1260 } |
| 4311 | 1261 } |
| 1262 } | |
| 1263 else | |
| 1264 error ("fmod: nonconformant matrices"); | |
| 1265 } | |
| 1266 else | |
| 5823 | 1267 print_usage (); |
| 4311 | 1268 |
| 1269 return retval; | |
| 1270 } | |
| 1271 | |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1272 /* |
| 7741 | 1273 %!assert (size (fmod (zeros (0, 2), zeros (0, 2))), [0, 2]) |
| 1274 %!assert (size (fmod (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4]) | |
| 7743 | 1275 %!assert (size (fmod (rand (2, 3, 4), 1)), [2, 3, 4]) |
| 1276 %!assert (size (fmod (1, rand (2, 3, 4))), [2, 3, 4]) | |
| 1277 %!assert (size (fmod (1, 2)), [1, 1]) | |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1278 */ |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1279 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1280 // FIXME Need to convert the reduction functions of this file for single precision |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1281 |
| 7112 | 1282 #define NATIVE_REDUCTION_1(FCN, TYPE, DIM) \ |
| 1283 (arg.is_ ## TYPE ## _type ()) \ | |
| 1284 { \ | |
| 1285 TYPE ## NDArray tmp = arg. TYPE ##_array_value (); \ | |
| 1286 \ | |
| 1287 if (! error_state) \ | |
|
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1288 { \ |
|
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1289 octave_ ## TYPE::clear_conv_flags (); \ |
|
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1290 retval = tmp.FCN (DIM); \ |
|
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1291 if (octave_ ## TYPE::get_trunc_flag ()) \ |
|
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1292 { \ |
|
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1293 gripe_native_integer_math_truncated (#FCN, \ |
|
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1294 octave_ ## TYPE::type_name ()); \ |
|
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1295 octave_ ## TYPE::clear_conv_flags (); \ |
|
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1296 } \ |
|
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1297 } \ |
| 7112 | 1298 } |
| 1299 | |
|
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1300 #define NATIVE_REDUCTION(FCN, BOOL_FCN) \ |
| 7112 | 1301 \ |
| 1302 octave_value retval; \ | |
| 1303 \ | |
| 1304 int nargin = args.length (); \ | |
| 1305 \ | |
| 1306 bool isnative = false; \ | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1307 bool isdouble = false; \ |
| 7112 | 1308 \ |
| 1309 if (nargin > 1 && args(nargin - 1).is_string ()) \ | |
| 1310 { \ | |
| 1311 std::string str = args(nargin - 1).string_value (); \ | |
| 1312 \ | |
| 1313 if (! error_state) \ | |
| 1314 { \ | |
| 1315 if (str == "native") \ | |
| 1316 isnative = true; \ | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1317 else if (str == "double") \ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1318 isdouble = true; \ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1319 else \ |
| 7112 | 1320 error ("sum: unrecognized string argument"); \ |
| 1321 nargin --; \ | |
| 1322 } \ | |
| 1323 } \ | |
| 1324 \ | |
| 1325 if (nargin == 1 || nargin == 2) \ | |
| 1326 { \ | |
| 1327 octave_value arg = args(0); \ | |
| 1328 \ | |
| 1329 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \ | |
| 1330 \ | |
| 1331 if (! error_state) \ | |
| 1332 { \ | |
| 1333 if (dim >= -1) \ | |
| 1334 { \ | |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1335 if (arg.is_sparse_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1336 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1337 if (arg.is_real_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1338 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1339 SparseMatrix tmp = arg.sparse_matrix_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1340 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1341 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1342 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1343 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1344 else \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1345 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1346 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1347 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1348 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1349 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1350 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1351 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1352 else \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1353 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1354 if (isnative) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1355 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1356 if NATIVE_REDUCTION_1 (FCN, uint8, dim) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1357 else if NATIVE_REDUCTION_1 (FCN, uint16, dim) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1358 else if NATIVE_REDUCTION_1 (FCN, uint32, dim) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1359 else if NATIVE_REDUCTION_1 (FCN, uint64, dim) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1360 else if NATIVE_REDUCTION_1 (FCN, int8, dim) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1361 else if NATIVE_REDUCTION_1 (FCN, int16, dim) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1362 else if NATIVE_REDUCTION_1 (FCN, int32, dim) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1363 else if NATIVE_REDUCTION_1 (FCN, int64, dim) \ |
|
8756
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1364 else if (arg.is_bool_type ()) \ |
|
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1365 { \ |
|
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1366 boolNDArray tmp = arg.bool_array_value (); \ |
|
8756
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1367 if (! error_state) \ |
|
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1368 retval = boolNDArray (tmp.BOOL_FCN (dim)); \ |
|
8756
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1369 } \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1370 else if (arg.is_char_matrix ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1371 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1372 error (#FCN, ": invalid char type"); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1373 } \ |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1374 else if (!isdouble && arg.is_single_type ()) \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1375 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1376 if (arg.is_complex_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1377 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1378 FloatComplexNDArray tmp = \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1379 arg.float_complex_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1380 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1381 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1382 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1383 } \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1384 else if (arg.is_real_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1385 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1386 FloatNDArray tmp = arg.float_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1387 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1388 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1389 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1390 } \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1391 } \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1392 else if (arg.is_complex_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1393 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1394 ComplexNDArray tmp = arg.complex_array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1395 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1396 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1397 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1398 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1399 else if (arg.is_real_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1400 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1401 NDArray tmp = arg.array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1402 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1403 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1404 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1405 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1406 else \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1407 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1408 gripe_wrong_type_arg (#FCN, arg); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1409 return retval; \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1410 } \ |
| 7112 | 1411 } \ |
|
8756
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1412 else if (arg.is_bool_type ()) \ |
|
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1413 { \ |
|
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1414 boolNDArray tmp = arg.bool_array_value (); \ |
|
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1415 if (! error_state) \ |
|
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1416 retval = tmp.FCN (dim); \ |
|
d0755c9db5ed
implement fast logical sum (counting)
Jaroslav Hajek <highegg@gmail.com>
parents:
8734
diff
changeset
|
1417 } \ |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1418 else if (!isdouble && arg.is_single_type ()) \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1419 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1420 if (arg.is_real_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1421 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1422 FloatNDArray tmp = arg.float_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1423 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1424 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1425 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1426 } \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1427 else if (arg.is_complex_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1428 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1429 FloatComplexNDArray tmp = \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1430 arg.float_complex_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1431 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1432 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1433 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1434 } \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1435 } \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1436 else if (arg.is_real_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1437 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1438 NDArray tmp = arg.array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1439 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1440 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1441 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1442 } \ |
| 7112 | 1443 else if (arg.is_complex_type ()) \ |
| 1444 { \ | |
| 1445 ComplexNDArray tmp = arg.complex_array_value (); \ | |
| 1446 \ | |
| 1447 if (! error_state) \ | |
| 1448 retval = tmp.FCN (dim); \ | |
| 1449 } \ | |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1450 else \ |
| 7112 | 1451 { \ |
| 1452 gripe_wrong_type_arg (#FCN, arg); \ | |
| 1453 return retval; \ | |
| 1454 } \ | |
| 1455 } \ | |
| 1456 } \ | |
| 1457 else \ | |
| 1458 error (#FCN ": invalid dimension argument = %d", dim + 1); \ | |
| 1459 } \ | |
| 1460 \ | |
| 1461 } \ | |
| 1462 else \ | |
| 1463 print_usage (); \ | |
| 1464 \ | |
| 1465 return retval | |
| 1466 | |
| 3723 | 1467 #define DATA_REDUCTION(FCN) \ |
| 1468 \ | |
| 4233 | 1469 octave_value retval; \ |
| 3723 | 1470 \ |
| 1471 int nargin = args.length (); \ | |
| 1472 \ | |
| 1473 if (nargin == 1 || nargin == 2) \ | |
| 1474 { \ | |
| 1475 octave_value arg = args(0); \ | |
| 1476 \ | |
| 3864 | 1477 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \ |
| 3723 | 1478 \ |
| 1479 if (! error_state) \ | |
| 1480 { \ | |
| 4556 | 1481 if (dim >= -1) \ |
| 3723 | 1482 { \ |
| 1483 if (arg.is_real_type ()) \ | |
| 1484 { \ | |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1485 if (arg.is_sparse_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1486 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1487 SparseMatrix tmp = arg.sparse_matrix_value (); \ |
| 3723 | 1488 \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1489 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1490 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1491 } \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1492 else if (arg.is_single_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1493 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1494 FloatNDArray tmp = arg.float_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1495 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1496 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1497 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1498 } \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1499 else \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1500 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1501 NDArray tmp = arg.array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1502 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1503 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1504 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1505 } \ |
| 3723 | 1506 } \ |
| 1507 else if (arg.is_complex_type ()) \ | |
| 1508 { \ | |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1509 if (arg.is_sparse_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1510 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1511 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \ |
| 3723 | 1512 \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1513 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1514 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1515 } \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1516 else if (arg.is_single_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1517 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1518 FloatComplexNDArray tmp = arg.float_complex_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1519 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1520 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1521 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1522 } \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1523 else \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1524 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1525 ComplexNDArray tmp = arg.complex_array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1526 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1527 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1528 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1529 } \ |
| 3723 | 1530 } \ |
| 1531 else \ | |
| 1532 { \ | |
| 1533 gripe_wrong_type_arg (#FCN, arg); \ | |
| 1534 return retval; \ | |
| 1535 } \ | |
| 1536 } \ | |
| 1537 else \ | |
| 1538 error (#FCN ": invalid dimension argument = %d", dim + 1); \ | |
| 1539 } \ | |
| 1540 } \ | |
| 1541 else \ | |
| 5823 | 1542 print_usage (); \ |
| 3723 | 1543 \ |
| 1544 return retval | |
| 1545 | |
| 1957 | 1546 DEFUN (cumprod, args, , |
| 3428 | 1547 "-*- texinfo -*-\n\ |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1548 @deftypefn {Built-in Function} {} cumprod (@var{x})\n\ |
|
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1549 @deftypefnx {Built-in Function} {} cumprod (@var{x}, @var{dim})\n\ |
| 3723 | 1550 Cumulative product of elements along dimension @var{dim}. If\n\ |
|
9723
f426899f4b9c
fix reduction functions docstrings
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
1551 @var{dim} is omitted, it defaults to the first non-singleton dimension.\n\ |
| 5061 | 1552 \n\ |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1553 @seealso{prod, cumsum}\n\ |
| 3428 | 1554 @end deftypefn") |
| 523 | 1555 { |
| 3723 | 1556 DATA_REDUCTION (cumprod); |
| 523 | 1557 } |
| 1558 | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1559 /* |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1560 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1561 %!assert (cumprod ([1, 2, 3]), [1, 2, 6]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1562 %!assert (cumprod ([-1; -2; -3]), [-1; 2; -6]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1563 %!assert (cumprod ([i, 2+i, -3+2i, 4]), [i, -1+2i, -1-8i, -4-32i]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1564 %!assert (cumprod ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [1, 2, 3; i, 4i, 9i; -1+i, -8+8i, -27+27i]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1565 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1566 %!assert (cumprod (single([1, 2, 3])), single([1, 2, 6])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1567 %!assert (cumprod (single([-1; -2; -3])), single([-1; 2; -6])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1568 %!assert (cumprod (single([i, 2+i, -3+2i, 4])), single([i, -1+2i, -1-8i, -4-32i])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1569 %!assert (cumprod (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([1, 2, 3; i, 4i, 9i; -1+i, -8+8i, -27+27i])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1570 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1571 %!error <Invalid call to cumprod.*> cumprod (); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1572 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1573 %!assert (cumprod ([2, 3; 4, 5], 1), [2, 3; 8, 15]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1574 %!assert (cumprod ([2, 3; 4, 5], 2), [2, 6; 4, 20]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1575 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1576 %!assert (cumprod (single([2, 3; 4, 5]), 1), single([2, 3; 8, 15])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1577 %!assert (cumprod (single([2, 3; 4, 5]), 2), single([2, 6; 4, 20])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1578 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1579 */ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1580 |
| 1957 | 1581 DEFUN (cumsum, args, , |
| 3428 | 1582 "-*- texinfo -*-\n\ |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1583 @deftypefn {Built-in Function} {} cumsum (@var{x})\n\ |
|
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1584 @deftypefnx {Built-in Function} {} cumsum (@var{x}, @var{dim})\n\ |
|
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1585 @deftypefnx {Built-in Function} {} cumsum (@dots{}, 'native')\n\ |
| 3723 | 1586 Cumulative sum of elements along dimension @var{dim}. If @var{dim}\n\ |
|
9723
f426899f4b9c
fix reduction functions docstrings
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
1587 is omitted, it defaults to the first non-singleton dimension.\n\ |
|
8780
ea76466605ba
support native cumsum, gripe on overflow in sum/cumsum
Jaroslav Hajek <highegg@gmail.com>
parents:
8756
diff
changeset
|
1588 \n\ |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1589 The \"native\" argument implies the summation is performed in native type.\n\ |
|
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1590 See @code{sum} for a complete description and example of the use of\n\ |
|
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1591 \"native\".\n\ |
|
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1592 @seealso{sum, cumprod}\n\ |
| 3428 | 1593 @end deftypefn") |
| 523 | 1594 { |
|
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1595 octave_value retval; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1596 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1597 int nargin = args.length (); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1598 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1599 bool isnative = false; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1600 bool isdouble = false; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1601 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1602 if (nargin > 1 && args(nargin - 1).is_string ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1603 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1604 std::string str = args(nargin - 1).string_value (); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1605 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1606 if (! error_state) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1607 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1608 if (str == "native") |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1609 isnative = true; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1610 else if (str == "double") |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1611 isdouble = true; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1612 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1613 error ("sum: unrecognized string argument"); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1614 nargin --; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1615 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1616 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1617 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1618 if (error_state) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1619 return retval; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1620 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1621 if (nargin == 1 || nargin == 2) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1622 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1623 octave_value arg = args(0); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1624 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1625 int dim = -1; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1626 if (nargin == 2) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1627 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1628 dim = args(1).int_value () - 1; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1629 if (dim < 0) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1630 error ("cumsum: invalid dimension argument = %d", dim + 1); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1631 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1632 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1633 if (! error_state) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1634 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1635 switch (arg.builtin_type ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1636 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1637 case btyp_double: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1638 if (arg.is_sparse_type ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1639 retval = arg.sparse_matrix_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1640 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1641 retval = arg.array_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1642 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1643 case btyp_complex: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1644 if (arg.is_sparse_type ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1645 retval = arg.sparse_complex_matrix_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1646 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1647 retval = arg.complex_array_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1648 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1649 case btyp_float: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1650 if (isdouble) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1651 retval = arg.array_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1652 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1653 retval = arg.float_array_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1654 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1655 case btyp_float_complex: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1656 if (isdouble) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1657 retval = arg.complex_array_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1658 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1659 retval = arg.float_complex_array_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1660 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1661 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1662 #define MAKE_INT_BRANCH(X) \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1663 case btyp_ ## X: \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1664 if (isnative) \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1665 retval = arg.X ## _array_value ().cumsum (dim); \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1666 else \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1667 retval = arg.array_value ().cumsum (dim); \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1668 break |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1669 MAKE_INT_BRANCH (int8); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1670 MAKE_INT_BRANCH (int16); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1671 MAKE_INT_BRANCH (int32); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1672 MAKE_INT_BRANCH (int64); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1673 MAKE_INT_BRANCH (uint8); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1674 MAKE_INT_BRANCH (uint16); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1675 MAKE_INT_BRANCH (uint32); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1676 MAKE_INT_BRANCH (uint64); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1677 #undef MAKE_INT_BRANCH |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1678 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1679 case btyp_bool: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1680 if (arg.is_sparse_type ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1681 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1682 SparseMatrix cs = arg.sparse_matrix_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1683 if (isnative) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1684 retval = cs != 0.0; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1685 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1686 retval = cs; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1687 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1688 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1689 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1690 NDArray cs = arg.bool_array_value ().cumsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1691 if (isnative) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1692 retval = cs != 0.0; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1693 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1694 retval = cs; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1695 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1696 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1697 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1698 default: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1699 gripe_wrong_type_arg ("cumsum", arg); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1700 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1701 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1702 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1703 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1704 print_usage (); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1705 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
1706 return retval; |
| 523 | 1707 } |
| 1708 | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1709 /* |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1710 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1711 %!assert (cumsum ([1, 2, 3]), [1, 3, 6]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1712 %!assert (cumsum ([-1; -2; -3]), [-1; -3; -6]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1713 %!assert (cumsum ([i, 2+i, -3+2i, 4]), [i, 2+2i, -1+4i, 3+4i]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1714 %!assert (cumsum ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [1, 2, 3; 1+i, 2+2i, 3+3i; 2+2i, 4+4i, 6+6i]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1715 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1716 %!assert (cumsum (single([1, 2, 3])), single([1, 3, 6])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1717 %!assert (cumsum (single([-1; -2; -3])), single([-1; -3; -6])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1718 %!assert (cumsum (single([i, 2+i, -3+2i, 4])), single([i, 2+2i, -1+4i, 3+4i])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1719 %!assert (cumsum (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([1, 2, 3; 1+i, 2+2i, 3+3i; 2+2i, 4+4i, 6+6i])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1720 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1721 %!error <Invalid call to cumsum.*> cumsum (); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1722 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1723 %!assert (cumsum ([1, 2; 3, 4], 1), [1, 2; 4, 6]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1724 %!assert (cumsum ([1, 2; 3, 4], 2), [1, 3; 3, 7]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1725 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1726 %!assert (cumsum (single([1, 2; 3, 4]), 1), single([1, 2; 4, 6])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1727 %!assert (cumsum (single([1, 2; 3, 4]), 2), single([1, 3; 3, 7])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1728 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1729 */ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1730 |
| 1957 | 1731 DEFUN (diag, args, , |
| 3369 | 1732 "-*- texinfo -*-\n\ |
| 1733 @deftypefn {Built-in Function} {} diag (@var{v}, @var{k})\n\ | |
| 1734 Return a diagonal matrix with vector @var{v} on diagonal @var{k}. The\n\ | |
| 1735 second argument is optional. If it is positive, the vector is placed on\n\ | |
| 1736 the @var{k}-th super-diagonal. If it is negative, it is placed on the\n\ | |
| 1737 @var{-k}-th sub-diagonal. The default value of @var{k} is 0, and the\n\ | |
| 1738 vector is placed on the main diagonal. For example,\n\ | |
| 1739 \n\ | |
| 1740 @example\n\ | |
| 1741 @group\n\ | |
| 1742 diag ([1, 2, 3], 1)\n\ | |
| 1743 @result{} 0 1 0 0\n\ | |
| 1744 0 0 2 0\n\ | |
| 1745 0 0 0 3\n\ | |
| 1746 0 0 0 0\n\ | |
| 1747 @end group\n\ | |
| 1748 @end example\n\ | |
| 6772 | 1749 \n\ |
| 1750 @noindent\n\ | |
| 1751 Given a matrix argument, instead of a vector, @code{diag} extracts the\n\ | |
| 6774 | 1752 @var{k}-th diagonal of the matrix.\n\ |
| 3369 | 1753 @end deftypefn") |
| 523 | 1754 { |
| 4233 | 1755 octave_value retval; |
| 523 | 1756 |
| 1757 int nargin = args.length (); | |
| 1758 | |
| 712 | 1759 if (nargin == 1 && args(0).is_defined ()) |
|
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1760 retval = args(0).diag(); |
| 712 | 1761 else if (nargin == 2 && args(0).is_defined () && args(1).is_defined ()) |
|
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1762 { |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1763 octave_idx_type k = args(1).int_value (); |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1764 |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1765 if (error_state) |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1766 error ("diag: invalid second argument"); |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1767 else |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1768 retval = args(0).diag(k); |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1769 } |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1770 else if (nargin == 3) |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1771 { |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1772 octave_value arg0 = args(0); |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1773 if (arg0.ndims () == 2 && (args(0).rows () == 1 || args(0).columns () == 1)) |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1774 { |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1775 octave_idx_type m = args(1).int_value (), n = args(2).int_value (); |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1776 if (! error_state) |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1777 retval = arg0.diag ().resize (dim_vector (m, n)); |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1778 else |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1779 error ("diag: invalid dimensions"); |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1780 } |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1781 else |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1782 error ("diag: first argument must be a vector"); |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
1783 } |
| 523 | 1784 else |
| 5823 | 1785 print_usage (); |
| 523 | 1786 |
| 1787 return retval; | |
| 1788 } | |
| 1789 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1790 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1791 |
|
8459
d17874a6f161
improve indexing of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
1792 %!assert(full (diag ([1; 2; 3])), [1, 0, 0; 0, 2, 0; 0, 0, 3]); |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1793 %!assert(diag ([1; 2; 3], 1), [0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1794 %!assert(diag ([1; 2; 3], 2), [0, 0, 1, 0, 0; 0, 0, 0, 2, 0; 0, 0, 0, 0, 3; 0, 0, 0, 0, 0; 0, 0, 0, 0, 0]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1795 %!assert(diag ([1; 2; 3],-1), [0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1796 %!assert(diag ([1; 2; 3],-2), [0, 0, 0, 0, 0; 0, 0, 0, 0, 0; 1, 0, 0, 0, 0; 0, 2, 0, 0, 0; 0, 0, 3, 0, 0]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1797 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1798 %!assert(diag ([1, 0, 0; 0, 2, 0; 0, 0, 3]), [1; 2; 3]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1799 %!assert(diag ([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0], 1), [1; 2; 3]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1800 %!assert(diag ([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0], -1), [1; 2; 3]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1801 |
|
8459
d17874a6f161
improve indexing of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
1802 %!assert(full (diag (single([1; 2; 3]))), single([1, 0, 0; 0, 2, 0; 0, 0, 3])); |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1803 %!assert(diag (single([1; 2; 3]), 1), single([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1804 %!assert(diag (single([1; 2; 3]), 2), single([0, 0, 1, 0, 0; 0, 0, 0, 2, 0; 0, 0, 0, 0, 3; 0, 0, 0, 0, 0; 0, 0, 0, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1805 %!assert(diag (single([1; 2; 3]),-1), single([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1806 %!assert(diag (single([1; 2; 3]),-2), single([0, 0, 0, 0, 0; 0, 0, 0, 0, 0; 1, 0, 0, 0, 0; 0, 2, 0, 0, 0; 0, 0, 3, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1807 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1808 %!assert(diag (single([1, 0, 0; 0, 2, 0; 0, 0, 3])), single([1; 2; 3])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1809 %!assert(diag (single([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0]), 1), single([1; 2; 3])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1810 %!assert(diag (single([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0]), -1), single([1; 2; 3])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1811 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1812 %!assert(diag (int8([1; 2; 3])), int8([1, 0, 0; 0, 2, 0; 0, 0, 3])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1813 %!assert(diag (int8([1; 2; 3]), 1), int8([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1814 %!assert(diag (int8([1; 2; 3]), 2), int8([0, 0, 1, 0, 0; 0, 0, 0, 2, 0; 0, 0, 0, 0, 3; 0, 0, 0, 0, 0; 0, 0, 0, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1815 %!assert(diag (int8([1; 2; 3]),-1), int8([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1816 %!assert(diag (int8([1; 2; 3]),-2), int8([0, 0, 0, 0, 0; 0, 0, 0, 0, 0; 1, 0, 0, 0, 0; 0, 2, 0, 0, 0; 0, 0, 3, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1817 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1818 %!assert(diag (int8([1, 0, 0; 0, 2, 0; 0, 0, 3])), int8([1; 2; 3])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1819 %!assert(diag (int8([0, 1, 0, 0; 0, 0, 2, 0; 0, 0, 0, 3; 0, 0, 0, 0]), 1), int8([1; 2; 3])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1820 %!assert(diag (int8([0, 0, 0, 0; 1, 0, 0, 0; 0, 2, 0, 0; 0, 0, 3, 0]), -1), int8([1; 2; 3])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1821 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1822 %!error <Invalid call to diag.*> diag (); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1823 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1824 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1825 |
| 1957 | 1826 DEFUN (prod, args, , |
| 3428 | 1827 "-*- texinfo -*-\n\ |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1828 @deftypefn {Built-in Function} {} prod (@var{x})\n\ |
|
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1829 @deftypefnx {Built-in Function} {} prod (@var{x}, @var{dim})\n\ |
| 3723 | 1830 Product of elements along dimension @var{dim}. If @var{dim} is\n\ |
|
9723
f426899f4b9c
fix reduction functions docstrings
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
1831 omitted, it defaults to the first non-singleton dimension.\n\ |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
1832 @seealso{cumprod, sum}\n\ |
| 3428 | 1833 @end deftypefn") |
| 523 | 1834 { |
| 3723 | 1835 DATA_REDUCTION (prod); |
| 523 | 1836 } |
| 1837 | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1838 /* |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1839 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1840 %!assert (prod ([1, 2, 3]), 6); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1841 %!assert (prod ([-1; -2; -3]), -6); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1842 %!assert (prod ([i, 2+i, -3+2i, 4]), -4 - 32i); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1843 %!assert (prod ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [-1+i, -8+8i, -27+27i]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1844 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1845 %!assert (prod (single([1, 2, 3])), single(6)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1846 %!assert (prod (single([-1; -2; -3])), single(-6)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1847 %!assert (prod (single([i, 2+i, -3+2i, 4])), single(-4 - 32i)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1848 %!assert (prod (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([-1+i, -8+8i, -27+27i])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1849 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1850 %!error <Invalid call to prod.*> prod (); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1851 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1852 %!assert (prod ([1, 2; 3, 4], 1), [3, 8]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1853 %!assert (prod ([1, 2; 3, 4], 2), [2; 12]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1854 %!assert (prod (zeros (1, 0)), 1); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1855 %!assert (prod (zeros (1, 0), 1), zeros (1, 0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1856 %!assert (prod (zeros (1, 0), 2), 1); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1857 %!assert (prod (zeros (0, 1)), 1); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1858 %!assert (prod (zeros (0, 1), 1), 1); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1859 %!assert (prod (zeros (0, 1), 2), zeros (0, 1)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1860 %!assert (prod (zeros (2, 0)), zeros (1, 0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1861 %!assert (prod (zeros (2, 0), 1), zeros (1, 0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1862 %!assert (prod (zeros (2, 0), 2), [1; 1]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1863 %!assert (prod (zeros (0, 2)), [1, 1]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1864 %!assert (prod (zeros (0, 2), 1), [1, 1]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1865 %!assert (prod (zeros (0, 2), 2), zeros(0, 1)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1866 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1867 %!assert (prod (single([1, 2; 3, 4]), 1), single([3, 8])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1868 %!assert (prod (single([1, 2; 3, 4]), 2), single([2; 12])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1869 %!assert (prod (zeros (1, 0, 'single')), single(1)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1870 %!assert (prod (zeros (1, 0, 'single'), 1), zeros (1, 0, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1871 %!assert (prod (zeros (1, 0, 'single'), 2), single(1)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1872 %!assert (prod (zeros (0, 1, 'single')), single(1)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1873 %!assert (prod (zeros (0, 1, 'single'), 1), single(1)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1874 %!assert (prod (zeros (0, 1, 'single'), 2), zeros (0, 1, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1875 %!assert (prod (zeros (2, 0, 'single')), zeros (1, 0, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1876 %!assert (prod (zeros (2, 0, 'single'), 1), zeros (1, 0, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1877 %!assert (prod (zeros (2, 0, 'single'), 2), single([1; 1])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1878 %!assert (prod (zeros (0, 2, 'single')), single([1, 1])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1879 %!assert (prod (zeros (0, 2, 'single'), 1), single([1, 1])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1880 %!assert (prod (zeros (0, 2, 'single'), 2), zeros(0, 1, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1881 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1882 */ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1883 |
|
8107
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1884 #define SINGLE_TYPE_CONCAT(TYPE, EXTRACTOR) \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1885 do \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1886 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1887 int dv_len = dv.length (); \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1888 Array<octave_idx_type> ra_idx (dv_len > 1 ? dv_len : 2, 0); \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1889 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1890 for (int j = 1; j < n_args; j++) \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1891 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1892 OCTAVE_QUIT; \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1893 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1894 TYPE ra = args(j).EXTRACTOR (); \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1895 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1896 if (! error_state) \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1897 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1898 result.insert (ra, ra_idx); \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1899 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1900 if (error_state) \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1901 return retval; \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1902 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1903 dim_vector dv_tmp = args (j).dims (); \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1904 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1905 if (dim >= dv_len) \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1906 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1907 if (j > 1) \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1908 error ("%s: indexing error", fname.c_str ()); \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1909 break; \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1910 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1911 else \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1912 ra_idx (dim) += (dim < dv_tmp.length () ? dv_tmp (dim) : 1); \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1913 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1914 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1915 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1916 while (0) |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1917 |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1918 #define DO_SINGLE_TYPE_CONCAT(TYPE, EXTRACTOR) \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1919 do \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1920 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1921 TYPE result (dv); \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1922 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1923 SINGLE_TYPE_CONCAT(TYPE, EXTRACTOR); \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1924 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1925 retval = result; \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1926 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1927 while (0) |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1928 |
| 4824 | 1929 static octave_value |
| 1930 do_cat (const octave_value_list& args, std::string fname) | |
| 4806 | 1931 { |
| 1932 octave_value retval; | |
| 1933 | |
| 4824 | 1934 int n_args = args.length (); |
| 4806 | 1935 |
| 5714 | 1936 if (n_args == 1) |
| 1937 retval = Matrix (); | |
| 1938 else if (n_args == 2) | |
| 1939 retval = args(1); | |
| 5507 | 1940 else if (n_args > 2) |
| 4824 | 1941 { |
| 5275 | 1942 octave_idx_type dim = args(0).int_value () - 1; |
| 4806 | 1943 |
| 4824 | 1944 if (error_state) |
| 4806 | 1945 { |
| 4824 | 1946 error ("cat: expecting first argument to be a integer"); |
| 4806 | 1947 return retval; |
| 1948 } | |
| 1949 | |
| 4824 | 1950 if (dim >= 0) |
| 1951 { | |
| 4915 | 1952 |
| 1953 dim_vector dv = args(1).dims (); | |
|
8107
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1954 std::string result_type = args(1).class_name (); |
| 4824 | 1955 |
|
8107
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1956 bool all_sq_strings_p = args(1).is_sq_string (); |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1957 bool all_dq_strings_p = args(1).is_dq_string (); |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1958 bool all_real_p = args(1).is_real_type (); |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1959 bool any_sparse_p = args(1).is_sparse_type(); |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1960 |
| 4915 | 1961 for (int i = 2; i < args.length (); i++) |
| 1962 { | |
| 1963 // add_dims constructs a dimension vector which holds the | |
| 4824 | 1964 // dimensions of the final array after concatenation. |
| 4806 | 1965 |
| 4915 | 1966 if (! dv.concat (args(i).dims (), dim)) |
| 4806 | 1967 { |
| 4824 | 1968 // Dimensions do not match. |
| 4915 | 1969 error ("cat: dimension mismatch"); |
| 4806 | 1970 return retval; |
| 1971 } | |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1972 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1973 result_type = |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1974 get_concat_class (result_type, args(i).class_name ()); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1975 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1976 if (all_sq_strings_p && ! args(i).is_sq_string ()) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1977 all_sq_strings_p = false; |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1978 if (all_dq_strings_p && ! args(i).is_dq_string ()) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1979 all_dq_strings_p = false; |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1980 if (all_real_p && ! args(i).is_real_type ()) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1981 all_real_p = false; |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1982 if (!any_sparse_p && args(i).is_sparse_type ()) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1983 any_sparse_p = true; |
| 4824 | 1984 } |
| 1985 | |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1986 if (result_type == "double") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1987 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1988 if (any_sparse_p) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1989 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1990 if (all_real_p) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1991 DO_SINGLE_TYPE_CONCAT (SparseMatrix, sparse_matrix_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1992 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1993 DO_SINGLE_TYPE_CONCAT (SparseComplexMatrix, sparse_complex_matrix_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1994 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1995 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1996 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1997 if (all_real_p) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1998 DO_SINGLE_TYPE_CONCAT (NDArray, array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1999 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2000 DO_SINGLE_TYPE_CONCAT (ComplexNDArray, complex_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2001 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2002 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2003 else if (result_type == "single") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2004 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2005 if (all_real_p) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2006 DO_SINGLE_TYPE_CONCAT (FloatNDArray, float_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2007 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2008 DO_SINGLE_TYPE_CONCAT (FloatComplexNDArray, |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2009 float_complex_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2010 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2011 else if (result_type == "char") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2012 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2013 char type = all_dq_strings_p ? '"' : '\''; |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2014 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2015 maybe_warn_string_concat (all_dq_strings_p, all_sq_strings_p); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2016 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2017 charNDArray result (dv, Vstring_fill_char); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2018 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2019 SINGLE_TYPE_CONCAT (charNDArray, char_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2020 |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9685
diff
changeset
|
2021 retval = octave_value (result, type); |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2022 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2023 else if (result_type == "logical") |
| 5533 | 2024 { |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2025 if (any_sparse_p) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2026 DO_SINGLE_TYPE_CONCAT (SparseBoolMatrix, sparse_bool_matrix_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2027 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2028 DO_SINGLE_TYPE_CONCAT (boolNDArray, bool_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2029 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2030 else if (result_type == "int8") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2031 DO_SINGLE_TYPE_CONCAT (int8NDArray, int8_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2032 else if (result_type == "int16") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2033 DO_SINGLE_TYPE_CONCAT (int16NDArray, int16_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2034 else if (result_type == "int32") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2035 DO_SINGLE_TYPE_CONCAT (int32NDArray, int32_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2036 else if (result_type == "int64") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2037 DO_SINGLE_TYPE_CONCAT (int64NDArray, int64_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2038 else if (result_type == "uint8") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2039 DO_SINGLE_TYPE_CONCAT (uint8NDArray, uint8_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2040 else if (result_type == "uint16") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2041 DO_SINGLE_TYPE_CONCAT (uint16NDArray, uint16_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2042 else if (result_type == "uint32") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2043 DO_SINGLE_TYPE_CONCAT (uint32NDArray, uint32_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2044 else if (result_type == "uint64") |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2045 DO_SINGLE_TYPE_CONCAT (uint64NDArray, uint64_array_value); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2046 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2047 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2048 // The lines below might seem crazy, since we take a copy |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2049 // of the first argument, resize it to be empty and then resize |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2050 // it to be full. This is done since it means that there is no |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2051 // recopying of data, as would happen if we used a single resize. |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2052 // It should be noted that resize operation is also significantly |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2053 // slower than the do_cat_op function, so it makes sense to have |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2054 // an empty matrix and copy all data. |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2055 // |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2056 // We might also start with a empty octave_value using |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2057 // tmp = octave_value_typeinfo::lookup_type |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2058 // (args(1).type_name()); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2059 // and then directly resize. However, for some types there might |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2060 // be some additional setup needed, and so this should be avoided. |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2061 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2062 octave_value tmp = args (1); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2063 tmp = tmp.resize (dim_vector (0,0)).resize (dv); |
| 4824 | 2064 |
| 4915 | 2065 if (error_state) |
| 2066 return retval; | |
| 4806 | 2067 |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2068 int dv_len = dv.length (); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2069 Array<octave_idx_type> ra_idx (dv_len, 0); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2070 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2071 for (int j = 1; j < n_args; j++) |
| 6401 | 2072 { |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2073 // Can't fast return here to skip empty matrices as something |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2074 // like cat(1,[],single([])) must return an empty matrix of |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2075 // the right type. |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2076 tmp = do_cat_op (tmp, args (j), ra_idx); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2077 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2078 if (error_state) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2079 return retval; |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2080 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2081 dim_vector dv_tmp = args (j).dims (); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2082 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2083 if (dim >= dv_len) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2084 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2085 if (j > 1) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2086 error ("%s: indexing error", fname.c_str ()); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2087 break; |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2088 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2089 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2090 ra_idx (dim) += (dim < dv_tmp.length () ? |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2091 dv_tmp (dim) : 1); |
| 6401 | 2092 } |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2093 retval = tmp; |
| 4915 | 2094 } |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2095 |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2096 if (! error_state) |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2097 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2098 // Reshape, chopping trailing singleton dimensions |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2099 dv.chop_trailing_singletons (); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2100 retval = retval.reshape (dv); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2101 } |
| 4806 | 2102 } |
| 5533 | 2103 else |
| 2104 error ("%s: invalid dimension argument", fname.c_str ()); | |
| 4806 | 2105 } |
| 2106 else | |
| 5823 | 2107 print_usage (); |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
2108 |
| 4806 | 2109 return retval; |
| 2110 } | |
| 2111 | |
| 2112 DEFUN (horzcat, args, , | |
| 4824 | 2113 "-*- texinfo -*-\n\ |
| 4806 | 2114 @deftypefn {Built-in Function} {} horzcat (@var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\ |
| 2115 Return the horizontal concatenation of N-d array objects, @var{array1},\n\ | |
| 2116 @var{array2}, @dots{}, @var{arrayN} along dimension 2.\n\ | |
| 5642 | 2117 @seealso{cat, vertcat}\n\ |
| 2118 @end deftypefn") | |
| 4806 | 2119 { |
| 2120 octave_value_list args_tmp = args; | |
| 2121 | |
| 2122 int dim = 2; | |
| 2123 | |
| 2124 octave_value d (dim); | |
| 2125 | |
| 2126 args_tmp.prepend (d); | |
| 2127 | |
| 4824 | 2128 return do_cat (args_tmp, "horzcat"); |
| 4806 | 2129 } |
| 2130 | |
| 2131 DEFUN (vertcat, args, , | |
| 2132 "-*- texinfo -*-\n\ | |
| 2133 @deftypefn {Built-in Function} {} vertcat (@var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\ | |
| 2134 Return the vertical concatenation of N-d array objects, @var{array1},\n\ | |
| 2135 @var{array2}, @dots{}, @var{arrayN} along dimension 1.\n\ | |
| 5642 | 2136 @seealso{cat, horzcat}\n\ |
| 2137 @end deftypefn") | |
| 4806 | 2138 { |
| 2139 octave_value_list args_tmp = args; | |
| 2140 | |
| 2141 int dim = 1; | |
| 2142 | |
| 2143 octave_value d (dim); | |
| 2144 | |
| 2145 args_tmp.prepend (d); | |
| 2146 | |
| 4824 | 2147 return do_cat (args_tmp, "vertcat"); |
| 4806 | 2148 } |
| 2149 | |
| 4758 | 2150 DEFUN (cat, args, , |
| 2151 "-*- texinfo -*-\n\ | |
| 2152 @deftypefn {Built-in Function} {} cat (@var{dim}, @var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\ | |
| 4806 | 2153 Return the concatenation of N-d array objects, @var{array1},\n\ |
| 2154 @var{array2}, @dots{}, @var{arrayN} along dimension @var{dim}.\n\ | |
| 4758 | 2155 \n\ |
| 2156 @example\n\ | |
| 2157 @group\n\ | |
| 2158 A = ones (2, 2);\n\ | |
| 2159 B = zeros (2, 2);\n\ | |
| 2160 cat (2, A, B)\n\ | |
| 2161 @result{} ans =\n\ | |
| 2162 \n\ | |
| 2163 1 1 0 0\n\ | |
| 2164 1 1 0 0\n\ | |
| 2165 @end group\n\ | |
| 2166 @end example\n\ | |
| 2167 \n\ | |
| 2168 Alternatively, we can concatenate @var{A} and @var{B} along the\n\ | |
| 2169 second dimension the following way:\n\ | |
| 2170 \n\ | |
| 2171 @example\n\ | |
| 2172 @group\n\ | |
| 2173 [A, B].\n\ | |
| 2174 @end group\n\ | |
| 2175 @end example\n\ | |
| 2176 \n\ | |
| 2177 @var{dim} can be larger than the dimensions of the N-d array objects\n\ | |
| 2178 and the result will thus have @var{dim} dimensions as the\n\ | |
| 2179 following example shows:\n\ | |
| 2180 @example\n\ | |
| 2181 @group\n\ | |
| 2182 cat (4, ones(2, 2), zeros (2, 2))\n\ | |
| 2183 @result{} ans =\n\ | |
| 2184 \n\ | |
| 2185 ans(:,:,1,1) =\n\ | |
| 2186 \n\ | |
| 2187 1 1\n\ | |
| 2188 1 1\n\ | |
| 2189 \n\ | |
| 2190 ans(:,:,1,2) =\n\ | |
| 2191 0 0\n\ | |
| 2192 0 0\n\ | |
| 2193 @end group\n\ | |
| 2194 @end example\n\ | |
| 5642 | 2195 @seealso{horzcat, vertcat}\n\ |
| 2196 @end deftypefn") | |
| 4758 | 2197 { |
| 4824 | 2198 return do_cat (args, "cat"); |
| 4758 | 2199 } |
| 2200 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2201 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2202 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2203 %!function ret = testcat (t1, t2, tr, cmplx) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2204 %! assert (cat (1, cast ([], t1), cast([], t2)), cast ([], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2205 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2206 %! assert (cat (1, cast (1, t1), cast (2, t2)), cast ([1; 2], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2207 %! assert (cat (1, cast (1, t1), cast ([2; 3], t2)), cast ([1; 2; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2208 %! assert (cat (1, cast ([1; 2], t1), cast (3, t2)), cast ([1; 2; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2209 %! assert (cat (1, cast ([1; 2], t1), cast ([3; 4], t2)), cast ([1; 2; 3; 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2210 %! assert (cat (2, cast (1, t1), cast (2, t2)), cast ([1, 2], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2211 %! assert (cat (2, cast (1, t1), cast ([2, 3], t2)), cast ([1, 2, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2212 %! assert (cat (2, cast ([1, 2], t1), cast (3, t2)), cast ([1, 2, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2213 %! assert (cat (2, cast ([1, 2], t1), cast ([3, 4], t2)), cast ([1, 2, 3, 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2214 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2215 %! assert ([cast(1, t1); cast(2, t2)], cast ([1; 2], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2216 %! assert ([cast(1, t1); cast([2; 3], t2)], cast ([1; 2; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2217 %! assert ([cast([1; 2], t1); cast(3, t2)], cast ([1; 2; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2218 %! assert ([cast([1; 2], t1); cast([3; 4], t2)], cast ([1; 2; 3; 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2219 %! assert ([cast(1, t1), cast(2, t2)], cast ([1, 2], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2220 %! assert ([cast(1, t1), cast([2, 3], t2)], cast ([1, 2, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2221 %! assert ([cast([1, 2], t1), cast(3, t2)], cast ([1, 2, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2222 %! assert ([cast([1, 2], t1), cast([3, 4], t2)], cast ([1, 2, 3, 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2223 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2224 %! if (nargin == 3 || cmplx) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2225 %! assert (cat (1, cast (1i, t1), cast (2, t2)), cast ([1i; 2], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2226 %! assert (cat (1, cast (1i, t1), cast ([2; 3], t2)), cast ([1i; 2; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2227 %! assert (cat (1, cast ([1i; 2], t1), cast (3, t2)), cast ([1i; 2; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2228 %! assert (cat (1, cast ([1i; 2], t1), cast ([3; 4], t2)), cast ([1i; 2; 3; 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2229 %! assert (cat (2, cast (1i, t1), cast (2, t2)), cast ([1i, 2], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2230 %! assert (cat (2, cast (1i, t1), cast ([2, 3], t2)), cast ([1i, 2, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2231 %! assert (cat (2, cast ([1i, 2], t1), cast (3, t2)), cast ([1i, 2, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2232 %! assert (cat (2, cast ([1i, 2], t1), cast ([3, 4], t2)), cast ([1i, 2, 3, 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2233 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2234 %! assert ([cast(1i, t1); cast(2, t2)], cast ([1i; 2], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2235 %! assert ([cast(1i, t1); cast([2; 3], t2)], cast ([1i; 2; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2236 %! assert ([cast([1i; 2], t1); cast(3, t2)], cast ([1i; 2; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2237 %! assert ([cast([1i; 2], t1); cast([3; 4], t2)], cast ([1i; 2; 3; 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2238 %! assert ([cast(1i, t1), cast(2, t2)], cast ([1i, 2], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2239 %! assert ([cast(1i, t1), cast([2, 3], t2)], cast ([1i, 2, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2240 %! assert ([cast([1i, 2], t1), cast(3, t2)], cast ([1i, 2, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2241 %! assert ([cast([1i, 2], t1), cast([3, 4], t2)], cast ([1i, 2, 3, 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2242 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2243 %! assert (cat (1, cast (1, t1), cast (2i, t2)), cast ([1; 2i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2244 %! assert (cat (1, cast (1, t1), cast ([2i; 3], t2)), cast ([1; 2i; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2245 %! assert (cat (1, cast ([1; 2], t1), cast (3i, t2)), cast ([1; 2; 3i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2246 %! assert (cat (1, cast ([1; 2], t1), cast ([3i; 4], t2)), cast ([1; 2; 3i; 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2247 %! assert (cat (2, cast (1, t1), cast (2i, t2)), cast ([1, 2i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2248 %! assert (cat (2, cast (1, t1), cast ([2i, 3], t2)), cast ([1, 2i, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2249 %! assert (cat (2, cast ([1, 2], t1), cast (3i, t2)), cast ([1, 2, 3i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2250 %! assert (cat (2, cast ([1, 2], t1), cast ([3i, 4], t2)), cast ([1, 2, 3i, 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2251 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2252 %! assert ([cast(1, t1); cast(2i, t2)], cast ([1; 2i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2253 %! assert ([cast(1, t1); cast([2i; 3], t2)], cast ([1; 2i; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2254 %! assert ([cast([1; 2], t1); cast(3i, t2)], cast ([1; 2; 3i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2255 %! assert ([cast([1; 2], t1); cast([3i; 4], t2)], cast ([1; 2; 3i; 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2256 %! assert ([cast(1, t1), cast(2i, t2)], cast ([1, 2i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2257 %! assert ([cast(1, t1), cast([2i, 3], t2)], cast ([1, 2i, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2258 %! assert ([cast([1, 2], t1), cast(3i, t2)], cast ([1, 2, 3i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2259 %! assert ([cast([1, 2], t1), cast([3i, 4], t2)], cast ([1, 2, 3i, 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2260 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2261 %! assert (cat (1, cast (1i, t1), cast (2i, t2)), cast ([1i; 2i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2262 %! assert (cat (1, cast (1i, t1), cast ([2i; 3], t2)), cast ([1i; 2i; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2263 %! assert (cat (1, cast ([1i; 2], t1), cast (3i, t2)), cast ([1i; 2; 3i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2264 %! assert (cat (1, cast ([1i; 2], t1), cast ([3i; 4], t2)), cast ([1i; 2; 3i; 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2265 %! assert (cat (2, cast (1i, t1), cast (2i, t2)), cast ([1i, 2i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2266 %! assert (cat (2, cast (1i, t1), cast ([2i, 3], t2)), cast ([1i, 2i, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2267 %! assert (cat (2, cast ([1i, 2], t1), cast (3i, t2)), cast ([1i, 2, 3i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2268 %! assert (cat (2, cast ([1i, 2], t1), cast ([3i, 4], t2)), cast ([1i, 2, 3i, 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2269 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2270 %! assert ([cast(1i, t1); cast(2i, t2)], cast ([1i; 2i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2271 %! assert ([cast(1i, t1); cast([2i; 3], t2)], cast ([1i; 2i; 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2272 %! assert ([cast([1i; 2], t1); cast(3i, t2)], cast ([1i; 2; 3i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2273 %! assert ([cast([1i; 2], t1); cast([3i; 4], t2)], cast ([1i; 2; 3i; 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2274 %! assert ([cast(1i, t1), cast(2i, t2)], cast ([1i, 2i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2275 %! assert ([cast(1i, t1), cast([2i, 3], t2)], cast ([1i, 2i, 3], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2276 %! assert ([cast([1i, 2], t1), cast(3i, t2)], cast ([1i, 2, 3i], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2277 %! assert ([cast([1i, 2], t1), cast([3i, 4], t2)], cast ([1i, 2, 3i, 4], tr)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2278 %! endif |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2279 %! ret = true; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2280 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2281 %!assert (testcat('double', 'double', 'double')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2282 %!assert (testcat('single', 'double', 'single')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2283 %!assert (testcat('double', 'single', 'single')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2284 %!assert (testcat('single', 'single', 'single')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2285 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2286 %!assert (testcat('double', 'int8', 'int8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2287 %!assert (testcat('int8', 'double', 'int8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2288 %!assert (testcat('single', 'int8', 'int8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2289 %!assert (testcat('int8', 'single', 'int8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2290 %!assert (testcat('int8', 'int8', 'int8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2291 %!assert (testcat('double', 'int16', 'int16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2292 %!assert (testcat('int16', 'double', 'int16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2293 %!assert (testcat('single', 'int16', 'int16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2294 %!assert (testcat('int16', 'single', 'int16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2295 %!assert (testcat('int16', 'int16', 'int16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2296 %!assert (testcat('double', 'int32', 'int32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2297 %!assert (testcat('int32', 'double', 'int32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2298 %!assert (testcat('single', 'int32', 'int32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2299 %!assert (testcat('int32', 'single', 'int32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2300 %!assert (testcat('int32', 'int32', 'int32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2301 %!assert (testcat('double', 'int64', 'int64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2302 %!assert (testcat('int64', 'double', 'int64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2303 %!assert (testcat('single', 'int64', 'int64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2304 %!assert (testcat('int64', 'single', 'int64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2305 %!assert (testcat('int64', 'int64', 'int64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2306 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2307 %!assert (testcat('double', 'uint8', 'uint8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2308 %!assert (testcat('uint8', 'double', 'uint8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2309 %!assert (testcat('single', 'uint8', 'uint8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2310 %!assert (testcat('uint8', 'single', 'uint8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2311 %!assert (testcat('uint8', 'uint8', 'uint8', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2312 %!assert (testcat('double', 'uint16', 'uint16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2313 %!assert (testcat('uint16', 'double', 'uint16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2314 %!assert (testcat('single', 'uint16', 'uint16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2315 %!assert (testcat('uint16', 'single', 'uint16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2316 %!assert (testcat('uint16', 'uint16', 'uint16', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2317 %!assert (testcat('double', 'uint32', 'uint32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2318 %!assert (testcat('uint32', 'double', 'uint32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2319 %!assert (testcat('single', 'uint32', 'uint32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2320 %!assert (testcat('uint32', 'single', 'uint32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2321 %!assert (testcat('uint32', 'uint32', 'uint32', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2322 %!assert (testcat('double', 'uint64', 'uint64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2323 %!assert (testcat('uint64', 'double', 'uint64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2324 %!assert (testcat('single', 'uint64', 'uint64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2325 %!assert (testcat('uint64', 'single', 'uint64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2326 %!assert (testcat('uint64', 'uint64', 'uint64', false)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2327 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2328 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2329 |
| 4593 | 2330 static octave_value |
| 6959 | 2331 do_permute (const octave_value_list& args, bool inv) |
| 4593 | 2332 { |
| 2333 octave_value retval; | |
| 2334 | |
| 5148 | 2335 if (args.length () == 2 && args(1).length () >= args(1).ndims ()) |
| 4593 | 2336 { |
| 2337 Array<int> vec = args(1).int_vector_value (); | |
| 2338 | |
| 5775 | 2339 // FIXME -- maybe we should create an idx_vector object |
| 5148 | 2340 // here and pass that to permute? |
| 2341 | |
| 2342 int n = vec.length (); | |
| 2343 | |
| 2344 for (int i = 0; i < n; i++) | |
| 2345 vec(i)--; | |
| 2346 | |
| 4593 | 2347 octave_value ret = args(0).permute (vec, inv); |
| 2348 | |
| 2349 if (! error_state) | |
| 2350 retval = ret; | |
| 2351 } | |
| 2352 else | |
| 5823 | 2353 print_usage (); |
| 4593 | 2354 |
| 2355 return retval; | |
| 2356 } | |
| 2357 | |
| 2358 DEFUN (permute, args, , | |
| 2359 "-*- texinfo -*-\n\ | |
| 2360 @deftypefn {Built-in Function} {} permute (@var{a}, @var{perm})\n\ | |
| 2361 Return the generalized transpose for an N-d array object @var{a}.\n\ | |
| 2362 The permutation vector @var{perm} must contain the elements\n\ | |
| 2363 @code{1:ndims(a)} (in any order, but each element must appear just once).\n\ | |
| 5642 | 2364 @seealso{ipermute}\n\ |
| 2365 @end deftypefn") | |
| 4593 | 2366 { |
| 6959 | 2367 return do_permute (args, false); |
| 4593 | 2368 } |
| 2369 | |
| 2370 DEFUN (ipermute, args, , | |
| 2371 "-*- texinfo -*-\n\ | |
| 2372 @deftypefn {Built-in Function} {} ipermute (@var{a}, @var{iperm})\n\ | |
| 2373 The inverse of the @code{permute} function. The expression\n\ | |
| 2374 \n\ | |
| 2375 @example\n\ | |
| 2376 ipermute (permute (a, perm), perm)\n\ | |
| 2377 @end example\n\ | |
| 2378 returns the original array @var{a}.\n\ | |
| 5642 | 2379 @seealso{permute}\n\ |
| 2380 @end deftypefn") | |
| 4593 | 2381 { |
| 6959 | 2382 return do_permute (args, true); |
| 4593 | 2383 } |
| 2384 | |
| 3195 | 2385 DEFUN (length, args, , |
| 3373 | 2386 "-*- texinfo -*-\n\ |
| 2387 @deftypefn {Built-in Function} {} length (@var{a})\n\ | |
| 4176 | 2388 Return the `length' of the object @var{a}. For matrix objects, the\n\ |
| 3373 | 2389 length is the number of rows or columns, whichever is greater (this\n\ |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
2390 odd definition is used for compatibility with @sc{matlab}).\n\ |
| 3373 | 2391 @end deftypefn") |
| 3195 | 2392 { |
| 2393 octave_value retval; | |
| 2394 | |
| 2395 if (args.length () == 1) | |
|
9706
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2396 retval = args(0).length (); |
| 3195 | 2397 else |
| 5823 | 2398 print_usage (); |
| 3195 | 2399 |
| 2400 return retval; | |
| 2401 } | |
| 2402 | |
| 4554 | 2403 DEFUN (ndims, args, , |
| 2404 "-*- texinfo -*-\n\ | |
| 2405 @deftypefn {Built-in Function} {} ndims (@var{a})\n\ | |
| 2406 Returns the number of dimensions of array @var{a}.\n\ | |
| 2407 For any array, the result will always be larger than or equal to 2.\n\ | |
| 2408 Trailing singleton dimensions are not counted.\n\ | |
| 2409 @end deftypefn") | |
| 2410 { | |
| 2411 octave_value retval; | |
| 2412 | |
| 2413 if (args.length () == 1) | |
|
9706
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2414 retval = args(0).ndims (); |
| 4554 | 2415 else |
| 5823 | 2416 print_usage (); |
| 4554 | 2417 |
| 2418 return retval; | |
| 2419 } | |
| 2420 | |
| 4559 | 2421 DEFUN (numel, args, , |
| 2422 "-*- texinfo -*-\n\ | |
| 2423 @deftypefn {Built-in Function} {} numel (@var{a})\n\ | |
|
9705
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2424 @deftypefnx {Built-in Function} {} numel (@var{a}, @var{idx1}, @var{idx2}, @dots{})\n\ |
| 4559 | 2425 Returns the number of elements in the object @var{a}.\n\ |
|
9705
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2426 Optionally, if indices @var{idx1}, @var{idx2}, @dots{} are supplied,\n\ |
|
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2427 return the number of elements that would result from the indexing\n\ |
|
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2428 @example\n\ |
|
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2429 @var{a}(@var{idx1}, @var{idx2}, @dots{})\n\ |
|
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2430 @end example\n\ |
|
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2431 This method is also called when an object appears as lvalue with cs-list\n\ |
|
9758
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
2432 indexing, i.e., @code{object@{@dots{}@}} or @code{object(@dots{}).field}.\n\ |
| 5724 | 2433 @seealso{size}\n\ |
| 4559 | 2434 @end deftypefn") |
| 2435 { | |
| 2436 octave_value retval; | |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
2437 octave_idx_type nargin = args.length (); |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9319
diff
changeset
|
2438 |
|
9705
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2439 if (nargin == 1) |
|
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2440 retval = args(0).numel (); |
|
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2441 else if (nargin > 1) |
| 4559 | 2442 { |
|
9705
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2443 // Don't use numel (const octave_value_list&) here as that corresponds to |
|
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2444 // an overloaded call, not to builtin! |
|
5acd99c3e794
avoid recursive overloaded calls in builtin numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9689
diff
changeset
|
2445 retval = dims_to_numel (args(0).dims (), args.slice (1, nargin-1)); |
| 4559 | 2446 } |
| 2447 else | |
| 5823 | 2448 print_usage (); |
| 4559 | 2449 |
| 2450 return retval; | |
| 2451 } | |
| 2452 | |
| 1957 | 2453 DEFUN (size, args, nargout, |
| 3373 | 2454 "-*- texinfo -*-\n\ |
| 2455 @deftypefn {Built-in Function} {} size (@var{a}, @var{n})\n\ | |
| 2456 Return the number rows and columns of @var{a}.\n\ | |
| 2457 \n\ | |
| 2458 With one input argument and one output argument, the result is returned\n\ | |
| 4741 | 2459 in a row vector. If there are multiple output arguments, the number of\n\ |
| 2460 rows is assigned to the first, and the number of columns to the second,\n\ | |
| 2461 etc. For example,\n\ | |
| 3373 | 2462 \n\ |
| 2463 @example\n\ | |
| 2464 @group\n\ | |
| 2465 size ([1, 2; 3, 4; 5, 6])\n\ | |
| 2466 @result{} [ 3, 2 ]\n\ | |
| 1031 | 2467 \n\ |
| 3373 | 2468 [nr, nc] = size ([1, 2; 3, 4; 5, 6])\n\ |
| 2469 @result{} nr = 3\n\ | |
| 2470 @result{} nc = 2\n\ | |
| 2471 @end group\n\ | |
| 2472 @end example\n\ | |
| 2473 \n\ | |
| 4741 | 2474 If given a second argument, @code{size} will return the size of the\n\ |
| 2475 corresponding dimension. For example\n\ | |
| 1031 | 2476 \n\ |
| 3373 | 2477 @example\n\ |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
2478 @group\n\ |
| 3373 | 2479 size ([1, 2; 3, 4; 5, 6], 2)\n\ |
| 2480 @result{} 2\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
2481 @end group\n\ |
| 3373 | 2482 @end example\n\ |
| 2483 \n\ | |
| 2484 @noindent\n\ | |
| 2485 returns the number of columns in the given matrix.\n\ | |
| 5724 | 2486 @seealso{numel}\n\ |
| 3373 | 2487 @end deftypefn") |
| 523 | 2488 { |
| 2086 | 2489 octave_value_list retval; |
| 523 | 2490 |
| 2491 int nargin = args.length (); | |
| 2492 | |
| 4513 | 2493 if (nargin == 1) |
| 523 | 2494 { |
|
9706
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2495 const dim_vector dimensions = args(0).dims (); |
| 4513 | 2496 |
| 2497 if (nargout > 1) | |
| 523 | 2498 { |
|
9706
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2499 const dim_vector rdims = dimensions.redim (nargout); |
|
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2500 retval.resize (nargout); |
|
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2501 for (int i = 0; i < nargout; i++) |
|
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2502 retval(i) = rdims(i); |
| 523 | 2503 } |
| 4513 | 2504 else |
| 712 | 2505 { |
|
9706
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2506 int ndims = dimensions.length (); |
|
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2507 |
|
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2508 NoAlias<Matrix> m (1, ndims); |
|
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2509 |
| 4513 | 2510 for (int i = 0; i < ndims; i++) |
|
9706
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2511 m(i) = dimensions(i); |
| 4513 | 2512 |
| 2513 retval(0) = m; | |
| 712 | 2514 } |
| 1031 | 2515 } |
| 2516 else if (nargin == 2 && nargout < 2) | |
| 2517 { | |
| 5275 | 2518 octave_idx_type nd = args(1).int_value (true); |
| 1031 | 2519 |
| 2520 if (error_state) | |
| 2521 error ("size: expecting scalar as second argument"); | |
| 712 | 2522 else |
| 1031 | 2523 { |
|
9706
71160b139b07
simplify length,ndims,size and size_equal
Jaroslav Hajek <highegg@gmail.com>
parents:
9705
diff
changeset
|
2524 const dim_vector dv = args(0).dims (); |
| 4741 | 2525 |
| 4911 | 2526 if (nd > 0) |
| 2527 { | |
| 2528 if (nd <= dv.length ()) | |
| 2529 retval(0) = dv(nd-1); | |
| 2530 else | |
| 2531 retval(0) = 1; | |
| 2532 } | |
| 1031 | 2533 else |
| 4741 | 2534 error ("size: requested dimension (= %d) out of range", nd); |
| 1031 | 2535 } |
| 523 | 2536 } |
| 712 | 2537 else |
| 5823 | 2538 print_usage (); |
| 523 | 2539 |
| 2540 return retval; | |
| 2541 } | |
| 2542 | |
| 6156 | 2543 DEFUN (size_equal, args, , |
| 2544 "-*- texinfo -*-\n\ | |
| 6561 | 2545 @deftypefn {Built-in Function} {} size_equal (@var{a}, @var{b}, @dots{})\n\ |
| 2546 Return true if the dimensions of all arguments agree.\n\ | |
| 6156 | 2547 Trailing singleton dimensions are ignored.\n\ |
|
8947
1e4b3149365a
allow size_equal called with 1 arg
Jaroslav Hajek <highegg@gmail.com>
parents:
8934
diff
changeset
|
2548 Called with a single argument, size_equal returns true.\n\ |
| 6156 | 2549 @seealso{size, numel}\n\ |
| 2550 @end deftypefn") | |
| 2551 { | |
| 2552 octave_value retval; | |
| 2553 | |
| 6561 | 2554 int nargin = args.length (); |
| 2555 | |
|
8947
1e4b3149365a
allow size_equal called with 1 arg
Jaroslav Hajek <highegg@gmail.com>
parents:
8934
diff
changeset
|
2556 if (nargin >= 1) |
| 6156 | 2557 { |
| 6561 | 2558 retval = true; |
| 2559 | |
| 6156 | 2560 dim_vector a_dims = args(0).dims (); |
| 6561 | 2561 |
| 2562 for (int i = 1; i < nargin; ++i) | |
| 2563 { | |
| 2564 dim_vector b_dims = args(i).dims (); | |
| 2565 | |
| 2566 if (a_dims != b_dims) | |
| 2567 { | |
| 2568 retval = false; | |
| 2569 break; | |
| 2570 } | |
| 2571 } | |
| 6156 | 2572 } |
| 2573 else | |
| 2574 print_usage (); | |
| 2575 | |
| 2576 return retval; | |
| 2577 } | |
| 2578 | |
| 5602 | 2579 DEFUN (nnz, args, , |
| 2580 "-*- texinfo -*-\n\ | |
| 6156 | 2581 @deftypefn {Built-in Function} {@var{scalar} =} nnz (@var{a})\n\ |
| 2582 Returns the number of non zero elements in @var{a}.\n\ | |
| 5602 | 2583 @seealso{sparse}\n\ |
| 2584 @end deftypefn") | |
| 2585 { | |
| 2586 octave_value retval; | |
| 2587 | |
| 2588 if (args.length () == 1) | |
| 2589 retval = args(0).nnz (); | |
| 2590 else | |
| 5823 | 2591 print_usage (); |
| 5602 | 2592 |
| 2593 return retval; | |
| 2594 } | |
| 2595 | |
| 5604 | 2596 DEFUN (nzmax, args, , |
| 2597 "-*- texinfo -*-\n\ | |
| 6156 | 2598 @deftypefn {Built-in Function} {@var{scalar} =} nzmax (@var{SM})\n\ |
| 5604 | 2599 Return the amount of storage allocated to the sparse matrix @var{SM}.\n\ |
| 7001 | 2600 Note that Octave tends to crop unused memory at the first opportunity\n\ |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
2601 for sparse objects. There are some cases of user created sparse objects\n\ |
|
9066
be150a172010
Cleanup documentation for diagperm.texi, sparse.texi
Rik <rdrider0-list@yahoo.com>
parents:
9064
diff
changeset
|
2602 where the value returned by @dfn{nzmax} will not be the same as @dfn{nnz},\n\ |
| 5604 | 2603 but in general they will give the same result.\n\ |
| 2604 @seealso{sparse, spalloc}\n\ | |
| 2605 @end deftypefn") | |
| 2606 { | |
| 2607 octave_value retval; | |
| 2608 | |
| 2609 if (args.length() == 1) | |
| 2610 retval = args(0).nzmax (); | |
| 2611 else | |
| 5823 | 2612 print_usage (); |
| 5604 | 2613 |
| 2614 return retval; | |
| 2615 } | |
| 2616 | |
| 5677 | 2617 DEFUN (rows, args, , |
| 2618 "-*- texinfo -*-\n\ | |
| 2619 @deftypefn {Built-in Function} {} rows (@var{a})\n\ | |
| 2620 Return the number of rows of @var{a}.\n\ | |
| 5724 | 2621 @seealso{size, numel, columns, length, isscalar, isvector, ismatrix}\n\ |
| 5677 | 2622 @end deftypefn") |
| 2623 { | |
| 2624 octave_value retval; | |
| 2625 | |
| 2626 if (args.length () == 1) | |
| 2627 retval = args(0).rows (); | |
| 2628 else | |
| 5823 | 2629 print_usage (); |
| 5677 | 2630 |
| 2631 return retval; | |
| 2632 } | |
| 2633 | |
| 2634 DEFUN (columns, args, , | |
| 2635 "-*- texinfo -*-\n\ | |
| 2636 @deftypefn {Built-in Function} {} columns (@var{a})\n\ | |
| 2637 Return the number of columns of @var{a}.\n\ | |
|
8286
6f2d95255911
fix @seealso references to point to existing anchors
Thorsten Meyer <thorsten.meyier@gmx.de>
parents:
8129
diff
changeset
|
2638 @seealso{size, numel, rows, length, isscalar, isvector, ismatrix}\n\ |
| 5677 | 2639 @end deftypefn") |
| 2640 { | |
| 2641 octave_value retval; | |
| 2642 | |
| 2643 if (args.length () == 1) | |
| 2644 retval = args(0).columns (); | |
| 2645 else | |
| 5823 | 2646 print_usage (); |
| 5677 | 2647 |
| 2648 return retval; | |
| 2649 } | |
| 2650 | |
| 1957 | 2651 DEFUN (sum, args, , |
| 3428 | 2652 "-*- texinfo -*-\n\ |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
2653 @deftypefn {Built-in Function} {} sum (@var{x})\n\ |
|
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
2654 @deftypefnx {Built-in Function} {} sum (@var{x}, @var{dim})\n\ |
| 7112 | 2655 @deftypefnx {Built-in Function} {} sum (@dots{}, 'native')\n\ |
|
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2656 @deftypefnx {Built-in Function} {} sum (@dots{}, 'double')\n\ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2657 @deftypefnx {Built-in Function} {} sum (@dots{}, 'extra')\n\ |
| 3723 | 2658 Sum of elements along dimension @var{dim}. If @var{dim} is\n\ |
|
9723
f426899f4b9c
fix reduction functions docstrings
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
2659 omitted, it defaults to the first non-singleton dimension.\n\ |
| 7112 | 2660 \n\ |
| 2661 If the optional argument 'native' is given, then the sum is performed\n\ | |
| 2662 in the same type as the original argument, rather than in the default\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
2663 double type. For example\n\ |
| 7112 | 2664 \n\ |
| 2665 @example\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
2666 @group\n\ |
| 7112 | 2667 sum ([true, true])\n\ |
| 2668 @result{} 2\n\ | |
| 2669 sum ([true, true], 'native')\n\ | |
| 2670 @result{} true\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
2671 @end group\n\ |
| 7112 | 2672 @end example\n\ |
|
9723
f426899f4b9c
fix reduction functions docstrings
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
2673 \n\ |
|
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2674 On the contrary, if 'double' is given, the sum is performed in double precision\n\ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2675 even for single precision inputs.\n\ |
|
9723
f426899f4b9c
fix reduction functions docstrings
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
2676 \n\ |
|
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2677 For double precision inputs, 'extra' indicates that a more accurate algorithm\n\ |
|
9758
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
2678 than straightforward summation is to be used. For single precision inputs, 'extra' is\n\ |
|
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
2679 the same as 'double'. Otherwise, 'extra' has no effect.\n\ |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
2680 @seealso{cumsum, sumsq, prod}\n\ |
| 3428 | 2681 @end deftypefn") |
| 523 | 2682 { |
|
9721
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2683 octave_value retval; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2684 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2685 int nargin = args.length (); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2686 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2687 bool isnative = false; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2688 bool isdouble = false; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2689 bool isextra = false; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2690 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2691 if (nargin > 1 && args(nargin - 1).is_string ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2692 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2693 std::string str = args(nargin - 1).string_value (); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2694 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2695 if (! error_state) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2696 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2697 if (str == "native") |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2698 isnative = true; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2699 else if (str == "double") |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2700 isdouble = true; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2701 else if (str == "extra") |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2702 isextra = true; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2703 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2704 error ("sum: unrecognized string argument"); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2705 nargin --; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2706 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2707 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2708 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2709 if (error_state) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2710 return retval; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2711 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2712 if (nargin == 1 || nargin == 2) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2713 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2714 octave_value arg = args(0); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2715 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2716 int dim = -1; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2717 if (nargin == 2) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2718 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2719 dim = args(1).int_value () - 1; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2720 if (dim < 0) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2721 error ("sum: invalid dimension argument = %d", dim + 1); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2722 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2723 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2724 if (! error_state) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2725 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2726 switch (arg.builtin_type ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2727 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2728 case btyp_double: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2729 if (arg.is_sparse_type ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2730 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2731 if (isextra) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2732 warning ("sum: 'extra' not yet implemented for sparse matrices"); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2733 retval = arg.sparse_matrix_value ().sum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2734 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2735 else if (isextra) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2736 retval = arg.array_value ().xsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2737 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2738 retval = arg.array_value ().sum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2739 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2740 case btyp_complex: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2741 if (arg.is_sparse_type ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2742 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2743 if (isextra) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2744 warning ("sum: 'extra' not yet implemented for sparse matrices"); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2745 retval = arg.sparse_complex_matrix_value ().sum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2746 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2747 else if (isextra) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2748 retval = arg.complex_array_value ().xsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2749 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2750 retval = arg.complex_array_value ().sum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2751 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2752 case btyp_float: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2753 if (isdouble || isextra) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2754 retval = arg.float_array_value ().dsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2755 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2756 retval = arg.float_array_value ().sum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2757 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2758 case btyp_float_complex: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2759 if (isdouble || isextra) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2760 retval = arg.float_complex_array_value ().dsum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2761 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2762 retval = arg.float_complex_array_value ().sum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2763 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2764 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2765 #define MAKE_INT_BRANCH(X) \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2766 case btyp_ ## X: \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2767 if (isnative) \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2768 retval = arg.X ## _array_value ().sum (dim); \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2769 else \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2770 retval = arg.X ## _array_value ().dsum (dim); \ |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2771 break |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2772 MAKE_INT_BRANCH (int8); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2773 MAKE_INT_BRANCH (int16); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2774 MAKE_INT_BRANCH (int32); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2775 MAKE_INT_BRANCH (int64); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2776 MAKE_INT_BRANCH (uint8); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2777 MAKE_INT_BRANCH (uint16); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2778 MAKE_INT_BRANCH (uint32); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2779 MAKE_INT_BRANCH (uint64); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2780 #undef MAKE_INT_BRANCH |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2781 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2782 case btyp_bool: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2783 if (arg.is_sparse_type ()) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2784 { |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2785 if (isnative) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2786 retval = arg.sparse_bool_matrix_value ().any (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2787 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2788 retval = arg.sparse_matrix_value ().sum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2789 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2790 else if (isnative) |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2791 retval = arg.bool_array_value ().any (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2792 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2793 retval = arg.bool_array_value ().sum (dim); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2794 break; |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2795 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2796 default: |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2797 gripe_wrong_type_arg ("sum", arg); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2798 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2799 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2800 } |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2801 else |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2802 print_usage (); |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2803 |
|
192d94cff6c1
improve sum & implement the 'extra' option, refactor some code
Jaroslav Hajek <highegg@gmail.com>
parents:
9706
diff
changeset
|
2804 return retval; |
| 523 | 2805 } |
| 2806 | |
| 7112 | 2807 /* |
| 2808 | |
| 2809 %!assert (sum([true,true]), 2) | |
| 2810 %!assert (sum([true,true],'native'), true) | |
| 2811 %!assert (sum(int8([127,10,-20])), 117); | |
| 2812 %!assert (sum(int8([127,10,-20]),'native'), int8(107)); | |
| 2813 | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2814 %!assert(sum ([1, 2, 3]), 6) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2815 %!assert(sum ([-1; -2; -3]), -6); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2816 %!assert(sum ([i, 2+i, -3+2i, 4]), 3+4i); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2817 %!assert(sum ([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i]), [2+2i, 4+4i, 6+6i]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2818 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2819 %!assert(sum (single([1, 2, 3])), single(6)) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2820 %!assert(sum (single([-1; -2; -3])), single(-6)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2821 %!assert(sum (single([i, 2+i, -3+2i, 4])), single(3+4i)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2822 %!assert(sum (single([1, 2, 3; i, 2i, 3i; 1+i, 2+2i, 3+3i])), single([2+2i, 4+4i, 6+6i])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2823 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2824 %!error <Invalid call to sum.*> sum (); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2825 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2826 %!assert (sum ([1, 2; 3, 4], 1), [4, 6]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2827 %!assert (sum ([1, 2; 3, 4], 2), [3; 7]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2828 %!assert (sum (zeros (1, 0)), 0); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2829 %!assert (sum (zeros (1, 0), 1), zeros(1, 0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2830 %!assert (sum (zeros (1, 0), 2), 0); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2831 %!assert (sum (zeros (0, 1)), 0); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2832 %!assert (sum (zeros (0, 1), 1), 0); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2833 %!assert (sum (zeros (0, 1), 2), zeros(0, 1)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2834 %!assert (sum (zeros (2, 0)), zeros(1, 0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2835 %!assert (sum (zeros (2, 0), 1), zeros(1, 0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2836 %!assert (sum (zeros (2, 0), 2), [0; 0]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2837 %!assert (sum (zeros (0, 2)), [0, 0]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2838 %!assert (sum (zeros (0, 2), 1), [0, 0]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2839 %!assert (sum (zeros (0, 2), 2), zeros(0, 1)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2840 %!assert (sum (zeros (2, 2, 0, 3)), zeros(1, 2, 0, 3)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2841 %!assert (sum (zeros (2, 2, 0, 3), 2), zeros(2, 1, 0, 3)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2842 %!assert (sum (zeros (2, 2, 0, 3), 3), zeros(2, 2, 1, 3)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2843 %!assert (sum (zeros (2, 2, 0, 3), 4), zeros(2, 2, 0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2844 %!assert (sum (zeros (2, 2, 0, 3), 7), zeros(2, 2, 0, 3)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2845 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2846 %!assert (sum (single([1, 2; 3, 4]), 1), single([4, 6])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2847 %!assert (sum (single([1, 2; 3, 4]), 2), single([3; 7])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2848 %!assert (sum (zeros (1, 0, 'single')), single(0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2849 %!assert (sum (zeros (1, 0, 'single'), 1), zeros(1, 0, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2850 %!assert (sum (zeros (1, 0, 'single'), 2), single(0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2851 %!assert (sum (zeros (0, 1, 'single')), single(0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2852 %!assert (sum (zeros (0, 1, 'single'), 1), single(0)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2853 %!assert (sum (zeros (0, 1, 'single'), 2), zeros(0, 1, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2854 %!assert (sum (zeros (2, 0, 'single')), zeros(1, 0, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2855 %!assert (sum (zeros (2, 0, 'single'), 1), zeros(1, 0, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2856 %!assert (sum (zeros (2, 0, 'single'), 2), single([0; 0])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2857 %!assert (sum (zeros (0, 2, 'single')), single([0, 0])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2858 %!assert (sum (zeros (0, 2, 'single'), 1), single([0, 0])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2859 %!assert (sum (zeros (0, 2, 'single'), 2), zeros(0, 1, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2860 %!assert (sum (zeros (2, 2, 0, 3, 'single')), zeros(1, 2, 0, 3, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2861 %!assert (sum (zeros (2, 2, 0, 3, 'single'), 2), zeros(2, 1, 0, 3, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2862 %!assert (sum (zeros (2, 2, 0, 3, 'single'), 3), zeros(2, 2, 1, 3, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2863 %!assert (sum (zeros (2, 2, 0, 3, 'single'), 4), zeros(2, 2, 0, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2864 %!assert (sum (zeros (2, 2, 0, 3, 'single'), 7), zeros(2, 2, 0, 3, 'single')); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2865 |
| 7112 | 2866 */ |
| 2867 | |
| 1957 | 2868 DEFUN (sumsq, args, , |
| 3428 | 2869 "-*- texinfo -*-\n\ |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
2870 @deftypefn {Built-in Function} {} sumsq (@var{x})\n\ |
|
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
2871 @deftypefnx {Built-in Function} {} sumsq (@var{x}, @var{dim})\n\ |
| 3723 | 2872 Sum of squares of elements along dimension @var{dim}. If @var{dim}\n\ |
|
9723
f426899f4b9c
fix reduction functions docstrings
Jaroslav Hajek <highegg@gmail.com>
parents:
9721
diff
changeset
|
2873 is omitted, it defaults to the first non-singleton dimension.\n\ |
| 5061 | 2874 \n\ |
| 2875 This function is conceptually equivalent to computing\n\ | |
| 3723 | 2876 @example\n\ |
| 2877 sum (x .* conj (x), dim)\n\ | |
| 2878 @end example\n\ | |
|
9163
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
2879 but it uses less memory and avoids calling @code{conj} if @var{x} is real.\n\ |
|
9cb0c21e97f7
Update section 17.4 (Sums and Products) of arith.txi
Rik <rdrider0-list@yahoo.com>
parents:
9155
diff
changeset
|
2880 @seealso{sum}\n\ |
| 3428 | 2881 @end deftypefn") |
| 523 | 2882 { |
| 3723 | 2883 DATA_REDUCTION (sumsq); |
| 523 | 2884 } |
| 2885 | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2886 /* |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2887 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2888 %!assert(sumsq ([1, 2, 3]), 14) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2889 %!assert(sumsq ([-1; -2; 4i]), 21); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2890 %!assert(sumsq ([1, 2, 3; 2, 3, 4; 4i, 6i, 2]), [21, 49, 29]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2891 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2892 %!assert(sumsq (single([1, 2, 3])), single(14)) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2893 %!assert(sumsq (single([-1; -2; 4i])), single(21)); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2894 %!assert(sumsq (single([1, 2, 3; 2, 3, 4; 4i, 6i, 2])), single([21, 49, 29])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2895 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2896 %!error <Invalid call to sumsq.*> sumsq (); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2897 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2898 %!assert (sumsq ([1, 2; 3, 4], 1), [10, 20]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2899 %!assert (sumsq ([1, 2; 3, 4], 2), [5; 25]); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2900 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2901 %!assert (sumsq (single([1, 2; 3, 4]), 1), single([10, 20])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2902 %!assert (sumsq (single([1, 2; 3, 4]), 2), single([5; 25])); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2903 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2904 */ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2905 |
| 6688 | 2906 DEFUN (islogical, args, , |
| 3428 | 2907 "-*- texinfo -*-\n\ |
| 7144 | 2908 @deftypefn {Built-in Function} {} islogical (@var{x})\n\ |
| 6688 | 2909 Return true if @var{x} is a logical object.\n\ |
| 3439 | 2910 @end deftypefn") |
| 3209 | 2911 { |
| 2912 octave_value retval; | |
| 2913 | |
| 2914 if (args.length () == 1) | |
| 3258 | 2915 retval = args(0).is_bool_type (); |
| 3209 | 2916 else |
| 5823 | 2917 print_usage (); |
| 3209 | 2918 |
| 2919 return retval; | |
| 2920 } | |
| 2921 | |
| 6688 | 2922 DEFALIAS (isbool, islogical); |
| 3209 | 2923 |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2924 /* |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2925 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2926 %!assert (islogical(true), true) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2927 %!assert (islogical(false), true) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2928 %!assert (islogical([true, false]), true) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2929 %!assert (islogical(1), false) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2930 %!assert (islogical(1i), false) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2931 %!assert (islogical([1,1]), false) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2932 %!assert (islogical(single(1)), false) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2933 %!assert (islogical(single(1i)), false) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2934 %!assert (islogical(single([1,1])), false) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2935 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2936 */ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2937 |
| 6223 | 2938 DEFUN (isinteger, args, , |
| 2939 "-*- texinfo -*-\n\ | |
| 6230 | 2940 @deftypefn {Built-in Function} {} isinteger (@var{x})\n\ |
| 6223 | 2941 Return true if @var{x} is an integer object (int8, uint8, int16, etc.).\n\ |
| 2942 Note that @code{isinteger (14)} is false because numeric constants in\n\ | |
|
8429
f34ab2b433e8
One word missing from int8 help string.
Francesco Potortì <pot@gnu.org>
parents:
8366
diff
changeset
|
2943 Octave are double precision floating point values.\n\ |
| 6223 | 2944 @seealso{isreal, isnumeric, class, isa}\n\ |
| 2945 @end deftypefn") | |
| 2946 { | |
| 2947 octave_value retval; | |
| 2948 | |
| 2949 if (args.length () == 1) | |
| 2950 retval = args(0).is_integer_type (); | |
| 2951 else | |
| 2952 print_usage (); | |
| 2953 | |
| 2954 return retval; | |
| 2955 } | |
| 2956 | |
| 4028 | 2957 DEFUN (iscomplex, args, , |
| 3428 | 2958 "-*- texinfo -*-\n\ |
| 4028 | 2959 @deftypefn {Built-in Function} {} iscomplex (@var{x})\n\ |
| 3428 | 2960 Return true if @var{x} is a complex-valued numeric object.\n\ |
| 2961 @end deftypefn") | |
| 3186 | 2962 { |
| 2963 octave_value retval; | |
| 2964 | |
| 2965 if (args.length () == 1) | |
| 3258 | 2966 retval = args(0).is_complex_type (); |
| 3186 | 2967 else |
| 5823 | 2968 print_usage (); |
| 3186 | 2969 |
| 2970 return retval; | |
| 2971 } | |
| 2972 | |
| 7576 | 2973 DEFUN (isfloat, args, , |
| 2974 "-*- texinfo -*-\n\ | |
| 2975 @deftypefn {Built-in Function} {} isfloat (@var{x})\n\ | |
| 2976 Return true if @var{x} is a floating-point numeric object.\n\ | |
| 2977 @end deftypefn") | |
| 2978 { | |
| 2979 octave_value retval; | |
| 2980 | |
| 2981 if (args.length () == 1) | |
| 2982 retval = args(0).is_float_type (); | |
| 2983 else | |
| 2984 print_usage (); | |
| 2985 | |
| 2986 return retval; | |
| 2987 } | |
| 2988 | |
| 5775 | 2989 // FIXME -- perhaps this should be implemented with an |
| 5476 | 2990 // octave_value member function? |
| 2991 | |
| 2992 DEFUN (complex, args, , | |
| 2993 "-*- texinfo -*-\n\ | |
|
9309
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
2994 @deftypefn {Built-in Function} {} complex (@var{x})\n\ |
| 5476 | 2995 @deftypefnx {Built-in Function} {} complex (@var{re}, @var{im})\n\ |
|
9309
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
2996 Return a complex result from real arguments. With 1 real argument @var{x},\n\ |
|
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
2997 return the complex result @code{@var{x} + 0i}. With 2 real arguments,\n\ |
|
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
2998 return the complex result @code{@var{re} + @var{im}}. @code{complex} can\n\ |
|
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
2999 often be more convenient than expressions such as @code{a + i*b}.\n\ |
|
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
3000 For example:\n\ |
|
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
3001 \n\ |
|
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
3002 @example\n\ |
|
9758
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
3003 @group\n\ |
|
9309
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
3004 complex ([1, 2], [3, 4])\n\ |
|
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
3005 @result{}\n\ |
|
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
3006 1 + 3i 2 + 4i\n\ |
|
9758
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
3007 @end group\n\ |
|
9309
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
3008 @end example\n\ |
|
fb8b8589dd46
Expand documentation for 'complex' function
Rik <rdrider0-list@yahoo.com>
parents:
9308
diff
changeset
|
3009 @seealso{real, imag, iscomplex}\n\ |
| 5476 | 3010 @end deftypefn") |
| 3011 { | |
| 3012 octave_value retval; | |
| 3013 | |
| 3014 int nargin = args.length (); | |
| 3015 | |
| 3016 if (nargin == 1) | |
| 3017 { | |
| 3018 octave_value arg = args(0); | |
| 3019 | |
| 3020 if (arg.is_complex_type ()) | |
| 3021 retval = arg; | |
| 3022 else | |
| 3023 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3024 if (arg.is_sparse_type ()) |
| 5476 | 3025 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3026 SparseComplexMatrix val = arg.sparse_complex_matrix_value (); |
| 5476 | 3027 |
| 3028 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3029 retval = octave_value (new octave_sparse_complex_matrix (val)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3030 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3031 else if (arg.is_single_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3032 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3033 if (arg.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3034 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3035 FloatComplex val = arg.float_complex_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3036 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3037 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3038 retval = octave_value (new octave_float_complex (val)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3039 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3040 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3041 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3042 FloatComplexNDArray val = arg.float_complex_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3043 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3044 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3045 retval = octave_value (new octave_float_complex_matrix (val)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3046 } |
| 5476 | 3047 } |
| 3048 else | |
| 3049 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3050 if (arg.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3051 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3052 Complex val = arg.complex_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3053 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3054 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3055 retval = octave_value (new octave_complex (val)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3056 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3057 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3058 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3059 ComplexNDArray val = arg.complex_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3060 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3061 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3062 retval = octave_value (new octave_complex_matrix (val)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3063 } |
| 5476 | 3064 } |
| 3065 | |
| 3066 if (error_state) | |
| 3067 error ("complex: invalid conversion"); | |
| 3068 } | |
| 3069 } | |
| 3070 else if (nargin == 2) | |
| 3071 { | |
| 3072 octave_value re = args(0); | |
| 3073 octave_value im = args(1); | |
| 3074 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3075 if (re.is_sparse_type () && im.is_sparse_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3076 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3077 const SparseMatrix re_val = re.sparse_matrix_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3078 const SparseMatrix im_val = im.sparse_matrix_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3079 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3080 if (!error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3081 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3082 if (re.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3083 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3084 SparseComplexMatrix result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3085 if (re_val.nnz () == 0) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3086 result = Complex(0, 1) * SparseComplexMatrix (im_val); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3087 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3088 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3089 result = SparseComplexMatrix (im_val.dims (), re_val (0)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3090 octave_idx_type nr = im_val.rows (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3091 octave_idx_type nc = im_val.cols (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3092 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3093 for (octave_idx_type j = 0; j < nc; j++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3094 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3095 octave_idx_type off = j * nr; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3096 for (octave_idx_type i = im_val.cidx(j); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3097 i < im_val.cidx(j + 1); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3098 result.data (im_val.ridx(i) + off) = |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3099 result.data (im_val.ridx(i) + off) + |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3100 Complex (0, im_val.data (i)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3101 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3102 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3103 retval = octave_value (new octave_sparse_complex_matrix (result)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3104 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3105 else if (im.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3106 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3107 SparseComplexMatrix result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3108 if (im_val.nnz () == 0) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3109 result = SparseComplexMatrix (re_val); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3110 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3111 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3112 result = SparseComplexMatrix (re_val.rows(), re_val.cols(), Complex(0, im_val (0))); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3113 octave_idx_type nr = re_val.rows (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3114 octave_idx_type nc = re_val.cols (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3115 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3116 for (octave_idx_type j = 0; j < nc; j++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3117 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3118 octave_idx_type off = j * nr; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3119 for (octave_idx_type i = re_val.cidx(j); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3120 i < re_val.cidx(j + 1); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3121 result.data (re_val.ridx(i) + off) = |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3122 result.data (re_val.ridx(i) + off) + |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3123 re_val.data (i); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3124 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3125 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3126 retval = octave_value (new octave_sparse_complex_matrix (result)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3127 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3128 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3129 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3130 if (re_val.dims () == im_val.dims ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3131 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3132 SparseComplexMatrix result = SparseComplexMatrix(re_val) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3133 + Complex(0, 1) * SparseComplexMatrix (im_val); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3134 retval = octave_value (new octave_sparse_complex_matrix (result)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3135 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3136 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3137 error ("complex: dimension mismatch"); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3138 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3139 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3140 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3141 else if (re.is_single_type () || im.is_single_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3142 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3143 if (re.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3144 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3145 float re_val = re.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3146 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3147 if (im.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3148 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3149 float im_val = im.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3150 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3151 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3152 retval = octave_value (new octave_float_complex (FloatComplex (re_val, im_val))); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3153 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3154 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3155 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3156 const FloatNDArray im_val = im.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3157 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3158 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3159 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3160 FloatComplexNDArray result (im_val.dims (), FloatComplex ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3161 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3162 for (octave_idx_type i = 0; i < im_val.numel (); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3163 result.xelem (i) = FloatComplex (re_val, im_val(i)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3164 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3165 retval = octave_value (new octave_float_complex_matrix (result)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3166 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3167 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3168 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3169 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3170 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3171 const FloatNDArray re_val = re.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3172 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3173 if (im.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3174 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3175 float im_val = im.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3176 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3177 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3178 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3179 FloatComplexNDArray result (re_val.dims (), FloatComplex ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3180 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3181 for (octave_idx_type i = 0; i < re_val.numel (); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3182 result.xelem (i) = FloatComplex (re_val(i), im_val); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3183 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3184 retval = octave_value (new octave_float_complex_matrix (result)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3185 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3186 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3187 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3188 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3189 const FloatNDArray im_val = im.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3190 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3191 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3192 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3193 if (re_val.dims () == im_val.dims ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3194 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3195 FloatComplexNDArray result (re_val.dims (), FloatComplex ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3196 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3197 for (octave_idx_type i = 0; i < re_val.numel (); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3198 result.xelem (i) = FloatComplex (re_val(i), im_val(i)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3199 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3200 retval = octave_value (new octave_float_complex_matrix (result)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3201 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3202 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3203 error ("complex: dimension mismatch"); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3204 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3205 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3206 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3207 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3208 else if (re.numel () == 1) |
| 5476 | 3209 { |
| 3210 double re_val = re.double_value (); | |
| 3211 | |
| 3212 if (im.numel () == 1) | |
| 3213 { | |
| 3214 double im_val = im.double_value (); | |
| 3215 | |
| 3216 if (! error_state) | |
| 3217 retval = octave_value (new octave_complex (Complex (re_val, im_val))); | |
| 3218 } | |
| 3219 else | |
| 3220 { | |
| 3221 const NDArray im_val = im.array_value (); | |
| 3222 | |
| 3223 if (! error_state) | |
| 3224 { | |
| 3225 ComplexNDArray result (im_val.dims (), Complex ()); | |
| 3226 | |
| 3227 for (octave_idx_type i = 0; i < im_val.numel (); i++) | |
| 3228 result.xelem (i) = Complex (re_val, im_val(i)); | |
| 3229 | |
| 3230 retval = octave_value (new octave_complex_matrix (result)); | |
| 3231 } | |
| 3232 } | |
| 3233 } | |
| 3234 else | |
| 3235 { | |
| 3236 const NDArray re_val = re.array_value (); | |
| 3237 | |
| 3238 if (im.numel () == 1) | |
| 3239 { | |
| 3240 double im_val = im.double_value (); | |
| 3241 | |
| 3242 if (! error_state) | |
| 3243 { | |
| 3244 ComplexNDArray result (re_val.dims (), Complex ()); | |
| 3245 | |
| 3246 for (octave_idx_type i = 0; i < re_val.numel (); i++) | |
| 3247 result.xelem (i) = Complex (re_val(i), im_val); | |
| 3248 | |
| 3249 retval = octave_value (new octave_complex_matrix (result)); | |
| 3250 } | |
| 3251 } | |
| 3252 else | |
| 3253 { | |
| 3254 const NDArray im_val = im.array_value (); | |
| 3255 | |
| 3256 if (! error_state) | |
| 3257 { | |
| 3258 if (re_val.dims () == im_val.dims ()) | |
| 3259 { | |
| 3260 ComplexNDArray result (re_val.dims (), Complex ()); | |
| 3261 | |
| 3262 for (octave_idx_type i = 0; i < re_val.numel (); i++) | |
| 3263 result.xelem (i) = Complex (re_val(i), im_val(i)); | |
| 3264 | |
| 3265 retval = octave_value (new octave_complex_matrix (result)); | |
| 3266 } | |
| 3267 else | |
| 3268 error ("complex: dimension mismatch"); | |
| 3269 } | |
| 3270 } | |
| 3271 } | |
| 3272 | |
| 3273 if (error_state) | |
| 3274 error ("complex: invalid conversion"); | |
| 3275 } | |
| 3276 else | |
| 5823 | 3277 print_usage (); |
| 5476 | 3278 |
| 3279 return retval; | |
| 3280 } | |
| 3281 | |
| 3258 | 3282 DEFUN (isreal, args, , |
| 3428 | 3283 "-*- texinfo -*-\n\ |
| 3284 @deftypefn {Built-in Function} {} isreal (@var{x})\n\ | |
| 3285 Return true if @var{x} is a real-valued numeric object.\n\ | |
| 3286 @end deftypefn") | |
| 3258 | 3287 { |
| 3288 octave_value retval; | |
| 3289 | |
| 3290 if (args.length () == 1) | |
| 3291 retval = args(0).is_real_type (); | |
| 3292 else | |
| 5823 | 3293 print_usage (); |
| 3258 | 3294 |
| 3295 return retval; | |
| 3296 } | |
| 3297 | |
| 3202 | 3298 DEFUN (isempty, args, , |
| 3373 | 3299 "-*- texinfo -*-\n\ |
| 3300 @deftypefn {Built-in Function} {} isempty (@var{a})\n\ | |
| 3301 Return 1 if @var{a} is an empty matrix (either the number of rows, or\n\ | |
| 3302 the number of columns, or both are zero). Otherwise, return 0.\n\ | |
| 3303 @end deftypefn") | |
| 3202 | 3304 { |
| 4233 | 3305 octave_value retval = false; |
| 3202 | 3306 |
| 3307 if (args.length () == 1) | |
| 4559 | 3308 retval = args(0).is_empty (); |
| 3202 | 3309 else |
| 5823 | 3310 print_usage (); |
| 3202 | 3311 |
| 3312 return retval; | |
| 3313 } | |
| 3314 | |
| 3206 | 3315 DEFUN (isnumeric, args, , |
| 3428 | 3316 "-*- texinfo -*-\n\ |
| 3317 @deftypefn {Built-in Function} {} isnumeric (@var{x})\n\ | |
| 3318 Return nonzero if @var{x} is a numeric object.\n\ | |
| 3319 @end deftypefn") | |
| 3206 | 3320 { |
| 3321 octave_value retval; | |
| 3322 | |
| 3323 if (args.length () == 1) | |
| 3258 | 3324 retval = args(0).is_numeric_type (); |
| 3206 | 3325 else |
| 5823 | 3326 print_usage (); |
| 3206 | 3327 |
| 3328 return retval; | |
| 3329 } | |
| 3330 | |
| 4028 | 3331 DEFUN (islist, args, , |
| 3526 | 3332 "-*- texinfo -*-\n\ |
| 4028 | 3333 @deftypefn {Built-in Function} {} islist (@var{x})\n\ |
| 3428 | 3334 Return nonzero if @var{x} is a list.\n\ |
| 3335 @end deftypefn") | |
| 3204 | 3336 { |
| 3337 octave_value retval; | |
| 3338 | |
| 3339 if (args.length () == 1) | |
| 3258 | 3340 retval = args(0).is_list (); |
| 3204 | 3341 else |
| 5823 | 3342 print_usage (); |
| 3204 | 3343 |
| 3344 return retval; | |
| 3345 } | |
| 3346 | |
| 4028 | 3347 DEFUN (ismatrix, args, , |
| 3321 | 3348 "-*- texinfo -*-\n\ |
| 4028 | 3349 @deftypefn {Built-in Function} {} ismatrix (@var{a})\n\ |
| 3321 | 3350 Return 1 if @var{a} is a matrix. Otherwise, return 0.\n\ |
| 3333 | 3351 @end deftypefn") |
| 3202 | 3352 { |
| 4233 | 3353 octave_value retval = false; |
| 3202 | 3354 |
| 3355 if (args.length () == 1) | |
| 3356 { | |
| 3357 octave_value arg = args(0); | |
| 3358 | |
| 3212 | 3359 if (arg.is_scalar_type () || arg.is_range ()) |
| 4233 | 3360 retval = true; |
| 3202 | 3361 else if (arg.is_matrix_type ()) |
| 4233 | 3362 retval = (arg.rows () >= 1 && arg.columns () >= 1); |
| 3202 | 3363 } |
| 3364 else | |
| 5823 | 3365 print_usage (); |
| 3202 | 3366 |
| 3367 return retval; | |
| 3368 } | |
| 3369 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3370 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3371 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3372 %!assert(ismatrix (1)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3373 %!assert(ismatrix ([1, 2, 3])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3374 %!assert(ismatrix ([1, 2; 3, 4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3375 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3376 %% Yes, this is right, ismatrix() checks for non-empty matrices. |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3377 %!assert(ismatrix ([]), false); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3378 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3379 %!assert(ismatrix (single(1))); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3380 %!assert(ismatrix (single([1, 2, 3]))); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3381 %!assert(ismatrix (single([1, 2; 3, 4]))); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3382 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3383 %% Yes, this is right, ismatrix() checks for non-empty matrices. |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3384 %!assert(ismatrix (single([])), false); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3385 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3386 %!assert(ismatrix ("t"), false); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3387 %!assert(ismatrix ("test"), false); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3388 %!assert(ismatrix (["test"; "ing"]), false); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3389 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3390 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3391 %! s.a = 1; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3392 %! assert(ismatrix (s), false); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3393 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3394 %!error <Invalid call to ismatrix.*> ismatrix (); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3395 %!error <Invalid call to ismatrix.*> ismatrix ([1, 2; 3, 4], 2); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3396 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3397 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3398 |
| 3354 | 3399 static octave_value |
| 5747 | 3400 fill_matrix (const octave_value_list& args, int val, const char *fcn) |
| 523 | 3401 { |
| 3354 | 3402 octave_value retval; |
| 523 | 3403 |
| 3404 int nargin = args.length (); | |
| 3405 | |
| 4946 | 3406 oct_data_conv::data_type dt = oct_data_conv::dt_double; |
| 4481 | 3407 |
| 4946 | 3408 dim_vector dims (1, 1); |
| 4481 | 3409 |
| 3410 if (nargin > 0 && args(nargin-1).is_string ()) | |
| 3411 { | |
| 4946 | 3412 std::string nm = args(nargin-1).string_value (); |
| 4481 | 3413 nargin--; |
| 3414 | |
| 4946 | 3415 dt = oct_data_conv::string_to_data_type (nm); |
| 3416 | |
| 3417 if (error_state) | |
| 3418 return retval; | |
| 4481 | 3419 } |
| 3420 | |
| 523 | 3421 switch (nargin) |
| 3422 { | |
| 712 | 3423 case 0: |
| 3424 break; | |
| 777 | 3425 |
| 610 | 3426 case 1: |
| 4481 | 3427 get_dimensions (args(0), fcn, dims); |
| 610 | 3428 break; |
| 777 | 3429 |
| 4563 | 3430 default: |
| 3431 { | |
| 3432 dims.resize (nargin); | |
| 4481 | 3433 |
| 4563 | 3434 for (int i = 0; i < nargin; i++) |
| 3435 { | |
| 6133 | 3436 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value (); |
| 4481 | 3437 |
| 4563 | 3438 if (error_state) |
| 3439 { | |
| 4732 | 3440 error ("%s: expecting scalar integer arguments", fcn); |
| 4563 | 3441 break; |
| 3442 } | |
| 3443 } | |
| 3444 } | |
| 3445 break; | |
| 4481 | 3446 } |
| 3447 | |
| 3448 if (! error_state) | |
| 3449 { | |
| 4946 | 3450 dims.chop_trailing_singletons (); |
| 4565 | 3451 |
| 4481 | 3452 check_dimensions (dims, fcn); |
| 3354 | 3453 |
| 5775 | 3454 // FIXME -- perhaps this should be made extensible by |
| 4946 | 3455 // using the class name to lookup a function to call to create |
| 3456 // the new value. | |
| 3457 | |
| 3458 // Note that automatic narrowing will handle conversion from | |
| 3459 // NDArray to scalar. | |
| 3460 | |
| 4481 | 3461 if (! error_state) |
| 3462 { | |
| 4946 | 3463 switch (dt) |
| 3464 { | |
| 3465 case oct_data_conv::dt_int8: | |
| 3466 retval = int8NDArray (dims, val); | |
| 3467 break; | |
| 4481 | 3468 |
| 4946 | 3469 case oct_data_conv::dt_uint8: |
| 3470 retval = uint8NDArray (dims, val); | |
| 3471 break; | |
| 3472 | |
| 3473 case oct_data_conv::dt_int16: | |
| 3474 retval = int16NDArray (dims, val); | |
| 3475 break; | |
| 3476 | |
| 3477 case oct_data_conv::dt_uint16: | |
| 3478 retval = uint16NDArray (dims, val); | |
| 3479 break; | |
| 3480 | |
| 3481 case oct_data_conv::dt_int32: | |
| 3482 retval = int32NDArray (dims, val); | |
| 3483 break; | |
| 777 | 3484 |
| 4946 | 3485 case oct_data_conv::dt_uint32: |
| 3486 retval = uint32NDArray (dims, val); | |
| 3487 break; | |
| 3488 | |
| 3489 case oct_data_conv::dt_int64: | |
| 3490 retval = int64NDArray (dims, val); | |
| 3491 break; | |
| 4481 | 3492 |
| 4946 | 3493 case oct_data_conv::dt_uint64: |
| 3494 retval = uint64NDArray (dims, val); | |
| 3495 break; | |
| 4481 | 3496 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3497 case oct_data_conv::dt_single: |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3498 retval = FloatNDArray (dims, val); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3499 break; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3500 |
| 4946 | 3501 case oct_data_conv::dt_double: |
|
8972
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8947
diff
changeset
|
3502 { |
|
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8947
diff
changeset
|
3503 if (val == 1 && dims.length () == 2 && dims (0) == 1) |
|
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8947
diff
changeset
|
3504 retval = Range (1.0, 0.0, dims (1)); // packed form |
|
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8947
diff
changeset
|
3505 else |
|
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8947
diff
changeset
|
3506 retval = NDArray (dims, val); |
|
5fa53d1b6247
more indexing optimizations
Jaroslav Hajek <highegg@gmail.com>
parents:
8947
diff
changeset
|
3507 } |
| 4946 | 3508 break; |
| 3509 | |
| 4986 | 3510 case oct_data_conv::dt_logical: |
| 3511 retval = boolNDArray (dims, val); | |
| 3512 break; | |
| 3513 | |
| 4946 | 3514 default: |
| 3515 error ("%s: invalid class name", fcn); | |
| 3516 break; | |
| 4481 | 3517 } |
| 3518 } | |
| 523 | 3519 } |
| 3520 | |
| 3521 return retval; | |
| 3522 } | |
| 3523 | |
| 5747 | 3524 static octave_value |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3525 fill_matrix (const octave_value_list& args, double val, float fval, |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3526 const char *fcn) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3527 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3528 octave_value retval; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3529 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3530 int nargin = args.length (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3531 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3532 oct_data_conv::data_type dt = oct_data_conv::dt_double; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3533 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3534 dim_vector dims (1, 1); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3535 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3536 if (nargin > 0 && args(nargin-1).is_string ()) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3537 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3538 std::string nm = args(nargin-1).string_value (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3539 nargin--; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3540 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3541 dt = oct_data_conv::string_to_data_type (nm); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3542 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3543 if (error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3544 return retval; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3545 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3546 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3547 switch (nargin) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3548 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3549 case 0: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3550 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3551 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3552 case 1: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3553 get_dimensions (args(0), fcn, dims); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3554 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3555 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3556 default: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3557 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3558 dims.resize (nargin); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3559 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3560 for (int i = 0; i < nargin; i++) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3561 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3562 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3563 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3564 if (error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3565 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3566 error ("%s: expecting scalar integer arguments", fcn); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3567 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3568 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3569 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3570 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3571 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3572 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3573 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3574 if (! error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3575 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3576 dims.chop_trailing_singletons (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3577 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3578 check_dimensions (dims, fcn); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3579 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3580 // Note that automatic narrowing will handle conversion from |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3581 // NDArray to scalar. |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3582 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3583 if (! error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3584 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3585 switch (dt) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3586 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3587 case oct_data_conv::dt_single: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3588 retval = FloatNDArray (dims, fval); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3589 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3590 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3591 case oct_data_conv::dt_double: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3592 retval = NDArray (dims, val); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3593 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3594 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3595 default: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3596 error ("%s: invalid class name", fcn); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3597 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3598 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3599 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3600 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3601 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3602 return retval; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3603 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3604 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3605 static octave_value |
| 5747 | 3606 fill_matrix (const octave_value_list& args, double val, const char *fcn) |
| 3607 { | |
| 3608 octave_value retval; | |
| 3609 | |
| 3610 int nargin = args.length (); | |
| 3611 | |
| 3612 oct_data_conv::data_type dt = oct_data_conv::dt_double; | |
| 3613 | |
| 3614 dim_vector dims (1, 1); | |
| 3615 | |
| 3616 if (nargin > 0 && args(nargin-1).is_string ()) | |
| 3617 { | |
| 3618 std::string nm = args(nargin-1).string_value (); | |
| 3619 nargin--; | |
| 3620 | |
| 3621 dt = oct_data_conv::string_to_data_type (nm); | |
| 3622 | |
| 3623 if (error_state) | |
| 3624 return retval; | |
| 3625 } | |
| 3626 | |
| 3627 switch (nargin) | |
| 3628 { | |
| 3629 case 0: | |
| 3630 break; | |
| 3631 | |
| 3632 case 1: | |
| 3633 get_dimensions (args(0), fcn, dims); | |
| 3634 break; | |
| 3635 | |
| 3636 default: | |
| 3637 { | |
| 3638 dims.resize (nargin); | |
| 3639 | |
| 3640 for (int i = 0; i < nargin; i++) | |
| 3641 { | |
| 6133 | 3642 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value (); |
| 5747 | 3643 |
| 3644 if (error_state) | |
| 3645 { | |
| 3646 error ("%s: expecting scalar integer arguments", fcn); | |
| 3647 break; | |
| 3648 } | |
| 3649 } | |
| 3650 } | |
| 3651 break; | |
| 3652 } | |
| 3653 | |
| 3654 if (! error_state) | |
| 3655 { | |
| 3656 dims.chop_trailing_singletons (); | |
| 3657 | |
| 3658 check_dimensions (dims, fcn); | |
| 3659 | |
| 3660 // Note that automatic narrowing will handle conversion from | |
| 3661 // NDArray to scalar. | |
| 3662 | |
| 3663 if (! error_state) | |
| 3664 { | |
| 3665 switch (dt) | |
| 3666 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3667 case oct_data_conv::dt_single: |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3668 retval = FloatNDArray (dims, static_cast <float> (val)); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3669 break; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3670 |
| 5747 | 3671 case oct_data_conv::dt_double: |
| 3672 retval = NDArray (dims, val); | |
| 3673 break; | |
| 3674 | |
| 3675 default: | |
| 3676 error ("%s: invalid class name", fcn); | |
| 3677 break; | |
| 3678 } | |
| 3679 } | |
| 3680 } | |
| 3681 | |
| 3682 return retval; | |
| 3683 } | |
| 3684 | |
| 3685 static octave_value | |
| 3686 fill_matrix (const octave_value_list& args, const Complex& val, | |
| 3687 const char *fcn) | |
| 3688 { | |
| 3689 octave_value retval; | |
| 3690 | |
| 3691 int nargin = args.length (); | |
| 3692 | |
| 3693 oct_data_conv::data_type dt = oct_data_conv::dt_double; | |
| 3694 | |
| 3695 dim_vector dims (1, 1); | |
| 3696 | |
| 3697 if (nargin > 0 && args(nargin-1).is_string ()) | |
| 3698 { | |
| 3699 std::string nm = args(nargin-1).string_value (); | |
| 3700 nargin--; | |
| 3701 | |
| 3702 dt = oct_data_conv::string_to_data_type (nm); | |
| 3703 | |
| 3704 if (error_state) | |
| 3705 return retval; | |
| 3706 } | |
| 3707 | |
| 3708 switch (nargin) | |
| 3709 { | |
| 3710 case 0: | |
| 3711 break; | |
| 3712 | |
| 3713 case 1: | |
| 3714 get_dimensions (args(0), fcn, dims); | |
| 3715 break; | |
| 3716 | |
| 3717 default: | |
| 3718 { | |
| 3719 dims.resize (nargin); | |
| 3720 | |
| 3721 for (int i = 0; i < nargin; i++) | |
| 3722 { | |
| 6133 | 3723 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value (); |
| 5747 | 3724 |
| 3725 if (error_state) | |
| 3726 { | |
| 3727 error ("%s: expecting scalar integer arguments", fcn); | |
| 3728 break; | |
| 3729 } | |
| 3730 } | |
| 3731 } | |
| 3732 break; | |
| 3733 } | |
| 3734 | |
| 3735 if (! error_state) | |
| 3736 { | |
| 3737 dims.chop_trailing_singletons (); | |
| 3738 | |
| 3739 check_dimensions (dims, fcn); | |
| 3740 | |
| 3741 // Note that automatic narrowing will handle conversion from | |
| 3742 // NDArray to scalar. | |
| 3743 | |
| 3744 if (! error_state) | |
| 3745 { | |
| 3746 switch (dt) | |
| 3747 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3748 case oct_data_conv::dt_single: |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3749 retval = FloatComplexNDArray (dims, static_cast<FloatComplex> (val)); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3750 break; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3751 |
| 5747 | 3752 case oct_data_conv::dt_double: |
| 3753 retval = ComplexNDArray (dims, val); | |
| 3754 break; | |
| 3755 | |
| 3756 default: | |
| 3757 error ("%s: invalid class name", fcn); | |
| 3758 break; | |
| 3759 } | |
| 3760 } | |
| 3761 } | |
| 3762 | |
| 3763 return retval; | |
| 3764 } | |
| 3765 | |
| 3766 static octave_value | |
| 3767 fill_matrix (const octave_value_list& args, bool val, const char *fcn) | |
| 3768 { | |
| 3769 octave_value retval; | |
| 3770 | |
| 3771 int nargin = args.length (); | |
| 3772 | |
| 3773 dim_vector dims (1, 1); | |
| 3774 | |
| 3775 switch (nargin) | |
| 3776 { | |
| 3777 case 0: | |
| 3778 break; | |
| 3779 | |
| 3780 case 1: | |
| 3781 get_dimensions (args(0), fcn, dims); | |
| 3782 break; | |
| 3783 | |
| 3784 default: | |
| 3785 { | |
| 3786 dims.resize (nargin); | |
| 3787 | |
| 3788 for (int i = 0; i < nargin; i++) | |
| 3789 { | |
| 6133 | 3790 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value (); |
| 5747 | 3791 |
| 3792 if (error_state) | |
| 3793 { | |
| 3794 error ("%s: expecting scalar integer arguments", fcn); | |
| 3795 break; | |
| 3796 } | |
| 3797 } | |
| 3798 } | |
| 3799 break; | |
| 3800 } | |
| 3801 | |
| 3802 if (! error_state) | |
| 3803 { | |
| 3804 dims.chop_trailing_singletons (); | |
| 3805 | |
| 3806 check_dimensions (dims, fcn); | |
| 3807 | |
| 3808 // Note that automatic narrowing will handle conversion from | |
| 3809 // NDArray to scalar. | |
| 3810 | |
| 3811 if (! error_state) | |
| 3812 retval = boolNDArray (dims, val); | |
| 3813 } | |
| 3814 | |
| 3815 return retval; | |
| 3816 } | |
| 3817 | |
| 3354 | 3818 DEFUN (ones, args, , |
| 3369 | 3819 "-*- texinfo -*-\n\ |
| 3820 @deftypefn {Built-in Function} {} ones (@var{x})\n\ | |
| 3821 @deftypefnx {Built-in Function} {} ones (@var{n}, @var{m})\n\ | |
| 4948 | 3822 @deftypefnx {Built-in Function} {} ones (@var{n}, @var{m}, @var{k}, @dots{})\n\ |
| 3823 @deftypefnx {Built-in Function} {} ones (@dots{}, @var{class})\n\ | |
| 4481 | 3824 Return a matrix or N-dimensional array whose elements are all 1.\n\ |
|
9428
b317debeb828
data.cc (Fones, Fzeros, Ftrue, Ffalse): update docstring
John W. Eaton <jwe@octave.org>
parents:
9351
diff
changeset
|
3825 If invoked with a single scalar integer argument, return a square\n\ |
|
b317debeb828
data.cc (Fones, Fzeros, Ftrue, Ffalse): update docstring
John W. Eaton <jwe@octave.org>
parents:
9351
diff
changeset
|
3826 matrix of the specified size. If invoked with two or more scalar\n\ |
|
b317debeb828
data.cc (Fones, Fzeros, Ftrue, Ffalse): update docstring
John W. Eaton <jwe@octave.org>
parents:
9351
diff
changeset
|
3827 integer arguments, or a vector of integer values, return an array with\n\ |
|
b317debeb828
data.cc (Fones, Fzeros, Ftrue, Ffalse): update docstring
John W. Eaton <jwe@octave.org>
parents:
9351
diff
changeset
|
3828 given dimensions.\n\ |
| 3369 | 3829 \n\ |
| 3830 If you need to create a matrix whose values are all the same, you should\n\ | |
| 3831 use an expression like\n\ | |
| 3832 \n\ | |
| 3833 @example\n\ | |
| 3834 val_matrix = val * ones (n, m)\n\ | |
| 3835 @end example\n\ | |
| 4945 | 3836 \n\ |
| 3837 The optional argument @var{class}, allows @code{ones} to return an array of\n\ | |
| 5747 | 3838 the specified type, for example\n\ |
| 4945 | 3839 \n\ |
| 3840 @example\n\ | |
| 3841 val = ones (n,m, \"uint8\")\n\ | |
| 3842 @end example\n\ | |
| 3369 | 3843 @end deftypefn") |
| 523 | 3844 { |
| 5747 | 3845 return fill_matrix (args, 1, "ones"); |
| 523 | 3846 } |
| 3847 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3848 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3849 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3850 %!assert(ones (3), [1, 1, 1; 1, 1, 1; 1, 1, 1]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3851 %!assert(ones (2, 3), [1, 1, 1; 1, 1, 1]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3852 %!assert(ones (3, 2), [1, 1; 1, 1; 1, 1]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3853 %!assert(size (ones (3, 4, 5)), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3854 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3855 %!assert(ones (3,'single'), single([1, 1, 1; 1, 1, 1; 1, 1, 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3856 %!assert(ones (2, 3,'single'), single([1, 1, 1; 1, 1, 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3857 %!assert(ones (3, 2,'single'), single([1, 1; 1, 1; 1, 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3858 %!assert(size (ones (3, 4, 5, 'single')), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3859 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3860 %!assert(ones (3,'int8'), int8([1, 1, 1; 1, 1, 1; 1, 1, 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3861 %!assert(ones (2, 3,'int8'), int8([1, 1, 1; 1, 1, 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3862 %!assert(ones (3, 2,'int8'), int8([1, 1; 1, 1; 1, 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3863 %!assert(size (ones (3, 4, 5, 'int8')), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3864 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3865 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3866 |
| 3354 | 3867 DEFUN (zeros, args, , |
| 3369 | 3868 "-*- texinfo -*-\n\ |
| 3869 @deftypefn {Built-in Function} {} zeros (@var{x})\n\ | |
| 3870 @deftypefnx {Built-in Function} {} zeros (@var{n}, @var{m})\n\ | |
| 4948 | 3871 @deftypefnx {Built-in Function} {} zeros (@var{n}, @var{m}, @var{k}, @dots{})\n\ |
| 3872 @deftypefnx {Built-in Function} {} zeros (@dots{}, @var{class})\n\ | |
| 4481 | 3873 Return a matrix or N-dimensional array whose elements are all 0.\n\ |
|
9428
b317debeb828
data.cc (Fones, Fzeros, Ftrue, Ffalse): update docstring
John W. Eaton <jwe@octave.org>
parents:
9351
diff
changeset
|
3874 The arguments are handled the same as the arguments for @code{ones}.\n\ |
| 4945 | 3875 \n\ |
| 3876 The optional argument @var{class}, allows @code{zeros} to return an array of\n\ | |
| 5747 | 3877 the specified type, for example\n\ |
| 4945 | 3878 \n\ |
| 3879 @example\n\ | |
| 3880 val = zeros (n,m, \"uint8\")\n\ | |
| 3881 @end example\n\ | |
| 3369 | 3882 @end deftypefn") |
| 523 | 3883 { |
| 5747 | 3884 return fill_matrix (args, 0, "zeros"); |
| 3885 } | |
| 3886 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3887 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3888 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3889 %!assert(zeros (3), [0, 0, 0; 0, 0, 0; 0, 0, 0]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3890 %!assert(zeros (2, 3), [0, 0, 0; 0, 0, 0]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3891 %!assert(zeros (3, 2), [0, 0; 0, 0; 0, 0]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3892 %!assert(size (zeros (3, 4, 5)), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3893 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3894 %!assert(zeros (3,'single'), single([0, 0, 0; 0, 0, 0; 0, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3895 %!assert(zeros (2, 3,'single'), single([0, 0, 0; 0, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3896 %!assert(zeros (3, 2,'single'), single([0, 0; 0, 0; 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3897 %!assert(size (zeros (3, 4, 5, 'single')), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3898 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3899 %!assert(zeros (3,'int8'), int8([0, 0, 0; 0, 0, 0; 0, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3900 %!assert(zeros (2, 3,'int8'), int8([0, 0, 0; 0, 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3901 %!assert(zeros (3, 2,'int8'), int8([0, 0; 0, 0; 0, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3902 %!assert(size (zeros (3, 4, 5, 'int8')), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3903 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3904 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3905 |
| 5747 | 3906 DEFUN (Inf, args, , |
| 3907 "-*- texinfo -*-\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3908 @deftypefn {Built-in Function} {} Inf\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3909 @deftypefnx {Built-in Function} {} Inf (@var{n})\n\ |
| 5747 | 3910 @deftypefnx {Built-in Function} {} Inf (@var{n}, @var{m})\n\ |
| 3911 @deftypefnx {Built-in Function} {} Inf (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3912 @deftypefnx {Built-in Function} {} Inf (@dots{}, @var{class})\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3913 Return a scalar, matrix or N-dimensional array whose elements are all equal\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3914 to the IEEE representation for positive infinity.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3915 \n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3916 Infinity is produced when results are too large to be represented using the\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3917 the IEEE floating point format for numbers. Two common examples which\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3918 produce infinity are division by zero and overflow.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3919 @example\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3920 @group\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3921 [1/0 e^800]\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3922 @result{}\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3923 Inf Inf\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3924 @end group\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3925 @end example\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3926 \n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3927 When called with no arguments, return a scalar with the value @samp{Inf}.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3928 When called with a single argument, return a square matrix with the dimension\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3929 specified. When called with more than one scalar argument the first two\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3930 arguments are taken as the number of rows and columns and any further\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3931 arguments specify additional matrix dimensions.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3932 The optional argument @var{class} specifies the return type and may be\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3933 either \"double\" or \"single\".\n\ |
|
9308
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
3934 @seealso{isinf}\n\ |
| 5747 | 3935 @end deftypefn") |
| 3936 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3937 return fill_matrix (args, lo_ieee_inf_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3938 lo_ieee_float_inf_value (), "Inf"); |
| 5747 | 3939 } |
| 3940 | |
| 3941 DEFALIAS (inf, Inf); | |
| 3942 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3943 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3944 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3945 %!assert(inf (3), [Inf, Inf, Inf; Inf, Inf, Inf; Inf, Inf, Inf]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3946 %!assert(inf (2, 3), [Inf, Inf, Inf; Inf, Inf, Inf]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3947 %!assert(inf (3, 2), [Inf, Inf; Inf, Inf; Inf, Inf]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3948 %!assert(size (inf (3, 4, 5)), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3949 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3950 %!assert(inf (3,'single'), single([Inf, Inf, Inf; Inf, Inf, Inf; Inf, Inf, Inf])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3951 %!assert(inf (2, 3,'single'), single([Inf, Inf, Inf; Inf, Inf, Inf])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3952 %!assert(inf (3, 2,'single'), single([Inf, Inf; Inf, Inf; Inf, Inf])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3953 %!assert(size (inf (3, 4, 5, 'single')), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3954 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3955 %!error(inf (3,'int8')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3956 %!error(inf (2, 3,'int8')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3957 %!error(inf (3, 2,'int8')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3958 %!error(inf (3, 4, 5, 'int8')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3959 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3960 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3961 |
| 5747 | 3962 DEFUN (NaN, args, , |
| 3963 "-*- texinfo -*-\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3964 @deftypefn {Built-in Function} {} NaN\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3965 @deftypefnx {Built-in Function} {} NaN (@var{n})\n\ |
| 5747 | 3966 @deftypefnx {Built-in Function} {} NaN (@var{n}, @var{m})\n\ |
| 3967 @deftypefnx {Built-in Function} {} NaN (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3968 @deftypefnx {Built-in Function} {} NaN (@dots{}, @var{class})\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3969 Return a scalar, matrix, or N-dimensional array whose elements are all equal\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3970 to the IEEE symbol NaN (Not a Number).\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3971 NaN is the result of operations which do not produce a well defined numerical\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3972 result. Common operations which produce a NaN are arithmetic with infinity\n\ |
| 5747 | 3973 @tex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3974 ($\\infty - \\infty$), zero divided by zero ($0/0$),\n\ |
| 5747 | 3975 @end tex\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
3976 @ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3977 (Inf - Inf), zero divided by zero (0/0),\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
3978 @end ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3979 and any operation involving another NaN value (5 + NaN).\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3980 \n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3981 Note that NaN always compares not equal to NaN (NaN != NaN). This behavior\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3982 is specified by the IEEE standard for floating point arithmetic. To\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3983 find NaN values, use the @code{isnan} function.\n\ |
| 5747 | 3984 \n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3985 When called with no arguments, return a scalar with the value @samp{NaN}.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3986 When called with a single argument, return a square matrix with the dimension\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3987 specified. When called with more than one scalar argument the first two\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3988 arguments are taken as the number of rows and columns and any further\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3989 arguments specify additional matrix dimensions.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3990 The optional argument @var{class} specifies the return type and may be\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3991 either \"double\" or \"single\".\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
3992 @seealso{isnan}\n\ |
| 5747 | 3993 @end deftypefn") |
| 3994 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3995 return fill_matrix (args, lo_ieee_nan_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3996 lo_ieee_float_nan_value (), "NaN"); |
| 5747 | 3997 } |
| 3998 | |
| 3999 DEFALIAS (nan, NaN); | |
| 4000 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4001 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4002 %!assert(NaN (3), [NaN, NaN, NaN; NaN, NaN, NaN; NaN, NaN, NaN]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4003 %!assert(NaN (2, 3), [NaN, NaN, NaN; NaN, NaN, NaN]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4004 %!assert(NaN (3, 2), [NaN, NaN; NaN, NaN; NaN, NaN]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4005 %!assert(size (NaN (3, 4, 5)), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4006 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4007 %!assert(NaN (3,'single'), single([NaN, NaN, NaN; NaN, NaN, NaN; NaN, NaN, NaN])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4008 %!assert(NaN (2, 3,'single'), single([NaN, NaN, NaN; NaN, NaN, NaN])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4009 %!assert(NaN (3, 2,'single'), single([NaN, NaN; NaN, NaN; NaN, NaN])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4010 %!assert(size (NaN (3, 4, 5, 'single')), [3, 4, 5]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4011 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4012 %!error(NaN (3,'int8')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4013 %!error(NaN (2, 3,'int8')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4014 %!error(NaN (3, 2,'int8')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4015 %!error(NaN (3, 4, 5, 'int8')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4016 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4017 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4018 |
| 5747 | 4019 DEFUN (e, args, , |
| 4020 "-*- texinfo -*-\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4021 @deftypefn {Built-in Function} {} e\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4022 @deftypefnx {Built-in Function} {} e (@var{n})\n\ |
| 5747 | 4023 @deftypefnx {Built-in Function} {} e (@var{n}, @var{m})\n\ |
| 4024 @deftypefnx {Built-in Function} {} e (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 4025 @deftypefnx {Built-in Function} {} e (@dots{}, @var{class})\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4026 Return a scalar, matrix, or N-dimensional array whose elements are all equal\n\ |
| 5747 | 4027 to the base of natural logarithms. The constant\n\ |
| 4028 @tex\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4029 $e$ satisfies the equation $\\log (e) = 1$.\n\ |
| 5747 | 4030 @end tex\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4031 @ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4032 @samp{e} satisfies the equation @code{log} (e) = 1.\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4033 @end ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4034 \n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4035 When called with no arguments, return a scalar with the value @math{e}. When\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4036 called with a single argument, return a square matrix with the dimension\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4037 specified. When called with more than one scalar argument the first two\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4038 arguments are taken as the number of rows and columns and any further\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4039 arguments specify additional matrix dimensions.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4040 The optional argument @var{class} specifies the return type and may be\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4041 either \"double\" or \"single\".\n\ |
| 5747 | 4042 @end deftypefn") |
| 4043 { | |
| 4044 #if defined (M_E) | |
| 4045 double e_val = M_E; | |
| 4046 #else | |
| 4047 double e_val = exp (1.0); | |
| 4048 #endif | |
| 4049 | |
| 4050 return fill_matrix (args, e_val, "e"); | |
| 4051 } | |
| 4052 | |
| 4053 DEFUN (eps, args, , | |
| 4054 "-*- texinfo -*-\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4055 @deftypefn {Built-in Function} {} eps\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4056 @deftypefnx {Built-in Function} {} eps (@var{x})\n\ |
| 5747 | 4057 @deftypefnx {Built-in Function} {} eps (@var{n}, @var{m})\n\ |
| 4058 @deftypefnx {Built-in Function} {} eps (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 4059 @deftypefnx {Built-in Function} {} eps (@dots{}, @var{class})\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4060 Return a scalar, matrix or N-dimensional array whose elements are all eps,\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4061 the machine precision. More precisely, @code{eps} is the relative spacing\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4062 between any two adjacent numbers in the machine's floating point system.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4063 This number is obviously system dependent. On machines that support IEEE\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4064 floating point arithmetic, @code{eps} is approximately\n\ |
| 5747 | 4065 @tex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4066 $2.2204\\times10^{-16}$ for double precision and $1.1921\\times10^{-7}$\n\ |
| 5747 | 4067 @end tex\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4068 @ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4069 2.2204e-16 for double precision and 1.1921e-07\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4070 @end ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4071 for single precision.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4072 \n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4073 When called with no arguments, return a scalar with the value\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4074 @code{eps(1.0)}.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4075 Given a single argument @var{x}, return the distance between @var{x} and\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4076 the next largest value.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4077 When called with more than one argument the first two arguments are taken as\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4078 the number of rows and columns and any further\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4079 arguments specify additional matrix dimensions.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4080 The optional argument @var{class} specifies the return type and may be\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4081 either \"double\" or \"single\".\n\ |
| 5747 | 4082 @end deftypefn") |
| 4083 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4084 int nargin = args.length (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4085 octave_value retval; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4086 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4087 if (nargin == 1 && ! args(0).is_string ()) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4088 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4089 if (args(0).is_single_type ()) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4090 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4091 float val = args(0).float_value (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4092 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4093 if (! error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4094 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4095 val = ::fabsf(val); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4096 if (xisnan (val) || xisinf (val)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4097 retval = fill_matrix (octave_value ("single"), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4098 lo_ieee_nan_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4099 lo_ieee_float_nan_value (), "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4100 else if (val < FLT_MIN) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4101 retval = fill_matrix (octave_value ("single"), 0e0, |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4102 powf (2.0, -149e0), "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4103 else |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4104 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4105 int expon; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4106 frexpf (val, &expon); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4107 val = std::pow (static_cast <float> (2.0), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4108 static_cast <float> (expon - 24)); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4109 retval = fill_matrix (octave_value ("single"), DBL_EPSILON, |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4110 val, "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4111 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4112 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4113 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4114 else |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4115 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4116 double val = args(0).double_value (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4117 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4118 if (! error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4119 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4120 val = ::fabs(val); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4121 if (xisnan (val) || xisinf (val)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4122 retval = fill_matrix (octave_value_list (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4123 lo_ieee_nan_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4124 lo_ieee_float_nan_value (), "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4125 else if (val < DBL_MIN) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4126 retval = fill_matrix (octave_value_list (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4127 pow (2.0, -1074e0), 0e0, "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4128 else |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4129 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4130 int expon; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4131 frexp (val, &expon); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4132 val = std::pow (static_cast <double> (2.0), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4133 static_cast <double> (expon - 53)); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4134 retval = fill_matrix (octave_value_list (), val, |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4135 FLT_EPSILON, "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4136 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4137 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4138 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4139 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4140 else |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4141 retval = fill_matrix (args, DBL_EPSILON, FLT_EPSILON, "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4142 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4143 return retval; |
| 5747 | 4144 } |
| 4145 | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4146 /* |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4147 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4148 %!assert(eps(1/2),2^(-53)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4149 %!assert(eps(1),2^(-52)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4150 %!assert(eps(2),2^(-51)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4151 %!assert(eps(realmax),2^971) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4152 %!assert(eps(0),2^(-1074)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4153 %!assert(eps(realmin/2),2^(-1074)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4154 %!assert(eps(realmin/16),2^(-1074)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4155 %!assert(eps(Inf),NaN) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4156 %!assert(eps(NaN),NaN) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4157 %!assert(eps(single(1/2)),single(2^(-24))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4158 %!assert(eps(single(1)),single(2^(-23))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4159 %!assert(eps(single(2)),single(2^(-22))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4160 %!assert(eps(realmax('single')),single(2^104)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4161 %!assert(eps(single(0)),single(2^(-149))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4162 %!assert(eps(realmin('single')/2),single(2^(-149))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4163 %!assert(eps(realmin('single')/16),single(2^(-149))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4164 %!assert(eps(single(Inf)),single(NaN)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4165 %!assert(eps(single(NaN)),single(NaN)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4166 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4167 */ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4168 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4169 |
| 5747 | 4170 DEFUN (pi, args, , |
| 4171 "-*- texinfo -*-\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4172 @deftypefn {Built-in Function} {} pi\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4173 @deftypefnx {Built-in Function} {} pi (@var{n})\n\ |
| 5747 | 4174 @deftypefnx {Built-in Function} {} pi (@var{n}, @var{m})\n\ |
| 4175 @deftypefnx {Built-in Function} {} pi (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 4176 @deftypefnx {Built-in Function} {} pi (@dots{}, @var{class})\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4177 Return a scalar, matrix, or N-dimensional array whose elements are all equal\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4178 to the ratio of the circumference of a circle to its\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4179 @tex\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4180 diameter($\\pi$).\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4181 @end tex\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4182 @ifnottex\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4183 diameter.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4184 @end ifnottex\n\ |
| 5747 | 4185 Internally, @code{pi} is computed as @samp{4.0 * atan (1.0)}.\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4186 \n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4187 When called with no arguments, return a scalar with the value of\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4188 @tex\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4189 $\\pi$.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4190 @end tex\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4191 @ifnottex\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4192 pi.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4193 @end ifnottex\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4194 When called with a single argument, return a square matrix with the dimension\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4195 specified. When called with more than one scalar argument the first two\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4196 arguments are taken as the number of rows and columns and any further\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4197 arguments specify additional matrix dimensions.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4198 The optional argument @var{class} specifies the return type and may be\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4199 either \"double\" or \"single\".\n\ |
| 5747 | 4200 @end deftypefn") |
| 4201 { | |
| 4202 #if defined (M_PI) | |
| 4203 double pi_val = M_PI; | |
| 4204 #else | |
| 4205 double pi_val = 4.0 * atan (1.0); | |
| 4206 #endif | |
| 4207 | |
| 4208 return fill_matrix (args, pi_val, "pi"); | |
| 4209 } | |
| 4210 | |
| 4211 DEFUN (realmax, args, , | |
| 4212 "-*- texinfo -*-\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4213 @deftypefn {Built-in Function} {} realmax\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4214 @deftypefnx {Built-in Function} {} realmax (@var{n})\n\ |
| 5747 | 4215 @deftypefnx {Built-in Function} {} realmax (@var{n}, @var{m})\n\ |
| 4216 @deftypefnx {Built-in Function} {} realmax (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 4217 @deftypefnx {Built-in Function} {} realmax (@dots{}, @var{class})\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4218 Return a scalar, matrix or N-dimensional array whose elements are all equal\n\ |
| 5747 | 4219 to the largest floating point number that is representable. The actual\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4220 value is system dependent. On machines that support IEEE\n\ |
| 5747 | 4221 floating point arithmetic, @code{realmax} is approximately\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4222 @tex\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4223 $1.7977\\times10^{308}$ for double precision and $3.4028\\times10^{38}$\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4224 @end tex\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4225 @ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4226 1.7977e+308 for double precision and 3.4028e+38\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4227 @end ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4228 for single precision.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4229 \n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4230 When called with no arguments, return a scalar with the value\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4231 @code{realmax(\"double\")}.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4232 When called with a single argument, return a square matrix with the dimension\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4233 specified. When called with more than one scalar argument the first two\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4234 arguments are taken as the number of rows and columns and any further\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4235 arguments specify additional matrix dimensions.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4236 The optional argument @var{class} specifies the return type and may be\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4237 either \"double\" or \"single\".\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4238 @seealso{realmin, intmax, bitmax}\n\ |
| 5747 | 4239 @end deftypefn") |
| 4240 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4241 return fill_matrix (args, DBL_MAX, FLT_MAX, "realmax"); |
| 5747 | 4242 } |
| 4243 | |
| 4244 DEFUN (realmin, args, , | |
| 4245 "-*- texinfo -*-\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4246 @deftypefn {Built-in Function} {} realmin\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4247 @deftypefnx {Built-in Function} {} realmin (@var{n})\n\ |
| 5747 | 4248 @deftypefnx {Built-in Function} {} realmin (@var{n}, @var{m})\n\ |
| 4249 @deftypefnx {Built-in Function} {} realmin (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 4250 @deftypefnx {Built-in Function} {} realmin (@dots{}, @var{class})\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4251 Return a scalar, matrix or N-dimensional array whose elements are all equal\n\ |
| 5747 | 4252 to the smallest normalized floating point number that is representable.\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4253 The actual value is system dependent. On machines that support\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4254 IEEE floating point arithmetic, @code{realmin} is approximately\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4255 @tex\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4256 $2.2251\\times10^{-308}$ for double precision and $1.1755\\times10^{-38}$\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4257 @end tex\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4258 @ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4259 2.2251e-308 for double precision and 1.1755e-38\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4260 @end ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4261 for single precision.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4262 \n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4263 When called with no arguments, return a scalar with the value\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4264 @code{realmin(\"double\")}.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4265 When called with a single argument, return a square matrix with the dimension\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4266 specified. When called with more than one scalar argument the first two\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4267 arguments are taken as the number of rows and columns and any further\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4268 arguments specify additional matrix dimensions.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4269 The optional argument @var{class} specifies the return type and may be\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4270 either \"double\" or \"single\".\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4271 @seealso{realmax, intmin}\n\ |
| 5747 | 4272 @end deftypefn") |
| 4273 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4274 return fill_matrix (args, DBL_MIN, FLT_MIN, "realmin"); |
| 5747 | 4275 } |
| 4276 | |
| 4277 DEFUN (I, args, , | |
| 4278 "-*- texinfo -*-\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4279 @deftypefn {Built-in Function} {} I\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4280 @deftypefnx {Built-in Function} {} I (@var{n})\n\ |
| 5747 | 4281 @deftypefnx {Built-in Function} {} I (@var{n}, @var{m})\n\ |
| 4282 @deftypefnx {Built-in Function} {} I (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 4283 @deftypefnx {Built-in Function} {} I (@dots{}, @var{class})\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4284 Return a scalar, matrix, or N-dimensional array whose elements are all equal\n\ |
| 5747 | 4285 to the pure imaginary unit, defined as\n\ |
| 4286 @tex\n\ | |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4287 $\\sqrt{-1}$.\n\ |
| 5747 | 4288 @end tex\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4289 @ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4290 @code{sqrt (-1)}.\n\ |
|
8517
81d6ab3ac93c
Allow documentation tobe built for other formats than tex and info
sh@sh-laptop
parents:
8487
diff
changeset
|
4291 @end ifnottex\n\ |
|
9197
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4292 I, and its equivalents i, J, and j, are functions so any of the names may\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4293 be reused for other purposes (such as i for a counter variable).\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4294 \n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4295 When called with no arguments, return a scalar with the value @math{i}. When\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4296 called with a single argument, return a square matrix with the dimension\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4297 specified. When called with more than one scalar argument the first two\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4298 arguments are taken as the number of rows and columns and any further\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4299 arguments specify additional matrix dimensions.\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4300 The optional argument @var{class} specifies the return type and may be\n\ |
|
3c27a0340a64
Update documentation for section 17.8 (Mathematical Constants) of arith.texi
Rik <rdrider0-list@yahoo.com>
parents:
9194
diff
changeset
|
4301 either \"double\" or \"single\".\n\ |
| 5747 | 4302 @end deftypefn") |
| 4303 { | |
| 4304 return fill_matrix (args, Complex (0.0, 1.0), "I"); | |
| 4305 } | |
| 4306 | |
| 4307 DEFALIAS (i, I); | |
| 4308 DEFALIAS (J, I); | |
| 4309 DEFALIAS (j, I); | |
| 4310 | |
| 4311 DEFUN (NA, args, , | |
| 4312 "-*- texinfo -*-\n\ | |
|
9308
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4313 @deftypefn {Built-in Function} {} NA\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4314 @deftypefnx {Built-in Function} {} NA (@var{n})\n\ |
| 5747 | 4315 @deftypefnx {Built-in Function} {} NA (@var{n}, @var{m})\n\ |
| 4316 @deftypefnx {Built-in Function} {} NA (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 4317 @deftypefnx {Built-in Function} {} NA (@dots{}, @var{class})\n\ | |
|
9308
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4318 Return a scalar, matrix, or N-dimensional array whose elements are all equal\n\ |
| 5747 | 4319 to the special constant used to designate missing values.\n\ |
|
9308
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4320 \n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4321 Note that NA always compares not equal to NA (NA != NA).\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4322 To find NA values, use the @code{isna} function.\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4323 \n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4324 When called with no arguments, return a scalar with the value @samp{NA}.\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4325 When called with a single argument, return a square matrix with the dimension\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4326 specified. When called with more than one scalar argument the first two\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4327 arguments are taken as the number of rows and columns and any further\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4328 arguments specify additional matrix dimensions.\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4329 The optional argument @var{class} specifies the return type and may be\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4330 either \"double\" or \"single\".\n\ |
|
f2bf62f62286
Update documentation for NA and isna functions
Rik <rdrider0-list@yahoo.com>
parents:
9198
diff
changeset
|
4331 @seealso{isna}\n\ |
| 5747 | 4332 @end deftypefn") |
| 4333 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4334 return fill_matrix (args, lo_ieee_na_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
4335 lo_ieee_float_na_value (), "NA"); |
| 5747 | 4336 } |
| 4337 | |
|
7991
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
4338 /* |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
4339 |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
4340 %!assert(single(NA('double')),NA('single')) |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
4341 %!assert(double(NA('single')),NA('double')) |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
4342 |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
4343 */ |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
4344 |
| 5747 | 4345 DEFUN (false, args, , |
| 4346 "-*- texinfo -*-\n\ | |
| 4347 @deftypefn {Built-in Function} {} false (@var{x})\n\ | |
| 4348 @deftypefnx {Built-in Function} {} false (@var{n}, @var{m})\n\ | |
| 4349 @deftypefnx {Built-in Function} {} false (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 4350 Return a matrix or N-dimensional array whose elements are all logical 0.\n\ | |
|
9428
b317debeb828
data.cc (Fones, Fzeros, Ftrue, Ffalse): update docstring
John W. Eaton <jwe@octave.org>
parents:
9351
diff
changeset
|
4351 The arguments are handled the same as the arguments for @code{ones}.\n\ |
| 5747 | 4352 @end deftypefn") |
| 4353 { | |
| 4354 return fill_matrix (args, false, "false"); | |
| 4355 } | |
| 4356 | |
| 4357 DEFUN (true, args, , | |
| 4358 "-*- texinfo -*-\n\ | |
| 4359 @deftypefn {Built-in Function} {} true (@var{x})\n\ | |
| 4360 @deftypefnx {Built-in Function} {} true (@var{n}, @var{m})\n\ | |
| 4361 @deftypefnx {Built-in Function} {} true (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 4362 Return a matrix or N-dimensional array whose elements are all logical 1.\n\ | |
|
9428
b317debeb828
data.cc (Fones, Fzeros, Ftrue, Ffalse): update docstring
John W. Eaton <jwe@octave.org>
parents:
9351
diff
changeset
|
4363 The arguments are handled the same as the arguments for @code{ones}.\n\ |
| 5747 | 4364 @end deftypefn") |
| 4365 { | |
| 4366 return fill_matrix (args, true, "true"); | |
| 3354 | 4367 } |
| 523 | 4368 |
| 4946 | 4369 template <class MT> |
| 4370 octave_value | |
| 4371 identity_matrix (int nr, int nc) | |
| 4372 { | |
| 4373 octave_value retval; | |
| 4374 | |
| 9685 | 4375 typename MT::element_type one (1); |
| 4946 | 4376 |
| 4377 if (nr == 1 && nc == 1) | |
| 4378 retval = one; | |
| 4379 else | |
| 4380 { | |
| 4381 dim_vector dims (nr, nc); | |
| 4382 | |
| 9685 | 4383 typename MT::element_type zero (0); |
| 4946 | 4384 |
| 4385 MT m (dims, zero); | |
| 4386 | |
| 4387 if (nr > 0 && nc > 0) | |
| 4388 { | |
| 4389 int n = std::min (nr, nc); | |
| 4390 | |
| 4391 for (int i = 0; i < n; i++) | |
| 4392 m(i,i) = one; | |
| 4393 } | |
| 4394 | |
| 4395 retval = m; | |
| 4396 } | |
| 4397 | |
| 4398 return retval; | |
| 4399 } | |
| 4400 | |
| 5058 | 4401 #define INSTANTIATE_EYE(T) \ |
| 4402 template octave_value identity_matrix<T> (int, int) | |
| 4403 | |
| 4404 INSTANTIATE_EYE (int8NDArray); | |
| 4405 INSTANTIATE_EYE (uint8NDArray); | |
| 4406 INSTANTIATE_EYE (int16NDArray); | |
| 4407 INSTANTIATE_EYE (uint16NDArray); | |
| 4408 INSTANTIATE_EYE (int32NDArray); | |
| 4409 INSTANTIATE_EYE (uint32NDArray); | |
| 4410 INSTANTIATE_EYE (int64NDArray); | |
| 4411 INSTANTIATE_EYE (uint64NDArray); | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4412 INSTANTIATE_EYE (FloatNDArray); |
| 5058 | 4413 INSTANTIATE_EYE (NDArray); |
| 4414 INSTANTIATE_EYE (boolNDArray); | |
| 4415 | |
| 4945 | 4416 static octave_value |
| 4948 | 4417 identity_matrix (int nr, int nc, oct_data_conv::data_type dt) |
| 4945 | 4418 { |
| 4419 octave_value retval; | |
| 4420 | |
| 5775 | 4421 // FIXME -- perhaps this should be made extensible by using |
| 4946 | 4422 // the class name to lookup a function to call to create the new |
| 4423 // value. | |
| 4424 | |
| 4425 if (! error_state) | |
| 4426 { | |
| 4427 switch (dt) | |
| 4428 { | |
| 4429 case oct_data_conv::dt_int8: | |
| 4430 retval = identity_matrix<int8NDArray> (nr, nc); | |
| 4431 break; | |
| 4432 | |
| 4433 case oct_data_conv::dt_uint8: | |
| 4434 retval = identity_matrix<uint8NDArray> (nr, nc); | |
| 4435 break; | |
| 4436 | |
| 4437 case oct_data_conv::dt_int16: | |
| 4438 retval = identity_matrix<int16NDArray> (nr, nc); | |
| 4439 break; | |
| 4945 | 4440 |
| 4946 | 4441 case oct_data_conv::dt_uint16: |
| 4442 retval = identity_matrix<uint16NDArray> (nr, nc); | |
| 4443 break; | |
| 4444 | |
| 4445 case oct_data_conv::dt_int32: | |
| 4446 retval = identity_matrix<int32NDArray> (nr, nc); | |
| 4447 break; | |
| 4448 | |
| 4449 case oct_data_conv::dt_uint32: | |
| 4450 retval = identity_matrix<uint32NDArray> (nr, nc); | |
| 4451 break; | |
| 4945 | 4452 |
| 4946 | 4453 case oct_data_conv::dt_int64: |
| 4454 retval = identity_matrix<int64NDArray> (nr, nc); | |
| 4455 break; | |
| 4456 | |
| 4457 case oct_data_conv::dt_uint64: | |
| 4458 retval = identity_matrix<uint64NDArray> (nr, nc); | |
| 4459 break; | |
| 4945 | 4460 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4461 case oct_data_conv::dt_single: |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
4462 retval = FloatDiagMatrix (nr, nc, 1.0f); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4463 break; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4464 |
| 4946 | 4465 case oct_data_conv::dt_double: |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8347
diff
changeset
|
4466 retval = DiagMatrix (nr, nc, 1.0); |
| 4946 | 4467 break; |
| 4945 | 4468 |
| 4986 | 4469 case oct_data_conv::dt_logical: |
| 4470 retval = identity_matrix<boolNDArray> (nr, nc); | |
| 4471 break; | |
| 4472 | |
| 4946 | 4473 default: |
| 4474 error ("eye: invalid class name"); | |
| 4475 break; | |
| 4945 | 4476 } |
| 4477 } | |
| 4478 | |
| 4479 return retval; | |
| 4480 } | |
| 4481 | |
| 4946 | 4482 #undef INT_EYE_MATRIX |
| 4483 | |
| 1957 | 4484 DEFUN (eye, args, , |
| 3369 | 4485 "-*- texinfo -*-\n\ |
| 4486 @deftypefn {Built-in Function} {} eye (@var{x})\n\ | |
| 4487 @deftypefnx {Built-in Function} {} eye (@var{n}, @var{m})\n\ | |
| 4948 | 4488 @deftypefnx {Built-in Function} {} eye (@dots{}, @var{class})\n\ |
| 3369 | 4489 Return an identity matrix. If invoked with a single scalar argument,\n\ |
| 4490 @code{eye} returns a square matrix with the dimension specified. If you\n\ | |
| 4491 supply two scalar arguments, @code{eye} takes them to be the number of\n\ | |
| 4492 rows and columns. If given a vector with two elements, @code{eye} uses\n\ | |
| 4493 the values of the elements as the number of rows and columns,\n\ | |
| 4494 respectively. For example,\n\ | |
| 4495 \n\ | |
| 4496 @example\n\ | |
| 4497 @group\n\ | |
| 4498 eye (3)\n\ | |
| 4499 @result{} 1 0 0\n\ | |
| 4500 0 1 0\n\ | |
| 4501 0 0 1\n\ | |
| 4502 @end group\n\ | |
| 4503 @end example\n\ | |
| 4504 \n\ | |
| 4505 The following expressions all produce the same result:\n\ | |
| 4506 \n\ | |
| 4507 @example\n\ | |
| 4508 @group\n\ | |
| 4509 eye (2)\n\ | |
| 4510 @equiv{}\n\ | |
| 4511 eye (2, 2)\n\ | |
| 4512 @equiv{}\n\ | |
| 4513 eye (size ([1, 2; 3, 4])\n\ | |
| 4514 @end group\n\ | |
| 4515 @end example\n\ | |
| 4516 \n\ | |
| 4945 | 4517 The optional argument @var{class}, allows @code{eye} to return an array of\n\ |
| 4518 the specified type, like\n\ | |
| 4519 \n\ | |
| 4520 @example\n\ | |
| 4521 val = zeros (n,m, \"uint8\")\n\ | |
| 4522 @end example\n\ | |
| 4523 \n\ | |
| 6556 | 4524 Calling @code{eye} with no arguments is equivalent to calling it\n\ |
| 4525 with an argument of 1. This odd definition is for compatibility\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
4526 with @sc{matlab}.\n\ |
| 3369 | 4527 @end deftypefn") |
| 523 | 4528 { |
| 3354 | 4529 octave_value retval; |
| 523 | 4530 |
| 4948 | 4531 int nargin = args.length (); |
| 4945 | 4532 |
| 4948 | 4533 oct_data_conv::data_type dt = oct_data_conv::dt_double; |
| 523 | 4534 |
| 4945 | 4535 // Check for type information. |
| 4536 | |
| 4537 if (nargin > 0 && args(nargin-1).is_string ()) | |
| 4538 { | |
| 4948 | 4539 std::string nm = args(nargin-1).string_value (); |
| 4945 | 4540 nargin--; |
| 4948 | 4541 |
| 4542 dt = oct_data_conv::string_to_data_type (nm); | |
| 4543 | |
| 4544 if (error_state) | |
| 4545 return retval; | |
| 4945 | 4546 } |
| 4547 | |
| 523 | 4548 switch (nargin) |
| 4549 { | |
| 712 | 4550 case 0: |
| 4948 | 4551 retval = identity_matrix (1, 1, dt); |
| 712 | 4552 break; |
| 777 | 4553 |
| 610 | 4554 case 1: |
| 3354 | 4555 { |
| 5275 | 4556 octave_idx_type nr, nc; |
| 3354 | 4557 get_dimensions (args(0), "eye", nr, nc); |
| 4558 | |
| 4559 if (! error_state) | |
| 4948 | 4560 retval = identity_matrix (nr, nc, dt); |
| 3354 | 4561 } |
| 610 | 4562 break; |
| 777 | 4563 |
| 523 | 4564 case 2: |
| 3354 | 4565 { |
| 5275 | 4566 octave_idx_type nr, nc; |
| 3354 | 4567 get_dimensions (args(0), args(1), "eye", nr, nc); |
| 4568 | |
| 4569 if (! error_state) | |
| 4948 | 4570 retval = identity_matrix (nr, nc, dt); |
| 3354 | 4571 } |
| 523 | 4572 break; |
| 777 | 4573 |
| 523 | 4574 default: |
| 5823 | 4575 print_usage (); |
| 523 | 4576 break; |
| 4577 } | |
| 4578 | |
| 4579 return retval; | |
| 4580 } | |
| 4581 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4582 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4583 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4584 |
|
8459
d17874a6f161
improve indexing of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
4585 %!assert (full (eye(3)), [1, 0, 0; 0, 1, 0; 0, 0, 1]); |
|
d17874a6f161
improve indexing of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
4586 %!assert (full (eye(2, 3)), [1, 0, 0; 0, 1, 0]); |
|
d17874a6f161
improve indexing of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
4587 |
|
d17874a6f161
improve indexing of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
4588 %!assert (full (eye(3,'single')), single([1, 0, 0; 0, 1, 0; 0, 0, 1])); |
|
d17874a6f161
improve indexing of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
4589 %!assert (full (eye(2, 3,'single')), single([1, 0, 0; 0, 1, 0])); |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4590 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4591 %!assert (eye(3,'int8'), int8([1, 0, 0; 0, 1, 0; 0, 0, 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4592 %!assert (eye(2, 3,'int8'), int8([1, 0, 0; 0, 1, 0])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4593 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4594 %!error <Invalid call to eye.*> eye (1, 2, 3); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4595 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4596 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4597 |
|
9658
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4598 template <class MT> |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4599 static octave_value |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4600 do_linspace (const octave_value& base, const octave_value& limit, |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4601 octave_idx_type n) |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4602 { |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4603 typedef typename MT::column_vector_type CVT; |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4604 typedef typename MT::element_type T; |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4605 |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4606 octave_value retval; |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4607 |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4608 if (base.is_scalar_type ()) |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4609 { |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4610 T bs = octave_value_extract<T> (base); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4611 if (limit.is_scalar_type ()) |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4612 { |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4613 T ls = octave_value_extract<T> (limit); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4614 retval = linspace (bs, ls, n); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4615 } |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4616 else |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4617 { |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4618 CVT lv = octave_value_extract<CVT> (limit); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4619 CVT bv (lv.length (), bs); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4620 retval = linspace (bv, lv, n); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4621 } |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4622 } |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4623 else |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4624 { |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4625 CVT bv = octave_value_extract<CVT> (base); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4626 if (limit.is_scalar_type ()) |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4627 { |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4628 T ls = octave_value_extract<T> (limit); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4629 CVT lv (bv.length (), ls); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4630 retval = linspace (bv, lv, n); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4631 } |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4632 else |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4633 { |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4634 CVT lv = octave_value_extract<CVT> (limit); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4635 retval = linspace (bv, lv, n); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4636 } |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4637 } |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4638 |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4639 return retval; |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4640 } |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4641 |
| 1957 | 4642 DEFUN (linspace, args, , |
| 3369 | 4643 "-*- texinfo -*-\n\ |
| 4644 @deftypefn {Built-in Function} {} linspace (@var{base}, @var{limit}, @var{n})\n\ | |
| 4645 Return a row vector with @var{n} linearly spaced elements between\n\ | |
| 6630 | 4646 @var{base} and @var{limit}. If the number of elements is greater than one,\n\ |
| 4647 then the @var{base} and @var{limit} are always included in\n\ | |
| 3369 | 4648 the range. If @var{base} is greater than @var{limit}, the elements are\n\ |
| 4649 stored in decreasing order. If the number of points is not specified, a\n\ | |
| 4650 value of 100 is used.\n\ | |
| 1100 | 4651 \n\ |
|
9658
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4652 The @code{linspace} function always returns a row vector if both\n\ |
|
9758
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
4653 @var{base} and @var{limit} are scalars. If one of them or both are column\n\ |
|
9658
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4654 vectors, @code{linspace} returns a matrix.\n\ |
| 6630 | 4655 \n\ |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
4656 For compatibility with @sc{matlab}, return the second argument if\n\ |
| 6630 | 4657 fewer than two values are requested.\n\ |
| 3369 | 4658 @end deftypefn") |
| 1100 | 4659 { |
| 3418 | 4660 octave_value retval; |
| 1100 | 4661 |
| 4662 int nargin = args.length (); | |
| 4663 | |
| 6133 | 4664 octave_idx_type npoints = 100; |
| 1100 | 4665 |
| 1940 | 4666 if (nargin != 2 && nargin != 3) |
| 4667 { | |
| 5823 | 4668 print_usage (); |
| 1940 | 4669 return retval; |
| 4670 } | |
| 4671 | |
| 1100 | 4672 if (nargin == 3) |
| 6133 | 4673 npoints = args(2).idx_type_value (); |
| 1100 | 4674 |
| 4675 if (! error_state) | |
| 4676 { | |
| 3322 | 4677 octave_value arg_1 = args(0); |
| 4678 octave_value arg_2 = args(1); | |
| 1100 | 4679 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4680 if (arg_1.is_single_type () || arg_2.is_single_type ()) |
| 3322 | 4681 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4682 if (arg_1.is_complex_type () || arg_2.is_complex_type ()) |
|
9658
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4683 retval = do_linspace<FloatComplexMatrix> (arg_1, arg_2, npoints); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4684 else |
|
9658
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4685 retval = do_linspace<FloatMatrix> (arg_1, arg_2, npoints); |
|
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4686 |
| 1100 | 4687 } |
| 4688 else | |
| 3322 | 4689 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4690 if (arg_1.is_complex_type () || arg_2.is_complex_type ()) |
|
9658
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4691 retval = do_linspace<ComplexMatrix> (arg_1, arg_2, npoints); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4692 else |
|
9658
3429c956de6f
extend linspace & fix up liboctave rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
9562
diff
changeset
|
4693 retval = do_linspace<Matrix> (arg_1, arg_2, npoints); |
| 3322 | 4694 } |
| 1100 | 4695 } |
| 4732 | 4696 else |
| 4697 error ("linspace: expecting third argument to be an integer"); | |
| 1100 | 4698 |
| 4699 return retval; | |
| 4700 } | |
| 4701 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4702 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4703 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4704 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4705 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4706 %! x1 = linspace (1, 2); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4707 %! x2 = linspace (1, 2, 10); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4708 %! x3 = linspace (1, -2, 10); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4709 %! assert((size (x1) == [1, 100] && x1(1) == 1 && x1(100) == 2 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4710 %! && size (x2) == [1, 10] && x2(1) == 1 && x2(10) == 2 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4711 %! && size (x3) == [1, 10] && x3(1) == 1 && x3(10) == -2)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4712 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4713 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4714 % assert(linspace ([1, 2; 3, 4], 5, 6), linspace (1, 5, 6)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4715 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4716 %!error <Invalid call to linspace.*> linspace (); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4717 %!error <Invalid call to linspace.*> linspace (1, 2, 3, 4); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4718 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4719 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4720 %! fail("linspace ([1, 2; 3, 4], 5, 6)","warning"); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4721 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4722 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4723 |
| 5775 | 4724 // FIXME -- should accept dimensions as separate args for N-d |
| 5734 | 4725 // arrays as well as 1-d and 2-d arrays. |
| 4726 | |
| 5731 | 4727 DEFUN (resize, args, , |
| 4728 "-*- texinfo -*-\n\ | |
| 4729 @deftypefn {Built-in Function} {} resize (@var{x}, @var{m})\n\ | |
| 4730 @deftypefnx {Built-in Function} {} resize (@var{x}, @var{m}, @var{n})\n\ | |
|
8799
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4731 @deftypefnx {Built-in Function} {} resize (@var{x}, @var{m}, @var{n}, @dots{})\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4732 Resize @var{x} cutting off elements as necessary.\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4733 \n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4734 In the result, element with certain indices is equal to the corresponding\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4735 element of @var{x} if the indices are within the bounds of @var{x};\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4736 otherwise, the element is set to zero.\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4737 \n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4738 In other words, the statement\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4739 \n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4740 @example\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4741 y = resize (x, dv);\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4742 @end example\n\ |
| 6174 | 4743 \n\ |
|
8799
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4744 @noindent\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4745 is equivalent to the following code:\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4746 \n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4747 @example\n\ |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
4748 @group\n\ |
|
8799
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4749 y = zeros (dv, class (x));\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4750 sz = min (dv, size (x));\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4751 for i = 1:length (sz), idx@{i@} = 1:sz(i); endfor\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4752 y(idx@{:@}) = x(idx@{:@});\n\ |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
4753 @end group\n\ |
|
8799
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4754 @end example\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4755 \n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4756 @noindent\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4757 but is performed more efficiently.\n\ |
| 6174 | 4758 \n\ |
| 4759 If only @var{m} is supplied and it is a scalar, the dimension of the\n\ | |
| 4760 result is @var{m}-by-@var{m}. If @var{m} is a vector, then the\n\ | |
| 4761 dimensions of the result are given by the elements of @var{m}.\n\ | |
| 4762 If both @var{m} and @var{n} are scalars, then the dimensions of\n\ | |
| 4763 the result are @var{m}-by-@var{n}.\n\ | |
|
8799
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4764 \n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4765 An object can be resized to more dimensions than it has;\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4766 in such case the missing dimensions are assumed to be 1.\n\ |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4767 Resizing an object to fewer dimensions is not possible.\n\ |
|
8433
3292bd1bbaa4
Cross reference between postpad and resize
Francesco Potortì <pot@gnu.org>
parents:
8429
diff
changeset
|
4768 @seealso{reshape, postpad}\n\ |
| 5731 | 4769 @end deftypefn") |
| 4770 { | |
| 4771 octave_value retval; | |
| 4772 int nargin = args.length (); | |
| 4773 | |
| 4774 if (nargin == 2) | |
| 4775 { | |
| 4776 Array<double> vec = args(1).vector_value (); | |
| 4777 int ndim = vec.length (); | |
| 4778 if (ndim == 1) | |
| 4779 { | |
| 4780 octave_idx_type m = static_cast<octave_idx_type> (vec(0)); | |
| 4781 retval = args(0); | |
| 4782 retval = retval.resize (dim_vector (m, m), true); | |
| 4783 } | |
| 4784 else | |
| 4785 { | |
| 4786 dim_vector dv; | |
| 4787 dv.resize (ndim); | |
| 4788 for (int i = 0; i < ndim; i++) | |
| 4789 dv(i) = static_cast<octave_idx_type> (vec(i)); | |
| 4790 retval = args(0); | |
| 4791 retval = retval.resize (dv, true); | |
| 4792 } | |
| 4793 } | |
|
8799
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4794 else if (nargin > 2) |
| 5731 | 4795 { |
|
8799
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4796 dim_vector dv; |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4797 dv.resize (nargin - 1); |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4798 for (octave_idx_type i = 1; i < nargin; i++) |
|
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4799 dv(i-1) = static_cast<octave_idx_type> (args(i).scalar_value ()); |
| 5731 | 4800 if (!error_state) |
| 4801 { | |
| 4802 retval = args(0); | |
|
8799
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4803 retval = retval.resize (dv, true); |
| 5731 | 4804 } |
|
8799
f6dc6eb57045
improve resize & resize on assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8780
diff
changeset
|
4805 |
| 5731 | 4806 } |
| 4807 else | |
| 5823 | 4808 print_usage (); |
| 5731 | 4809 return retval; |
| 4810 } | |
| 4811 | |
| 5775 | 4812 // FIXME -- should use octave_idx_type for dimensions. |
| 5734 | 4813 |
| 4567 | 4814 DEFUN (reshape, args, , |
| 4815 "-*- texinfo -*-\n\ | |
| 6671 | 4816 @deftypefn {Built-in Function} {} reshape (@var{a}, @var{m}, @var{n}, @dots{})\n\ |
|
9041
853f96e8008f
Cleanup documentation file matrix.texi
Rik <rdrider0-list@yahoo.com>
parents:
8972
diff
changeset
|
4817 @deftypefnx {Built-in Function} {} reshape (@var{a}, @var{size})\n\ |
| 4567 | 4818 Return a matrix with the given dimensions whose elements are taken\n\ |
| 6671 | 4819 from the matrix @var{a}. The elements of the matrix are accessed in\n\ |
| 4567 | 4820 column-major order (like Fortran arrays are stored).\n\ |
| 4821 \n\ | |
| 4822 For example,\n\ | |
| 4823 \n\ | |
| 4824 @example\n\ | |
| 4825 @group\n\ | |
| 4826 reshape ([1, 2, 3, 4], 2, 2)\n\ | |
| 4827 @result{} 1 3\n\ | |
| 4828 2 4\n\ | |
| 4829 @end group\n\ | |
| 4830 @end example\n\ | |
| 4831 \n\ | |
| 4832 @noindent\n\ | |
| 4833 Note that the total number of elements in the original\n\ | |
| 4834 matrix must match the total number of elements in the new matrix.\n\ | |
| 5013 | 4835 \n\ |
| 4836 A single dimension of the return matrix can be unknown and is flagged\n\ | |
| 4837 by an empty argument.\n\ | |
| 4567 | 4838 @end deftypefn") |
| 4839 { | |
| 4840 octave_value retval; | |
| 4841 | |
| 4842 int nargin = args.length (); | |
| 4843 | |
| 4844 Array<int> new_size; | |
| 4845 | |
| 4846 if (nargin == 2) | |
| 4847 new_size = args(1).int_vector_value (); | |
| 4848 else if (nargin > 2) | |
| 4849 { | |
| 4850 new_size.resize (nargin-1); | |
| 5013 | 4851 int empty_dim = -1; |
| 4852 | |
| 4567 | 4853 for (int i = 1; i < nargin; i++) |
| 4854 { | |
| 5013 | 4855 if (args(i).is_empty ()) |
| 4856 if (empty_dim > 0) | |
| 4857 { | |
| 4858 error ("reshape: only a single dimension can be unknown"); | |
| 4859 break; | |
| 4860 } | |
| 4861 else | |
| 4862 { | |
| 4863 empty_dim = i; | |
| 4864 new_size(i-1) = 1; | |
| 4865 } | |
| 4866 else | |
| 4867 { | |
| 6133 | 4868 new_size(i-1) = args(i).idx_type_value (); |
| 4567 | 4869 |
| 5013 | 4870 if (error_state) |
| 4871 break; | |
| 4872 } | |
| 4873 } | |
| 4874 | |
| 4875 if (! error_state && (empty_dim > 0)) | |
| 4876 { | |
| 4877 int nel = 1; | |
| 4878 for (int i = 0; i < nargin - 1; i++) | |
| 4879 nel *= new_size(i); | |
| 4880 | |
| 4881 if (nel == 0) | |
| 4882 new_size(empty_dim-1) = 0; | |
| 4883 else | |
| 4884 { | |
| 4885 int size_empty_dim = args(0).numel () / nel; | |
| 4886 | |
| 4887 if (args(0).numel () != size_empty_dim * nel) | |
| 4888 error ("reshape: size is not divisble by the product of known dimensions (= %d)", nel); | |
| 4889 else | |
| 4890 new_size(empty_dim-1) = size_empty_dim; | |
| 4891 } | |
| 4567 | 4892 } |
| 4893 } | |
| 4894 else | |
| 4895 { | |
| 5823 | 4896 print_usage (); |
| 4567 | 4897 return retval; |
| 4898 } | |
| 4899 | |
| 4900 if (error_state) | |
| 4901 { | |
| 4902 error ("reshape: invalid arguments"); | |
| 4903 return retval; | |
| 4904 } | |
| 4905 | |
| 4739 | 4906 // Remove trailing singletons in new_size, but leave at least 2 |
| 4907 // elements. | |
| 4908 | |
| 4567 | 4909 int n = new_size.length (); |
| 4910 | |
| 4739 | 4911 while (n > 2) |
| 4912 { | |
| 4913 if (new_size(n-1) == 1) | |
| 4914 n--; | |
| 4915 else | |
| 4916 break; | |
| 4917 } | |
| 4918 | |
| 4919 new_size.resize (n); | |
| 4920 | |
| 4567 | 4921 if (n < 2) |
| 4922 { | |
| 4923 error ("reshape: expecting size to be vector with at least 2 elements"); | |
| 4924 return retval; | |
| 4925 } | |
| 4926 | |
| 4927 dim_vector new_dims; | |
| 4928 | |
| 4929 new_dims.resize (n); | |
| 4930 | |
| 5275 | 4931 for (octave_idx_type i = 0; i < n; i++) |
| 4567 | 4932 new_dims(i) = new_size(i); |
| 4933 | |
| 4934 octave_value arg = args(0); | |
| 4935 | |
|
8526
17e0ad741fac
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8517
diff
changeset
|
4936 dim_vector dims = arg.dims (); |
|
17e0ad741fac
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8517
diff
changeset
|
4937 |
|
17e0ad741fac
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8517
diff
changeset
|
4938 if (new_dims.numel () == dims.numel ()) |
|
17e0ad741fac
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8517
diff
changeset
|
4939 retval = (new_dims == dims) ? arg : arg.reshape (new_dims); |
| 4567 | 4940 else |
|
8527
6b074f37e8d7
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8526
diff
changeset
|
4941 { |
|
6b074f37e8d7
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8526
diff
changeset
|
4942 std::string dims_str = dims.str (); |
|
6b074f37e8d7
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8526
diff
changeset
|
4943 std::string new_dims_str = new_dims.str (); |
|
6b074f37e8d7
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8526
diff
changeset
|
4944 |
|
6b074f37e8d7
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8526
diff
changeset
|
4945 error ("reshape: can't reshape %s array to %s array", |
|
6b074f37e8d7
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8526
diff
changeset
|
4946 dims_str.c_str (), new_dims_str.c_str ()); |
|
6b074f37e8d7
reshape: improve error message
John W. Eaton <jwe@octave.org>
parents:
8526
diff
changeset
|
4947 } |
| 4567 | 4948 |
| 4949 return retval; | |
| 4950 } | |
| 4951 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4952 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4953 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4954 %!assert(size (reshape (ones (4, 4), 2, 8)), [2, 8]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4955 %!assert(size (reshape (ones (4, 4), 8, 2)), [8, 2]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4956 %!assert(size (reshape (ones (15, 4), 1, 60)), [1, 60]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4957 %!assert(size (reshape (ones (15, 4), 60, 1)), [60, 1]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4958 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4959 %!assert(size (reshape (ones (4, 4, 'single'), 2, 8)), [2, 8]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4960 %!assert(size (reshape (ones (4, 4, 'single'), 8, 2)), [8, 2]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4961 %!assert(size (reshape (ones (15, 4, 'single'), 1, 60)), [1, 60]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4962 %!assert(size (reshape (ones (15, 4, 'single'), 60, 1)), [60, 1]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4963 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4964 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4965 %! s.a = 1; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4966 %! fail("reshape (s, 2, 3)"); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4967 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4968 %!error <Invalid call to reshape.*> reshape (); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4969 %!error reshape (1, 2, 3, 4); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4970 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4971 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4972 |
| 4532 | 4973 DEFUN (squeeze, args, , |
| 4974 "-*- texinfo -*-\n\ | |
| 4975 @deftypefn {Built-in Function} {} squeeze (@var{x})\n\ | |
| 4976 Remove singleton dimensions from @var{x} and return the result.\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
4977 Note that for compatibility with @sc{matlab}, all objects have\n\ |
| 7007 | 4978 a minimum of two dimensions and row vectors are left unchanged.\n\ |
| 4532 | 4979 @end deftypefn") |
| 4980 { | |
| 4981 octave_value retval; | |
| 4982 | |
| 4983 if (args.length () == 1) | |
| 4545 | 4984 retval = args(0).squeeze (); |
| 4532 | 4985 else |
| 5823 | 4986 print_usage (); |
| 4532 | 4987 |
| 4988 return retval; | |
| 4989 } | |
| 4990 | |
|
8458
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
4991 DEFUN (full, args, , |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
4992 "-*- texinfo -*-\n\ |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
4993 @deftypefn {Loadable Function} {@var{FM} =} full (@var{SM})\n\ |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
4994 returns a full storage matrix from a sparse, diagonal, permutation matrix or a range.\n\ |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
4995 @seealso{sparse}\n\ |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
4996 @end deftypefn") |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
4997 { |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
4998 octave_value retval; |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
4999 |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
5000 if (args.length () == 1) |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
5001 retval = args(0).full_value (); |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
5002 else |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
5003 print_usage (); |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
5004 |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
5005 return retval; |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
5006 } |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8433
diff
changeset
|
5007 |
| 6945 | 5008 // Compute various norms of the vector X. |
| 5009 | |
| 6953 | 5010 DEFUN (norm, args, , |
| 6508 | 5011 "-*- texinfo -*-\n\ |
|
9517
a85dbf7b6ff9
fix some functions help markup
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
5012 @deftypefn {Built-in Function} {} norm (@var{a}, @var{p}, @var{opt})\n\ |
| 6953 | 5013 Compute the p-norm of the matrix @var{a}. If the second argument is\n\ |
| 5014 missing, @code{p = 2} is assumed.\n\ | |
| 5015 \n\ | |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5016 If @var{a} is a matrix (or sparse matrix):\n\ |
| 6953 | 5017 \n\ |
| 5018 @table @asis\n\ | |
| 5019 @item @var{p} = @code{1}\n\ | |
| 5020 1-norm, the largest column sum of the absolute values of @var{a}.\n\ | |
| 5021 \n\ | |
| 5022 @item @var{p} = @code{2}\n\ | |
| 5023 Largest singular value of @var{a}.\n\ | |
| 5024 \n\ | |
| 7189 | 5025 @item @var{p} = @code{Inf} or @code{\"inf\"}\n\ |
| 6953 | 5026 @cindex infinity norm\n\ |
| 5027 Infinity norm, the largest row sum of the absolute values of @var{a}.\n\ | |
| 5028 \n\ | |
| 5029 @item @var{p} = @code{\"fro\"}\n\ | |
| 5030 @cindex Frobenius norm\n\ | |
| 5031 Frobenius norm of @var{a}, @code{sqrt (sum (diag (@var{a}' * @var{a})))}.\n\ | |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5032 \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5033 @item other @var{p}, @code{@var{p} > 1}\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5034 @cindex general p-norm \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5035 maximum @code{norm (A*x, p)} such that @code{norm (x, p) == 1}\n\ |
| 6953 | 5036 @end table\n\ |
| 5037 \n\ | |
| 5038 If @var{a} is a vector or a scalar:\n\ | |
| 5039 \n\ | |
| 5040 @table @asis\n\ | |
| 7189 | 5041 @item @var{p} = @code{Inf} or @code{\"inf\"}\n\ |
| 6953 | 5042 @code{max (abs (@var{a}))}.\n\ |
| 5043 \n\ | |
| 5044 @item @var{p} = @code{-Inf}\n\ | |
| 5045 @code{min (abs (@var{a}))}.\n\ | |
| 5046 \n\ | |
| 7189 | 5047 @item @var{p} = @code{\"fro\"}\n\ |
| 5048 Frobenius norm of @var{a}, @code{sqrt (sumsq (abs (a)))}.\n\ | |
| 5049 \n\ | |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5050 @item @var{p} = 0\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5051 Hamming norm - the number of nonzero elements.\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5052 \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5053 @item other @var{p}, @code{@var{p} > 1}\n\ |
| 6953 | 5054 p-norm of @var{a}, @code{(sum (abs (@var{a}) .^ @var{p})) ^ (1/@var{p})}.\n\ |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5055 \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5056 @item other @var{p} @code{@var{p} < 1}\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5057 the p-pseudonorm defined as above.\n\ |
| 6953 | 5058 @end table\n\ |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5059 \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5060 If @code{\"rows\"} is given as @var{opt}, the norms of all rows of the matrix @var{a} are\n\ |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
5061 returned as a column vector. Similarly, if @code{\"columns\"} or @code{\"cols\"} is passed\n\ |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5062 column norms are computed.\n\ |
| 6953 | 5063 @seealso{cond, svd}\n\ |
| 6508 | 5064 @end deftypefn") |
| 5065 { | |
| 6953 | 5066 octave_value_list retval; |
| 6508 | 5067 |
| 5068 int nargin = args.length (); | |
| 5069 | |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5070 if (nargin >= 1 && nargin <= 3) |
| 6508 | 5071 { |
| 6953 | 5072 octave_value x_arg = args(0); |
| 5073 | |
| 5074 if (x_arg.is_empty ()) | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5075 { |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5076 if (x_arg.is_single_type ()) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5077 retval(0) = static_cast<float>(0.0); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5078 else |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5079 retval(0) = 0.0; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5080 } |
| 6953 | 5081 else if (x_arg.ndims () == 2) |
| 6508 | 5082 { |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5083 enum { sfmatrix, sfcols, sfrows, sffrob, sfinf } strflag = sfmatrix; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5084 if (nargin > 1 && args(nargin-1).is_string ()) |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5085 { |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5086 std::string str = args(nargin-1).string_value (); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5087 if (str == "cols" || str == "columns") |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5088 strflag = sfcols; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5089 else if (str == "rows") |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5090 strflag = sfrows; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5091 else if (str == "fro") |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5092 strflag = sffrob; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5093 else if (str == "inf") |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5094 strflag = sfinf; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5095 else |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5096 error ("norm: unrecognized option: %s", str.c_str ()); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5097 // we've handled the last parameter, so act as if it was removed |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5098 nargin --; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5099 } |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5100 else if (nargin > 1 && ! args(1).is_scalar_type ()) |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5101 gripe_wrong_type_arg ("norm", args(1), true); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5102 |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5103 if (! error_state) |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5104 { |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5105 octave_value p_arg = (nargin > 1) ? args(1) : octave_value (2); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5106 switch (strflag) |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5107 { |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5108 case sfmatrix: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5109 retval(0) = xnorm (x_arg, p_arg); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5110 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5111 case sfcols: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5112 retval(0) = xcolnorms (x_arg, p_arg); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5113 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5114 case sfrows: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5115 retval(0) = xrownorms (x_arg, p_arg); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5116 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5117 case sffrob: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5118 retval(0) = xfrobnorm (x_arg); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5119 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5120 case sfinf: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5121 retval(0) = xnorm (x_arg, octave_Inf); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5122 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5123 } |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
5124 } |
| 6508 | 5125 } |
| 5126 else | |
| 6953 | 5127 error ("norm: only valid for 2-D objects"); |
| 6508 | 5128 } |
| 5129 else | |
| 5130 print_usage (); | |
| 5131 | |
| 5132 return retval; | |
| 5133 } | |
| 5134 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5135 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5136 %!shared x |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5137 %! x = [1, -3, 4, 5, -7]; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5138 %!assert(norm(x,1), 20); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5139 %!assert(norm(x,2), 10); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5140 %!assert(norm(x,3), 8.24257059961711, -4*eps); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5141 %!assert(norm(x,Inf), 7); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5142 %!assert(norm(x,-Inf), 1); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5143 %!assert(norm(x,"inf"), 7); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5144 %!assert(norm(x,"fro"), 10, -eps); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5145 %!assert(norm(x), 10); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5146 %!assert(norm([1e200, 1]), 1e200); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5147 %!assert(norm([3+4i, 3-4i, sqrt(31)]), 9, -4*eps); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5148 %!shared m |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5149 %! m = magic (4); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5150 %!assert(norm(m,1), 34); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5151 %!assert(norm(m,2), 34, -eps); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5152 %!assert(norm(m,Inf), 34); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5153 %!assert(norm(m,"inf"), 34); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5154 %!shared m2, flo, fhi |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5155 %! m2 = [1,2;3,4]; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5156 %! flo = 1e-300; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5157 %! fhi = 1e+300; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5158 %!assert (norm(flo*m2,"fro"), sqrt(30)*flo, -eps) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5159 %!assert (norm(fhi*m2,"fro"), sqrt(30)*fhi, -eps) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5160 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5161 %!shared x |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5162 %! x = single([1, -3, 4, 5, -7]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5163 %!assert(norm(x,1), single(20)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5164 %!assert(norm(x,2), single(10)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5165 %!assert(norm(x,3), single(8.24257059961711), -4*eps('single')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5166 %!assert(norm(x,Inf), single(7)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5167 %!assert(norm(x,-Inf), single(1)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5168 %!assert(norm(x,"inf"), single(7)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5169 %!assert(norm(x,"fro"), single(10), -eps('single')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5170 %!assert(norm(x), single(10)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5171 %!assert(norm(single([1e200, 1])), single(1e200)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5172 %!assert(norm(single([3+4i, 3-4i, sqrt(31)])), single(9), -4*eps('single')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5173 %!shared m |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5174 %! m = single(magic (4)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5175 %!assert(norm(m,1), single(34)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5176 %!assert(norm(m,2), single(34), -eps('single')); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5177 %!assert(norm(m,Inf), single(34)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5178 %!assert(norm(m,"inf"), single(34)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5179 %!shared m2, flo, fhi |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5180 %! m2 = single([1,2;3,4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5181 %! flo = single(1e-300); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5182 %! fhi = single(1e+300); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5183 %!assert (norm(flo*m2,"fro"), single(sqrt(30)*flo), -eps('single')) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5184 %!assert (norm(fhi*m2,"fro"), single(sqrt(30)*fhi), -eps('single')) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5185 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5186 |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5187 static octave_value |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5188 unary_op_defun_body (octave_value::unary_op op, |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5189 const octave_value_list& args) |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5190 { |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5191 octave_value retval; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5192 if (args.length () == 1) |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5193 retval = do_unary_op (op, args(0)); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5194 else |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5195 print_usage (); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5196 |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5197 return retval; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5198 } |
| 6518 | 5199 |
| 5200 DEFUN (not, args, , | |
| 5201 "-*- texinfo -*-\n\ | |
| 5202 @deftypefn {Built-in Function} {} not (@var{x})\n\ | |
| 5203 This function is equivalent to @code{! x}.\n\ | |
| 5204 @end deftypefn") | |
| 5205 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5206 return unary_op_defun_body (octave_value::op_not, args); |
| 6518 | 5207 } |
| 5208 | |
| 5209 DEFUN (uplus, args, , | |
| 5210 "-*- texinfo -*-\n\ | |
| 5211 @deftypefn {Built-in Function} {} uplus (@var{x})\n\ | |
| 5212 This function is equivalent to @code{+ x}.\n\ | |
| 5213 @end deftypefn") | |
| 5214 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5215 return unary_op_defun_body (octave_value::op_uplus, args); |
| 6518 | 5216 } |
| 5217 | |
| 5218 DEFUN (uminus, args, , | |
| 5219 "-*- texinfo -*-\n\ | |
| 5220 @deftypefn {Built-in Function} {} uminus (@var{x})\n\ | |
| 5221 This function is equivalent to @code{- x}.\n\ | |
| 5222 @end deftypefn") | |
| 5223 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5224 return unary_op_defun_body (octave_value::op_uminus, args); |
| 6518 | 5225 } |
| 5226 | |
| 5227 DEFUN (transpose, args, , | |
| 5228 "-*- texinfo -*-\n\ | |
| 5229 @deftypefn {Built-in Function} {} transpose (@var{x})\n\ | |
| 5230 This function is equivalent to @code{x.'}.\n\ | |
| 5231 @end deftypefn") | |
| 5232 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5233 return unary_op_defun_body (octave_value::op_transpose, args); |
| 6518 | 5234 } |
| 5235 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5236 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5237 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5238 %!assert (2.', 2); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5239 %!assert (2i.',2i); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5240 %!assert ([1:4].',[1;2;3;4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5241 %!assert ([1;2;3;4].',[1:4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5242 %!assert ([1,2;3,4].',[1,3;2,4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5243 %!assert ([1,2i;3,4].',[1,3;2i,4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5244 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5245 %!assert (transpose ([1,2;3,4]),[1,3;2,4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5246 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5247 %!assert (single(2).', single(2)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5248 %!assert (single(2i).',single(2i)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5249 %!assert (single([1:4]).',single([1;2;3;4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5250 %!assert (single([1;2;3;4]).',single([1:4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5251 %!assert (single([1,2;3,4]).',single([1,3;2,4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5252 %!assert (single([1,2i;3,4]).',single([1,3;2i,4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5253 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5254 %!assert (transpose (single([1,2;3,4])),single([1,3;2,4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5255 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5256 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5257 |
| 6518 | 5258 DEFUN (ctranspose, args, , |
| 5259 "-*- texinfo -*-\n\ | |
| 5260 @deftypefn {Built-in Function} {} ctranspose (@var{x})\n\ | |
| 5261 This function is equivalent to @code{x'}.\n\ | |
| 5262 @end deftypefn") | |
| 5263 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5264 return unary_op_defun_body (octave_value::op_hermitian, args); |
| 6518 | 5265 } |
| 5266 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5267 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5268 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5269 %!assert (2', 2); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5270 %!assert (2i',-2i); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5271 %!assert ([1:4]',[1;2;3;4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5272 %!assert ([1;2;3;4]',[1:4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5273 %!assert ([1,2;3,4]',[1,3;2,4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5274 %!assert ([1,2i;3,4]',[1,3;-2i,4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5275 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5276 %!assert (ctranspose ([1,2i;3,4]),[1,3;-2i,4]); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5277 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5278 %!assert (single(2)', single(2)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5279 %!assert (single(2i)',single(-2i)); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5280 %!assert (single([1:4])',single([1;2;3;4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5281 %!assert (single([1;2;3;4])',single([1:4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5282 %!assert (single([1,2;3,4])',single([1,3;2,4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5283 %!assert (single([1,2i;3,4])',single([1,3;-2i,4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5284 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5285 %!assert (ctranspose (single([1,2i;3,4])),single([1,3;-2i,4])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5286 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5287 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5288 |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5289 static octave_value |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5290 binary_op_defun_body (octave_value::binary_op op, |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5291 const octave_value_list& args) |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5292 { |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5293 octave_value retval; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5294 |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5295 if (args.length () == 2) |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5296 retval = do_binary_op (op, args(0), args(1)); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5297 else |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5298 print_usage (); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5299 |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5300 return retval; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5301 } |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5302 |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5303 static octave_value |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5304 binary_assoc_op_defun_body (octave_value::binary_op op, |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5305 octave_value::assign_op aop, |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5306 const octave_value_list& args) |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5307 { |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5308 octave_value retval; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5309 int nargin = args.length (); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5310 |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5311 switch (nargin) |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5312 { |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5313 case 0: |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5314 print_usage (); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5315 break; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5316 case 1: |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5317 retval = args(0); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5318 break; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5319 case 2: |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5320 retval = do_binary_op (op, args(0), args(1)); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5321 break; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5322 default: |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5323 retval = do_binary_op (op, args(0), args(1)); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5324 for (int i = 2; i < nargin; i++) |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5325 retval.assign (aop, args(i)); |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5326 break; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5327 } |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5328 |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5329 return retval; |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5330 } |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5331 |
| 6518 | 5332 DEFUN (plus, args, , |
| 5333 "-*- texinfo -*-\n\ | |
| 5334 @deftypefn {Built-in Function} {} plus (@var{x}, @var{y})\n\ | |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5335 @deftypefnx {Built-in Function} {} plus (@var{x1}, @var{x2}, @dots{})\n\ |
| 6518 | 5336 This function is equivalent to @code{x + y}.\n\ |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5337 If more arguments are given, the summation is applied\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5338 cumulatively from left to right:\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5339 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5340 @example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5341 (@dots{}((x1 + x2) + x3) + @dots{})\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5342 @end example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5343 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5344 At least one argument is needed.\n\ |
| 6518 | 5345 @end deftypefn") |
| 5346 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5347 return binary_assoc_op_defun_body (octave_value::op_add, |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5348 octave_value::op_add_eq, args); |
| 6518 | 5349 } |
| 5350 | |
| 5351 DEFUN (minus, args, , | |
| 5352 "-*- texinfo -*-\n\ | |
| 5353 @deftypefn {Built-in Function} {} minus (@var{x}, @var{y})\n\ | |
| 5354 This function is equivalent to @code{x - y}.\n\ | |
| 5355 @end deftypefn") | |
| 5356 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5357 return binary_op_defun_body (octave_value::op_sub, args); |
| 6518 | 5358 } |
| 5359 | |
| 5360 DEFUN (mtimes, args, , | |
| 5361 "-*- texinfo -*-\n\ | |
| 5362 @deftypefn {Built-in Function} {} mtimes (@var{x}, @var{y})\n\ | |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5363 @deftypefnx {Built-in Function} {} mtimes (@var{x1}, @var{x2}, @dots{})\n\ |
| 6518 | 5364 This function is equivalent to @code{x * y}.\n\ |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5365 If more arguments are given, the multiplication is applied\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5366 cumulatively from left to right:\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5367 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5368 @example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5369 (@dots{}((x1 * x2) * x3) * @dots{})\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5370 @end example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5371 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5372 At least one argument is needed.\n\ |
| 6518 | 5373 @end deftypefn") |
| 5374 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5375 return binary_assoc_op_defun_body (octave_value::op_mul, |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5376 octave_value::op_mul_eq, args); |
| 6518 | 5377 } |
| 5378 | |
| 5379 DEFUN (mrdivide, args, , | |
| 5380 "-*- texinfo -*-\n\ | |
| 5381 @deftypefn {Built-in Function} {} mrdivide (@var{x}, @var{y})\n\ | |
| 5382 This function is equivalent to @code{x / y}.\n\ | |
| 5383 @end deftypefn") | |
| 5384 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5385 return binary_op_defun_body (octave_value::op_div, args); |
| 6518 | 5386 } |
| 5387 | |
| 5388 DEFUN (mpower, args, , | |
| 5389 "-*- texinfo -*-\n\ | |
| 5390 @deftypefn {Built-in Function} {} mpower (@var{x}, @var{y})\n\ | |
| 5391 This function is equivalent to @code{x ^ y}.\n\ | |
| 5392 @end deftypefn") | |
| 5393 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5394 return binary_op_defun_body (octave_value::op_pow, args); |
| 6518 | 5395 } |
| 5396 | |
| 5397 DEFUN (mldivide, args, , | |
| 5398 "-*- texinfo -*-\n\ | |
| 5399 @deftypefn {Built-in Function} {} mldivide (@var{x}, @var{y})\n\ | |
| 5400 This function is equivalent to @code{x \\ y}.\n\ | |
| 5401 @end deftypefn") | |
| 5402 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5403 return binary_op_defun_body (octave_value::op_ldiv, args); |
| 6518 | 5404 } |
| 5405 | |
| 5406 DEFUN (lt, args, , | |
| 5407 "-*- texinfo -*-\n\ | |
| 5408 @deftypefn {Built-in Function} {} lt (@var{x}, @var{y})\n\ | |
| 5409 This function is equivalent to @code{x < y}.\n\ | |
| 5410 @end deftypefn") | |
| 5411 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5412 return binary_op_defun_body (octave_value::op_lt, args); |
| 6518 | 5413 } |
| 5414 | |
| 5415 DEFUN (le, args, , | |
| 5416 "-*- texinfo -*-\n\ | |
| 5417 @deftypefn {Built-in Function} {} le (@var{x}, @var{y})\n\ | |
| 5418 This function is equivalent to @code{x <= y}.\n\ | |
| 5419 @end deftypefn") | |
| 5420 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5421 return binary_op_defun_body (octave_value::op_le, args); |
| 6518 | 5422 } |
| 5423 | |
| 5424 DEFUN (eq, args, , | |
| 5425 "-*- texinfo -*-\n\ | |
| 5426 @deftypefn {Built-in Function} {} eq (@var{x}, @var{y})\n\ | |
| 5427 This function is equivalent to @code{x == y}.\n\ | |
| 5428 @end deftypefn") | |
| 5429 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5430 return binary_op_defun_body (octave_value::op_eq, args); |
| 6518 | 5431 } |
| 5432 | |
| 5433 DEFUN (ge, args, , | |
| 5434 "-*- texinfo -*-\n\ | |
| 5435 @deftypefn {Built-in Function} {} ge (@var{x}, @var{y})\n\ | |
| 5436 This function is equivalent to @code{x >= y}.\n\ | |
| 5437 @end deftypefn") | |
| 5438 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5439 return binary_op_defun_body (octave_value::op_ge, args); |
| 6518 | 5440 } |
| 5441 | |
| 5442 DEFUN (gt, args, , | |
| 5443 "-*- texinfo -*-\n\ | |
| 5444 @deftypefn {Built-in Function} {} gt (@var{x}, @var{y})\n\ | |
| 5445 This function is equivalent to @code{x > y}.\n\ | |
| 5446 @end deftypefn") | |
| 5447 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5448 return binary_op_defun_body (octave_value::op_gt, args); |
| 6518 | 5449 } |
| 5450 | |
| 5451 DEFUN (ne, args, , | |
| 5452 "-*- texinfo -*-\n\ | |
| 5453 @deftypefn {Built-in Function} {} ne (@var{x}, @var{y})\n\ | |
| 5454 This function is equivalent to @code{x != y}.\n\ | |
| 5455 @end deftypefn") | |
| 5456 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5457 return binary_op_defun_body (octave_value::op_ne, args); |
| 6518 | 5458 } |
| 5459 | |
| 5460 DEFUN (times, args, , | |
| 5461 "-*- texinfo -*-\n\ | |
| 5462 @deftypefn {Built-in Function} {} times (@var{x}, @var{y})\n\ | |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5463 @deftypefnx {Built-in Function} {} times (@var{x1}, @var{x2}, @dots{})\n\ |
| 6518 | 5464 This function is equivalent to @code{x .* y}.\n\ |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5465 If more arguments are given, the multiplication is applied\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5466 cumulatively from left to right:\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5467 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5468 @example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5469 (@dots{}((x1 .* x2) .* x3) .* @dots{})\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5470 @end example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5471 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5472 At least one argument is needed.\n\ |
| 6518 | 5473 @end deftypefn") |
| 5474 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5475 return binary_assoc_op_defun_body (octave_value::op_el_mul, |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5476 octave_value::op_el_mul_eq, args); |
| 6518 | 5477 } |
| 5478 | |
| 5479 DEFUN (rdivide, args, , | |
| 5480 "-*- texinfo -*-\n\ | |
| 5481 @deftypefn {Built-in Function} {} rdivide (@var{x}, @var{y})\n\ | |
| 5482 This function is equivalent to @code{x ./ y}.\n\ | |
| 5483 @end deftypefn") | |
| 5484 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5485 return binary_op_defun_body (octave_value::op_el_div, args); |
| 6518 | 5486 } |
| 5487 | |
| 5488 DEFUN (power, args, , | |
| 5489 "-*- texinfo -*-\n\ | |
| 5490 @deftypefn {Built-in Function} {} power (@var{x}, @var{y})\n\ | |
| 7623 | 5491 This function is equivalent to @code{x .^ y}.\n\ |
| 6518 | 5492 @end deftypefn") |
| 5493 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5494 return binary_op_defun_body (octave_value::op_el_pow, args); |
| 6518 | 5495 } |
| 5496 | |
| 5497 DEFUN (ldivide, args, , | |
| 5498 "-*- texinfo -*-\n\ | |
| 5499 @deftypefn {Built-in Function} {} ldivide (@var{x}, @var{y})\n\ | |
| 7623 | 5500 This function is equivalent to @code{x .\\ y}.\n\ |
| 6518 | 5501 @end deftypefn") |
| 5502 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5503 return binary_op_defun_body (octave_value::op_el_ldiv, args); |
| 6518 | 5504 } |
| 5505 | |
| 5506 DEFUN (and, args, , | |
| 5507 "-*- texinfo -*-\n\ | |
| 5508 @deftypefn {Built-in Function} {} and (@var{x}, @var{y})\n\ | |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5509 @deftypefnx {Built-in Function} {} and (@var{x1}, @var{x2}, @dots{})\n\ |
| 6518 | 5510 This function is equivalent to @code{x & y}.\n\ |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5511 If more arguments are given, the logical and is applied\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5512 cumulatively from left to right:\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5513 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5514 @example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5515 (@dots{}((x1 & x2) & x3) & @dots{})\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5516 @end example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5517 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5518 At least one argument is needed.\n\ |
| 6518 | 5519 @end deftypefn") |
| 5520 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5521 return binary_assoc_op_defun_body (octave_value::op_el_and, |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5522 octave_value::op_el_and_eq, args); |
| 6518 | 5523 } |
| 5524 | |
| 5525 DEFUN (or, args, , | |
| 5526 "-*- texinfo -*-\n\ | |
| 5527 @deftypefn {Built-in Function} {} or (@var{x}, @var{y})\n\ | |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5528 @deftypefnx {Built-in Function} {} or (@var{x1}, @var{x2}, @dots{})\n\ |
| 6518 | 5529 This function is equivalent to @code{x | y}.\n\ |
|
9339
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5530 If more arguments are given, the logical or is applied\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5531 cumulatively from left to right:\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5532 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5533 @example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5534 (@dots{}((x1 | x2) | x3) | @dots{})\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5535 @end example\n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5536 \n\ |
|
c0b104835d0d
allow multiple arguments in plus,times,mtimes,and,or
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
5537 At least one argument is needed.\n\ |
| 6518 | 5538 @end deftypefn") |
| 5539 { | |
|
9555
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5540 return binary_assoc_op_defun_body (octave_value::op_el_or, |
|
76ecc571879e
improve unop/binop implementation in data.cc
Jaroslav Hajek <highegg@gmail.com>
parents:
9517
diff
changeset
|
5541 octave_value::op_el_or_eq, args); |
| 6518 | 5542 } |
| 5543 | |
| 7065 | 5544 static double tic_toc_timestamp = -1.0; |
| 7045 | 5545 |
| 5546 DEFUN (tic, args, nargout, | |
| 5547 "-*- texinfo -*-\n\ | |
| 5548 @deftypefn {Built-in Function} {} tic ()\n\ | |
| 5549 @deftypefnx {Built-in Function} {} toc ()\n\ | |
| 5550 Set or check a wall-clock timer. Calling @code{tic} without an\n\ | |
| 5551 output argument sets the timer. Subsequent calls to @code{toc}\n\ | |
| 5552 return the number of seconds since the timer was set. For example,\n\ | |
| 5553 \n\ | |
| 5554 @example\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
5555 @group\n\ |
| 7045 | 5556 tic ();\n\ |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
5557 # many computations later@dots{}\n\ |
| 7045 | 5558 elapsed_time = toc ();\n\ |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
9041
diff
changeset
|
5559 @end group\n\ |
| 7045 | 5560 @end example\n\ |
| 5561 \n\ | |
| 5562 @noindent\n\ | |
| 5563 will set the variable @code{elapsed_time} to the number of seconds since\n\ | |
| 5564 the most recent call to the function @code{tic}.\n\ | |
| 5565 \n\ | |
| 5566 If called with one output argument then this function returns a scalar\n\ | |
| 5567 of type @code{uint64} and the wall-clock timer is not started.\n\ | |
| 5568 \n\ | |
| 5569 @example\n\ | |
| 5570 @group\n\ | |
| 5571 t = tic; sleep (5); (double (tic ()) - double (t)) * 1e-6\n\ | |
| 5572 @result{} 5\n\ | |
| 5573 @end group\n\ | |
| 5574 @end example\n\ | |
| 5575 \n\ | |
| 5576 Nested timing with @code{tic} and @code{toc} is not supported.\n\ | |
| 5577 Therefore @code{toc} will always return the elapsed time from the most\n\ | |
| 5578 recent call to @code{tic}.\n\ | |
| 5579 \n\ | |
| 5580 If you are more interested in the CPU time that your process used, you\n\ | |
| 5581 should use the @code{cputime} function instead. The @code{tic} and\n\ | |
| 5582 @code{toc} functions report the actual wall clock time that elapsed\n\ | |
| 5583 between the calls. This may include time spent processing other jobs or\n\ | |
| 5584 doing nothing at all. For example,\n\ | |
| 5585 \n\ | |
| 5586 @example\n\ | |
| 5587 @group\n\ | |
| 5588 tic (); sleep (5); toc ()\n\ | |
| 5589 @result{} 5\n\ | |
| 5590 t = cputime (); sleep (5); cputime () - t\n\ | |
| 5591 @result{} 0\n\ | |
| 5592 @end group\n\ | |
| 5593 @end example\n\ | |
| 5594 \n\ | |
| 5595 @noindent\n\ | |
| 5596 (This example also illustrates that the CPU timer may have a fairly\n\ | |
| 5597 coarse resolution.)\n\ | |
| 5598 @end deftypefn") | |
| 5599 { | |
| 5600 octave_value retval; | |
| 7065 | 5601 |
| 7045 | 5602 int nargin = args.length (); |
| 5603 | |
| 5604 if (nargin != 0) | |
| 5605 warning ("tic: ignoring extra arguments"); | |
| 5606 | |
| 7065 | 5607 octave_time now; |
| 5608 | |
| 5609 double tmp = now.double_value (); | |
| 5610 | |
| 7045 | 5611 if (nargout > 0) |
| 7065 | 5612 retval = static_cast<octave_uint64> (1e6 * tmp); |
| 7045 | 5613 else |
| 7065 | 5614 tic_toc_timestamp = tmp; |
| 7045 | 5615 |
| 5616 return retval; | |
| 5617 } | |
| 5618 | |
| 5619 DEFUN (toc, args, nargout, | |
| 5620 "-*- texinfo -*-\n\ | |
| 5621 @deftypefn {Built-in Function} {} toc ()\n\ | |
| 5622 See tic.\n\ | |
| 5623 @end deftypefn") | |
| 5624 { | |
| 5625 octave_value retval; | |
| 7065 | 5626 |
| 7045 | 5627 int nargin = args.length (); |
| 5628 | |
| 5629 if (nargin != 0) | |
| 5630 warning ("tic: ignoring extra arguments"); | |
| 5631 | |
| 7065 | 5632 if (tic_toc_timestamp < 0) |
| 7045 | 5633 { |
| 5634 warning ("toc called before timer set"); | |
| 5635 if (nargout > 0) | |
| 7065 | 5636 retval = Matrix (); |
| 7045 | 5637 } |
| 5638 else | |
| 7065 | 5639 { |
| 5640 octave_time now; | |
| 5641 | |
| 5642 double tmp = now.double_value () - tic_toc_timestamp; | |
| 5643 | |
| 5644 if (nargout > 0) | |
| 5645 retval = tmp; | |
| 5646 else | |
| 5647 octave_stdout << "Elapsed time is " << tmp << " seconds.\n"; | |
| 5648 } | |
| 7045 | 5649 |
| 5650 return retval; | |
| 5651 } | |
| 5652 | |
| 5653 DEFUN (cputime, args, , | |
| 5654 "-*- texinfo -*-\n\ | |
| 5655 @deftypefn {Built-in Function} {[@var{total}, @var{user}, @var{system}] =} cputime ();\n\ | |
| 5656 Return the CPU time used by your Octave session. The first output is\n\ | |
| 5657 the total time spent executing your process and is equal to the sum of\n\ | |
| 5658 second and third outputs, which are the number of CPU seconds spent\n\ | |
| 5659 executing in user mode and the number of CPU seconds spent executing in\n\ | |
| 5660 system mode, respectively. If your system does not have a way to report\n\ | |
| 5661 CPU time usage, @code{cputime} returns 0 for each of its output values.\n\ | |
| 5662 Note that because Octave used some CPU time to start, it is reasonable\n\ | |
| 5663 to check to see if @code{cputime} works by checking to see if the total\n\ | |
| 5664 CPU time used is nonzero.\n\ | |
| 5665 @end deftypefn") | |
| 5666 { | |
| 5667 octave_value_list retval; | |
| 5668 int nargin = args.length (); | |
| 5669 double usr = 0.0; | |
| 5670 double sys = 0.0; | |
| 5671 | |
| 5672 if (nargin != 0) | |
| 5673 warning ("tic: ignoring extra arguments"); | |
| 5674 | |
| 5675 #if defined (HAVE_GETRUSAGE) | |
| 5676 | |
| 5677 struct rusage ru; | |
| 5678 | |
| 5679 getrusage (RUSAGE_SELF, &ru); | |
| 5680 | |
| 5681 usr = static_cast<double> (ru.ru_utime.tv_sec) + | |
| 5682 static_cast<double> (ru.ru_utime.tv_usec) * 1e-6; | |
| 5683 | |
| 5684 sys = static_cast<double> (ru.ru_stime.tv_sec) + | |
| 5685 static_cast<double> (ru.ru_stime.tv_usec) * 1e-6; | |
| 5686 | |
| 5687 #elif defined (HAVE_TIMES) && defined (HAVE_SYS_TIMES_H) | |
| 5688 | |
| 5689 struct tms t; | |
| 5690 | |
| 5691 times (&t); | |
| 5692 | |
| 5693 unsigned long ticks; | |
| 5694 unsigned long seconds; | |
| 5695 unsigned long fraction; | |
| 5696 | |
| 5697 ticks = t.tms_utime + t.tms_cutime; | |
| 5698 fraction = ticks % HZ; | |
| 5699 seconds = ticks / HZ; | |
| 5700 | |
| 5701 usr = static_cast<double> (seconds) + static_cast<double>(fraction) / | |
| 5702 static_cast<double>(HZ); | |
| 5703 | |
| 5704 ticks = t.tms_stime + t.tms_cstime; | |
| 5705 fraction = ticks % HZ; | |
| 5706 seconds = ticks / HZ; | |
| 5707 | |
| 5708 sys = static_cast<double> (seconds) + static_cast<double>(fraction) / | |
| 5709 static_cast<double>(HZ); | |
| 5710 | |
| 5711 #elif defined (__WIN32__) | |
| 7145 | 5712 |
| 7045 | 5713 HANDLE hProcess = GetCurrentProcess (); |
| 5714 FILETIME ftCreation, ftExit, ftUser, ftKernel; | |
| 5715 GetProcessTimes (hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser); | |
| 5716 | |
| 5717 int64_t itmp = *(reinterpret_cast<int64_t *> (&ftUser)); | |
| 7145 | 5718 usr = static_cast<double> (itmp) * 1e-7; |
| 7045 | 5719 |
| 5720 itmp = *(reinterpret_cast<int64_t *> (&ftKernel)); | |
| 7145 | 5721 sys = static_cast<double> (itmp) * 1e-7; |
| 7045 | 5722 |
| 5723 #endif | |
| 5724 | |
| 5725 retval (2) = sys; | |
| 5726 retval (1) = usr; | |
| 5727 retval (0) = sys + usr; | |
| 5728 | |
| 5729 return retval; | |
| 5730 } | |
| 5731 | |
| 7433 | 5732 DEFUN (sort, args, nargout, |
| 5733 "-*- texinfo -*-\n\ | |
| 5734 @deftypefn {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x})\n\ | |
| 5735 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{dim})\n\ | |
| 5736 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{mode})\n\ | |
| 5737 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{dim}, @var{mode})\n\ | |
| 5738 Return a copy of @var{x} with the elements arranged in increasing\n\ | |
| 5739 order. For matrices, @code{sort} orders the elements in each column.\n\ | |
| 5740 \n\ | |
| 5741 For example,\n\ | |
| 5742 \n\ | |
| 5743 @example\n\ | |
| 5744 @group\n\ | |
| 5745 sort ([1, 2; 2, 3; 3, 1])\n\ | |
| 5746 @result{} 1 1\n\ | |
| 5747 2 2\n\ | |
| 5748 3 3\n\ | |
| 5749 @end group\n\ | |
| 5750 @end example\n\ | |
| 5751 \n\ | |
| 5752 The @code{sort} function may also be used to produce a matrix\n\ | |
| 5753 containing the original row indices of the elements in the sorted\n\ | |
| 5754 matrix. For example,\n\ | |
| 5755 \n\ | |
| 5756 @example\n\ | |
| 5757 @group\n\ | |
| 5758 [s, i] = sort ([1, 2; 2, 3; 3, 1])\n\ | |
| 5759 @result{} s = 1 1\n\ | |
| 5760 2 2\n\ | |
| 5761 3 3\n\ | |
| 5762 @result{} i = 1 3\n\ | |
| 5763 2 1\n\ | |
| 5764 3 2\n\ | |
| 5765 @end group\n\ | |
| 5766 @end example\n\ | |
| 5767 \n\ | |
| 5768 If the optional argument @var{dim} is given, then the matrix is sorted\n\ | |
|
9041
853f96e8008f
Cleanup documentation file matrix.texi
Rik <rdrider0-list@yahoo.com>
parents:
8972
diff
changeset
|
5769 along the dimension defined by @var{dim}. The optional argument @code{mode}\n\ |
|
853f96e8008f
Cleanup documentation file matrix.texi
Rik <rdrider0-list@yahoo.com>
parents:
8972
diff
changeset
|
5770 defines the order in which the values will be sorted. Valid values of\n\ |
| 7433 | 5771 @code{mode} are `ascend' or `descend'.\n\ |
| 5772 \n\ | |
| 5773 For equal elements, the indices are such that the equal elements are listed\n\ | |
| 5774 in the order that appeared in the original list.\n\ | |
| 5775 \n\ | |
| 5776 The @code{sort} function may also be used to sort strings and cell arrays\n\ | |
| 5777 of strings, in which case the dictionary order of the strings is used.\n\ | |
| 5778 \n\ | |
| 5779 The algorithm used in @code{sort} is optimized for the sorting of partially\n\ | |
| 5780 ordered lists.\n\ | |
| 5781 @end deftypefn") | |
| 5782 { | |
| 5783 octave_value_list retval; | |
| 5784 | |
| 5785 int nargin = args.length (); | |
| 5786 sortmode smode = ASCENDING; | |
| 5787 | |
| 5788 if (nargin < 1 || nargin > 3) | |
| 5789 { | |
| 5790 print_usage (); | |
| 5791 return retval; | |
| 5792 } | |
| 5793 | |
| 5794 bool return_idx = nargout > 1; | |
| 5795 | |
| 5796 octave_value arg = args(0); | |
| 5797 | |
| 5798 int dim = 0; | |
| 5799 if (nargin > 1) | |
| 5800 { | |
| 5801 if (args(1).is_string ()) | |
| 5802 { | |
| 5803 std::string mode = args(1).string_value(); | |
| 5804 if (mode == "ascend") | |
| 5805 smode = ASCENDING; | |
| 5806 else if (mode == "descend") | |
| 5807 smode = DESCENDING; | |
| 5808 else | |
| 5809 { | |
| 5810 error ("sort: mode must be either \"ascend\" or \"descend\""); | |
| 5811 return retval; | |
| 5812 } | |
| 5813 } | |
| 5814 else | |
| 5815 dim = args(1).nint_value () - 1; | |
| 5816 } | |
| 5817 | |
| 5818 if (nargin > 2) | |
| 5819 { | |
| 5820 if (args(1).is_string ()) | |
| 5821 { | |
| 5822 print_usage (); | |
| 5823 return retval; | |
| 5824 } | |
| 5825 | |
| 5826 if (! args(2).is_string ()) | |
| 5827 { | |
| 5828 error ("sort: mode must be a string"); | |
| 5829 return retval; | |
| 5830 } | |
| 5831 std::string mode = args(2).string_value(); | |
| 5832 if (mode == "ascend") | |
| 5833 smode = ASCENDING; | |
| 5834 else if (mode == "descend") | |
| 5835 smode = DESCENDING; | |
| 5836 else | |
| 5837 { | |
| 5838 error ("sort: mode must be either \"ascend\" or \"descend\""); | |
| 5839 return retval; | |
| 5840 } | |
| 5841 } | |
| 5842 | |
| 5843 dim_vector dv = arg.dims (); | |
| 5844 if (error_state) | |
| 5845 { | |
| 5846 gripe_wrong_type_arg ("sort", arg); | |
| 5847 return retval; | |
| 5848 } | |
| 5849 if (nargin == 1 || args(1).is_string ()) | |
| 5850 { | |
| 5851 // Find first non singleton dimension | |
| 5852 for (int i = 0; i < dv.length (); i++) | |
| 5853 if (dv(i) > 1) | |
| 5854 { | |
| 5855 dim = i; | |
| 5856 break; | |
| 5857 } | |
| 5858 } | |
| 5859 else | |
| 5860 { | |
| 5861 if (dim < 0 || dim > dv.length () - 1) | |
| 5862 { | |
| 5863 error ("sort: dim must be a valid dimension"); | |
| 5864 return retval; | |
| 5865 } | |
| 5866 } | |
| 5867 | |
| 5868 if (return_idx) | |
| 5869 { | |
| 5870 Array<octave_idx_type> sidx; | |
| 5871 | |
| 5872 retval (0) = arg.sort (sidx, dim, smode); | |
|
9351
e2344f4af0cb
autocache indices returned from find et al.
Jaroslav Hajek <highegg@gmail.com>
parents:
9339
diff
changeset
|
5873 retval (1) = octave_value (sidx, true, true); |
| 7433 | 5874 } |
| 5875 else | |
| 5876 retval(0) = arg.sort (dim, smode); | |
| 5877 | |
| 5878 return retval; | |
| 5879 } | |
| 5880 | |
| 5881 /* | |
| 5882 | |
| 5883 %% Double | |
| 5884 %!assert (sort ([NaN, 1, -1, 2, Inf]), [-1, 1, 2, Inf, NaN]) | |
| 5885 %!assert (sort ([NaN, 1, -1, 2, Inf], 1), [NaN, 1, -1, 2, Inf]) | |
| 5886 %!assert (sort ([NaN, 1, -1, 2, Inf], 2), [-1, 1, 2, Inf, NaN]) | |
| 5887 %!error (sort ([NaN, 1, -1, 2, Inf], 3)) | |
| 5888 %!assert (sort ([NaN, 1, -1, 2, Inf], "ascend"), [-1, 1, 2, Inf, NaN]) | |
| 5889 %!assert (sort ([NaN, 1, -1, 2, Inf], 2, "ascend"), [-1, 1, 2, Inf, NaN]) | |
| 5890 %!assert (sort ([NaN, 1, -1, 2, Inf], "descend"), [NaN, Inf, 2, 1, -1]) | |
| 5891 %!assert (sort ([NaN, 1, -1, 2, Inf], 2, "descend"), [NaN, Inf, 2, 1, -1]) | |
| 5892 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4]), [3, 1, 6, 4; 8, 2, 7, 5]) | |
| 5893 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4], 1), [3, 1, 6, 4; 8, 2, 7, 5]) | |
| 5894 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4], 2), [1, 3, 5, 7; 2, 4, 6, 8]) | |
| 5895 %!assert (sort (1), 1) | |
| 5896 | |
| 5897 %!test | |
| 5898 %! [v, i] = sort ([NaN, 1, -1, Inf, 1]); | |
| 5899 %! assert (v, [-1, 1, 1, Inf, NaN]) | |
| 5900 %! assert (i, [3, 2, 5, 4, 1]) | |
| 5901 | |
| 5902 %% Complex | |
| 5903 %!assert (sort ([NaN, 1i, -1, 2, Inf]), [1i, -1, 2, Inf, NaN]) | |
| 5904 %!assert (sort ([NaN, 1i, -1, 2, Inf], 1), [NaN, 1i, -1, 2, Inf]) | |
| 5905 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2), [1i, -1, 2, Inf, NaN]) | |
| 5906 %!error (sort ([NaN, 1i, -1, 2, Inf], 3)) | |
| 5907 %!assert (sort ([NaN, 1i, -1, 2, Inf], "ascend"), [1i, -1, 2, Inf, NaN]) | |
| 5908 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2, "ascend"), [1i, -1, 2, Inf, NaN]) | |
| 5909 %!assert (sort ([NaN, 1i, -1, 2, Inf], "descend"), [NaN, Inf, 2, -1, 1i]) | |
| 5910 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2, "descend"), [NaN, Inf, 2, -1, 1i]) | |
| 5911 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4]), [3, 1i, 6, 4; 8, 2, 7, 5]) | |
| 5912 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4], 1), [3, 1i, 6, 4; 8, 2, 7, 5]) | |
| 5913 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4], 2), [1i, 3, 5, 7; 2, 4, 6, 8]) | |
| 5914 %!assert (sort (1i), 1i) | |
| 5915 | |
| 5916 %!test | |
| 5917 %! [v, i] = sort ([NaN, 1i, -1, Inf, 1, 1i]); | |
| 5918 %! assert (v, [1, 1i, 1i, -1, Inf, NaN]) | |
| 5919 %! assert (i, [5, 2, 6, 3, 4, 1]) | |
| 5920 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5921 %% Single |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5922 %!assert (sort (single([NaN, 1, -1, 2, Inf])), single([-1, 1, 2, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5923 %!assert (sort (single([NaN, 1, -1, 2, Inf]), 1), single([NaN, 1, -1, 2, Inf])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5924 %!assert (sort (single([NaN, 1, -1, 2, Inf]), 2), single([-1, 1, 2, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5925 %!error (sort (single([NaN, 1, -1, 2, Inf]), 3)) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5926 %!assert (sort (single([NaN, 1, -1, 2, Inf]), "ascend"), single([-1, 1, 2, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5927 %!assert (sort (single([NaN, 1, -1, 2, Inf]), 2, "ascend"), single([-1, 1, 2, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5928 %!assert (sort (single([NaN, 1, -1, 2, Inf]), "descend"), single([NaN, Inf, 2, 1, -1])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5929 %!assert (sort (single([NaN, 1, -1, 2, Inf]), 2, "descend"), single([NaN, Inf, 2, 1, -1])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5930 %!assert (sort (single([3, 1, 7, 5; 8, 2, 6, 4])), single([3, 1, 6, 4; 8, 2, 7, 5])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5931 %!assert (sort (single([3, 1, 7, 5; 8, 2, 6, 4]), 1), single([3, 1, 6, 4; 8, 2, 7, 5])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5932 %!assert (sort (single([3, 1, 7, 5; 8, 2, 6, 4]), 2), single([1, 3, 5, 7; 2, 4, 6, 8])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5933 %!assert (sort (single(1)), single(1)) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5934 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5935 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5936 %! [v, i] = sort (single([NaN, 1, -1, Inf, 1])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5937 %! assert (v, single([-1, 1, 1, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5938 %! assert (i, [3, 2, 5, 4, 1]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5939 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5940 %% Single Complex |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5941 %!assert (sort (single([NaN, 1i, -1, 2, Inf])), single([1i, -1, 2, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5942 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), 1), single([NaN, 1i, -1, 2, Inf])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5943 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), 2), single([1i, -1, 2, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5944 %!error (sort (single([NaN, 1i, -1, 2, Inf]), 3)) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5945 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), "ascend"), single([1i, -1, 2, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5946 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), 2, "ascend"), single([1i, -1, 2, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5947 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), "descend"), single([NaN, Inf, 2, -1, 1i])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5948 %!assert (sort (single([NaN, 1i, -1, 2, Inf]), 2, "descend"), single([NaN, Inf, 2, -1, 1i])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5949 %!assert (sort (single([3, 1i, 7, 5; 8, 2, 6, 4])), single([3, 1i, 6, 4; 8, 2, 7, 5])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5950 %!assert (sort (single([3, 1i, 7, 5; 8, 2, 6, 4]), 1), single([3, 1i, 6, 4; 8, 2, 7, 5])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5951 %!assert (sort (single([3, 1i, 7, 5; 8, 2, 6, 4]), 2), single([1i, 3, 5, 7; 2, 4, 6, 8])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5952 %!assert (sort (single(1i)),single( 1i)) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5953 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5954 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5955 %! [v, i] = sort (single([NaN, 1i, -1, Inf, 1, 1i])); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5956 %! assert (v, single([1, 1i, 1i, -1, Inf, NaN])) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5957 %! assert (i, [5, 2, 6, 3, 4, 1]) |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5958 |
| 7433 | 5959 %% Bool |
| 5960 %!assert (sort ([true, false, true, false]), [false, false, true, true]) | |
| 5961 %!assert (sort ([true, false, true, false], 1), [true, false, true, false]) | |
| 5962 %!assert (sort ([true, false, true, false], 2), [false, false, true, true]) | |
| 5963 %!error (sort ([true, false, true, false], 3)) | |
| 5964 %!assert (sort ([true, false, true, false], "ascend"), [false, false, true, true]) | |
| 5965 %!assert (sort ([true, false, true, false], 2, "ascend"), [false, false, true, true]) | |
| 5966 %!assert (sort ([true, false, true, false], "descend"), [true, true, false, false]) | |
| 5967 %!assert (sort ([true, false, true, false], 2, "descend"), [true, true, false, false]) | |
| 5968 %!assert (sort (true), true) | |
| 5969 | |
| 5970 %!test | |
| 5971 %! [v, i] = sort ([true, false, true, false]); | |
| 5972 %! assert (v, [false, false, true, true]) | |
| 5973 %! assert (i, [2, 4, 1, 3]) | |
| 5974 | |
| 5975 %% Sparse Double | |
| 5976 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf])), sparse ([-1, 0, 0, 1, 2, Inf, NaN])) | |
| 5977 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 1), sparse ([0, NaN, 1, 0, -1, 2, Inf])) | |
| 5978 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2), sparse ([-1, 0, 0, 1, 2, Inf, NaN])) | |
| 5979 %!error (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 3)) | |
| 5980 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), "ascend"), sparse ([-1, 0, 0, 1, 2, Inf, NaN])) | |
| 5981 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2, "ascend"), sparse ([-1, 0, 0, 1, 2, Inf, NaN])) | |
| 5982 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), "descend"), sparse ([NaN, Inf, 2, 1, 0, 0, -1])) | |
| 5983 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2, "descend"), sparse ([NaN, Inf, 2, 1, 0, 0, -1])) | |
| 5984 | |
| 5985 %!shared a | |
| 5986 %! a = randn (10, 10); | |
| 5987 %! a (a < 0) = 0; | |
| 5988 %!assert (sort (sparse (a)), sparse (sort (a))) | |
| 5989 %!assert (sort (sparse (a), 1), sparse (sort (a, 1))) | |
| 5990 %!assert (sort (sparse (a), 2), sparse (sort (a, 2))) | |
| 5991 %!test | |
| 5992 %! [v, i] = sort (a); | |
| 5993 %! [vs, is] = sort (sparse (a)); | |
| 5994 %! assert (vs, sparse (v)) | |
| 5995 %! assert (is, i) | |
| 5996 | |
| 5997 %% Sparse Complex | |
| 5998 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf])), sparse ([0, 0, 1i, -1, 2, Inf, NaN])) | |
| 5999 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 1), sparse ([0, NaN, 1i, 0, -1, 2, Inf])) | |
| 6000 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2), sparse ([0, 0, 1i, -1, 2, Inf, NaN])) | |
| 6001 %!error (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 3)) | |
| 6002 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), "ascend"), sparse ([0, 0, 1i, -1, 2, Inf, NaN])) | |
| 6003 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2, "ascend"), sparse ([0, 0, 1i, -1, 2, Inf, NaN])) | |
| 6004 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), "descend"), sparse ([NaN, Inf, 2, -1, 1i, 0, 0])) | |
| 6005 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2, "descend"), sparse ([NaN, Inf, 2, -1, 1i, 0, 0])) | |
| 6006 | |
| 6007 %!shared a | |
| 6008 %! a = randn (10, 10); | |
| 6009 %! a (a < 0) = 0; | |
| 6010 %! a = 1i * a; | |
| 6011 %!assert (sort (sparse (a)), sparse (sort (a))) | |
| 6012 %!assert (sort (sparse (a), 1), sparse (sort (a, 1))) | |
| 6013 %!assert (sort (sparse (a), 2), sparse (sort (a, 2))) | |
| 6014 %!test | |
| 6015 %! [v, i] = sort (a); | |
| 6016 %! [vs, is] = sort (sparse (a)); | |
| 6017 %! assert (vs, sparse (v)) | |
| 6018 %! assert (is, i) | |
| 6019 | |
| 6020 %% Sparse Bool | |
| 6021 %!assert (sort (sparse ([true, false, true, false])), sparse ([false, false, true, true])) | |
| 6022 %!assert (sort (sparse([true, false, true, false]), 1), sparse ([true, false, true, false])) | |
| 6023 %!assert (sort (sparse ([true, false, true, false]), 2), sparse ([false, false, true, true])) | |
| 6024 %!error (sort (sparse ([true, false, true, false], 3))) | |
| 6025 %!assert (sort (sparse ([true, false, true, false]), "ascend"), sparse([false, false, true, true])) | |
| 6026 %!assert (sort (sparse ([true, false, true, false]), 2, "ascend"), sparse([false, false, true, true])) | |
| 6027 %!assert (sort (sparse ([true, false, true, false]), "descend"), sparse ([true, true, false, false])) | |
| 6028 %!assert (sort (sparse ([true, false, true, false]), 2, "descend"), sparse([true, true, false, false])) | |
| 6029 | |
| 6030 %!test | |
| 6031 %! [v, i] = sort (sparse([true, false, true, false])); | |
| 6032 %! assert (v, sparse([false, false, true, true])) | |
| 6033 %! assert (i, [2, 4, 1, 3]) | |
| 6034 | |
| 6035 %% Cell string array | |
| 6036 %!shared a, b, c | |
| 6037 %! a = {"Alice", "Cecile", "Eric", "Barry", "David"}; | |
| 6038 %! b = {"Alice", "Barry", "Cecile", "David", "Eric"}; | |
| 6039 %! c = {"Eric", "David", "Cecile", "Barry", "Alice"}; | |
| 6040 %!assert (sort (a), b); | |
| 6041 %!assert (sort (a, 1), a) | |
| 6042 %!assert (sort (a, 2), b) | |
| 6043 %!error (sort (a, 3)) | |
| 6044 %!assert (sort (a, "ascend"), b) | |
| 6045 %!assert (sort (a, 2, "ascend"), b) | |
| 6046 %!assert (sort (a, "descend"), c) | |
| 6047 %!assert (sort (a, 2, "descend"), c) | |
| 6048 | |
| 6049 %!test | |
| 6050 %! [v, i] = sort (a); | |
| 6051 %! assert (i, [1, 4, 2, 5, 3]) | |
| 6052 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
6053 %!error <Invalid call to sort.*> sort (); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
6054 %!error <Invalid call to sort.*> sort (1, 2, 3, 4); |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
6055 |
| 7433 | 6056 */ |
| 6057 | |
|
8812
7d48766c21a5
use consistent format for doc strings of internal functions
John W. Eaton <jwe@octave.org>
parents:
8799
diff
changeset
|
6058 // Sort the rows of the matrix @var{a} according to the order |
|
7d48766c21a5
use consistent format for doc strings of internal functions
John W. Eaton <jwe@octave.org>
parents:
8799
diff
changeset
|
6059 // specified by @var{mode}, which can either be `ascend' or `descend' |
|
7d48766c21a5
use consistent format for doc strings of internal functions
John W. Eaton <jwe@octave.org>
parents:
8799
diff
changeset
|
6060 // and return the index vector corresponding to the sort order. |
|
7d48766c21a5
use consistent format for doc strings of internal functions
John W. Eaton <jwe@octave.org>
parents:
8799
diff
changeset
|
6061 // |
|
7d48766c21a5
use consistent format for doc strings of internal functions
John W. Eaton <jwe@octave.org>
parents:
8799
diff
changeset
|
6062 // This function does not yet support sparse matrices. |
|
7d48766c21a5
use consistent format for doc strings of internal functions
John W. Eaton <jwe@octave.org>
parents:
8799
diff
changeset
|
6063 |
|
8733
3ef774603887
rename all uses of sortrows_idx to sort_rows_idx
John W. Eaton <jwe@octave.org>
parents:
8721
diff
changeset
|
6064 DEFUN (__sort_rows_idx__, args, , |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6065 "-*- texinfo -*-\n\ |
|
9517
a85dbf7b6ff9
fix some functions help markup
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
6066 @deftypefn {Built-in Function} {} __sort_rows_idx__ (@var{a}, @var{mode})\n\ |
|
8812
7d48766c21a5
use consistent format for doc strings of internal functions
John W. Eaton <jwe@octave.org>
parents:
8799
diff
changeset
|
6067 Undocumented internal function.\n\ |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6068 @end deftypefn\n") |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6069 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6070 octave_value retval; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6071 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6072 int nargin = args.length (); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6073 sortmode smode = ASCENDING; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6074 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6075 if (nargin < 1 || nargin > 2 || (nargin == 2 && ! args(1).is_string ())) |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6076 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6077 print_usage (); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6078 return retval; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6079 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6080 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6081 if (nargin > 1) |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6082 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6083 std::string mode = args(1).string_value(); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6084 if (mode == "ascend") |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6085 smode = ASCENDING; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6086 else if (mode == "descend") |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6087 smode = DESCENDING; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6088 else |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6089 { |
|
8733
3ef774603887
rename all uses of sortrows_idx to sort_rows_idx
John W. Eaton <jwe@octave.org>
parents:
8721
diff
changeset
|
6090 error ("__sort_rows_idx__: mode must be either \"ascend\" or \"descend\""); |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6091 return retval; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6092 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6093 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6094 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6095 octave_value arg = args(0); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6096 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6097 if (arg.is_sparse_type ()) |
|
8733
3ef774603887
rename all uses of sortrows_idx to sort_rows_idx
John W. Eaton <jwe@octave.org>
parents:
8721
diff
changeset
|
6098 error ("__sort_rows_idx__: sparse matrices not yet supported"); |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6099 if (arg.ndims () == 2) |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6100 { |
|
8733
3ef774603887
rename all uses of sortrows_idx to sort_rows_idx
John W. Eaton <jwe@octave.org>
parents:
8721
diff
changeset
|
6101 Array<octave_idx_type> idx = arg.sort_rows_idx (smode); |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6102 |
|
9351
e2344f4af0cb
autocache indices returned from find et al.
Jaroslav Hajek <highegg@gmail.com>
parents:
9339
diff
changeset
|
6103 retval = octave_value (idx, true, true); |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6104 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6105 else |
|
8733
3ef774603887
rename all uses of sortrows_idx to sort_rows_idx
John W. Eaton <jwe@octave.org>
parents:
8721
diff
changeset
|
6106 error ("__sort_rows_idx__: needs a 2-dimensional object"); |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6107 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6108 return retval; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6109 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6110 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6111 DEFUN (issorted, args, , |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6112 "-*- texinfo -*-\n\ |
|
9517
a85dbf7b6ff9
fix some functions help markup
Jaroslav Hajek <highegg@gmail.com>
parents:
9513
diff
changeset
|
6113 @deftypefn {Built-in Function} {} issorted (@var{a}, @var{rows})\n\ |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6114 Returns true if the array is sorted, ascending or descending.\n\ |
|
9194
41a0fc5c4600
Fix typo in documentation of issorted()
Carsten Clark <tantumquantum+gnuoctave@gmail.com>
parents:
9167
diff
changeset
|
6115 NaNs are treated as by @code{sort}. If @var{rows} is supplied and\n\ |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6116 has the value \"rows\", checks whether the array is sorted by rows\n\ |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6117 as if output by @code{sortrows} (with no options).\n\ |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6118 \n\ |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6119 This function does not yet support sparse matrices.\n\ |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6120 @seealso{sortrows, sort}\n\ |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6121 @end deftypefn\n") |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6122 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6123 octave_value retval; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6124 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6125 int nargin = args.length (); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6126 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6127 if (nargin == 1) |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6128 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6129 octave_value arg = args(0); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6130 if (arg.dims ().is_vector ()) |
|
8734
767ed8cc6634
rename internal issorted and issorted_rows functions to is_sorted and is_sorted_rows
John W. Eaton <jwe@octave.org>
parents:
8733
diff
changeset
|
6131 retval = args(0).is_sorted () != UNSORTED; |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6132 else |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6133 error ("issorted: needs a vector"); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6134 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6135 else if (nargin == 2) |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6136 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6137 if (args(1).is_string () && args(1).string_value () == "rows") |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6138 { |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6139 octave_value arg = args(0); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6140 sortmode smode = ASCENDING; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6141 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6142 if (arg.is_sparse_type ()) |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6143 error ("issorted: sparse matrices not yet supported"); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6144 if (arg.ndims () == 2) |
|
8734
767ed8cc6634
rename internal issorted and issorted_rows functions to is_sorted and is_sorted_rows
John W. Eaton <jwe@octave.org>
parents:
8733
diff
changeset
|
6145 retval = arg.is_sorted_rows (smode) != UNSORTED; |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6146 else |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6147 error ("issorted: needs a 2-dimensional object"); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6148 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6149 else |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6150 error ("issorted: second argument must be \"rows\""); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6151 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6152 else |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6153 print_usage (); |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6154 |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6155 return retval; |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6156 } |
|
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6157 |
| 9725 | 6158 DEFUN (nth_element, args, , |
| 6159 "-*- texinfo -*-\n\ | |
| 6160 @deftypefn {Built-in Function} {} nth_element (@var{x}, @var{n})\n\ | |
| 6161 @deftypefnx {Built-in Function} {} nth_element (@var{x}, @var{n}, @var{dim})\n\ | |
| 6162 Select the n-th smallest element of a vector, using the ordering defined by @code{sort}.\n\ | |
| 6163 In other words, the result is equivalent to @code{sort(@var{x})(@var{n})}.\n\ | |
| 6164 @var{n} can also be a contiguous range, either ascending @code{l:u}\n\ | |
| 6165 or descending @code{u:-1:l}, in which case a range of elements is returned.\n\ | |
| 6166 If @var{x} is an array, @code{nth_element} operates along the dimension defined by @var{dim},\n\ | |
| 6167 or the first non-singleton dimension if @var{dim} is not given.\n\ | |
| 6168 \n\ | |
|
9736
fa63a34827e0
clarify nth_element docstring
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
6169 nth_element encapsulates the C++ standard library algorithms nth_element and partial_sort.\n\ |
| 9725 | 6170 On average, the complexity of the operation is O(M*log(K)), where\n\ |
| 6171 @code{M = size(@var{x}, @var{dim})} and @code{K = length (@var{n})}.\n\ | |
| 6172 This function is intended for cases where the ratio K/M is small; otherwise,\n\ | |
| 6173 it may be better to use @code{sort}.\n\ | |
| 6174 @seealso{sort, min, max}\n\ | |
| 6175 @end deftypefn") | |
| 6176 { | |
| 6177 octave_value retval; | |
| 6178 int nargin = args.length (); | |
| 6179 | |
| 6180 if (nargin == 2 || nargin == 3) | |
| 6181 { | |
| 6182 octave_value argx = args(0); | |
| 6183 | |
| 6184 int dim = -1; | |
| 6185 if (nargin == 3) | |
| 6186 { | |
| 6187 dim = args(2).int_value (true) - 1; | |
| 6188 if (dim < 0 || dim >= argx.ndims ()) | |
| 6189 error ("nth_element: dim must be a valid dimension"); | |
| 6190 } | |
| 6191 if (dim < 0) | |
| 6192 dim = argx.dims ().first_non_singleton (); | |
| 6193 | |
| 6194 idx_vector n = args(1).index_vector (); | |
| 6195 | |
| 6196 if (error_state) | |
| 6197 return retval; | |
| 6198 | |
| 6199 switch (argx.builtin_type ()) | |
| 6200 { | |
| 6201 case btyp_double: | |
| 6202 retval = argx.array_value ().nth_element (n, dim); | |
| 6203 break; | |
| 6204 case btyp_float: | |
| 6205 retval = argx.float_array_value ().nth_element (n, dim); | |
| 6206 break; | |
| 6207 case btyp_complex: | |
| 6208 retval = argx.complex_array_value ().nth_element (n, dim); | |
| 6209 break; | |
| 6210 case btyp_float_complex: | |
| 6211 retval = argx.float_complex_array_value ().nth_element (n, dim); | |
| 6212 break; | |
| 6213 #define MAKE_INT_BRANCH(X) \ | |
| 6214 case btyp_ ## X: \ | |
| 6215 retval = argx.X ## _array_value ().nth_element (n, dim); \ | |
| 6216 break | |
| 6217 | |
| 6218 MAKE_INT_BRANCH (int8); | |
| 6219 MAKE_INT_BRANCH (int16); | |
| 6220 MAKE_INT_BRANCH (int32); | |
| 6221 MAKE_INT_BRANCH (int64); | |
| 6222 MAKE_INT_BRANCH (uint8); | |
| 6223 MAKE_INT_BRANCH (uint16); | |
| 6224 MAKE_INT_BRANCH (uint32); | |
| 6225 MAKE_INT_BRANCH (uint64); | |
| 6226 #undef MAKE_INT_BRANCH | |
| 6227 default: | |
| 6228 if (argx.is_cellstr ()) | |
| 6229 retval = argx.cellstr_value ().nth_element (n, dim); | |
| 6230 else | |
| 6231 gripe_wrong_type_arg ("nth_element", argx); | |
| 6232 } | |
| 6233 } | |
| 6234 else | |
| 6235 print_usage (); | |
| 6236 | |
| 6237 return retval; | |
| 6238 } | |
| 6239 | |
|
8934
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6240 template <class NDT> |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6241 static NDT |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6242 do_accumarray_sum (const idx_vector& idx, const NDT& vals, |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6243 octave_idx_type n = -1) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6244 { |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6245 typedef typename NDT::element_type T; |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6246 if (n < 0) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6247 n = idx.extent (0); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6248 else if (idx.extent (n) > n) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6249 error ("accumarray: index out of range"); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6250 |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6251 // FIXME: the class tree in liboctave is overly complicated, hence the |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6252 // following type gymnastics. |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6253 MArray<T> array; |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6254 |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6255 if (vals.numel () == 1) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6256 { |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6257 array = MArray<T> (n, T ()); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6258 array.idx_add (idx, vals (0)); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6259 } |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6260 else if (vals.length () == idx.length (n)) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6261 { |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6262 array = MArray<T> (n, T ()); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6263 array.idx_add (idx, MArray<T> (vals)); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6264 } |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6265 else |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6266 error ("accumarray: dimensions mismatch"); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6267 |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
6268 return NDT (MArrayN<T> (Array<T> (array))); |
|
8934
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6269 } |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6270 |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6271 DEFUN (__accumarray_sum__, args, , |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6272 "-*- texinfo -*-\n\ |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6273 @deftypefn {Built-in Function} {} __accumarray_sum__ (@var{idx}, @var{vals}, @var{n})\n\ |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6274 Undocumented internal function.\n\ |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6275 @end deftypefn") |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6276 { |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6277 octave_value retval; |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6278 int nargin = args.length (); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6279 if (nargin >= 2 && nargin <= 3 && args(0).is_numeric_type ()) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6280 { |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6281 idx_vector idx = args(0).index_vector (); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6282 octave_idx_type n = -1; |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6283 if (nargin == 3) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6284 n = args(2).idx_type_value (true); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6285 |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6286 if (! error_state) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6287 { |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6288 octave_value vals = args(1); |
|
9198
3b9aacf07744
optimize accumarray with constant ranges
Jaroslav Hajek <highegg@gmail.com>
parents:
9197
diff
changeset
|
6289 if (vals.is_range ()) |
|
3b9aacf07744
optimize accumarray with constant ranges
Jaroslav Hajek <highegg@gmail.com>
parents:
9197
diff
changeset
|
6290 { |
|
3b9aacf07744
optimize accumarray with constant ranges
Jaroslav Hajek <highegg@gmail.com>
parents:
9197
diff
changeset
|
6291 Range r = vals.range_value (); |
|
3b9aacf07744
optimize accumarray with constant ranges
Jaroslav Hajek <highegg@gmail.com>
parents:
9197
diff
changeset
|
6292 if (r.inc () == 0) |
|
3b9aacf07744
optimize accumarray with constant ranges
Jaroslav Hajek <highegg@gmail.com>
parents:
9197
diff
changeset
|
6293 vals = r.base (); |
|
3b9aacf07744
optimize accumarray with constant ranges
Jaroslav Hajek <highegg@gmail.com>
parents:
9197
diff
changeset
|
6294 } |
|
3b9aacf07744
optimize accumarray with constant ranges
Jaroslav Hajek <highegg@gmail.com>
parents:
9197
diff
changeset
|
6295 |
|
8934
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6296 if (vals.is_single_type ()) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6297 { |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6298 if (vals.is_complex_type ()) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6299 retval = do_accumarray_sum (idx, vals.float_complex_array_value (), n); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6300 else |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6301 retval = do_accumarray_sum (idx, vals.float_array_value (), n); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6302 } |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6303 else if (vals.is_numeric_type ()) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6304 { |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6305 if (vals.is_complex_type ()) |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6306 retval = do_accumarray_sum (idx, vals.complex_array_value (), n); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6307 else |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6308 retval = do_accumarray_sum (idx, vals.array_value (), n); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6309 } |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6310 else |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6311 gripe_wrong_type_arg ("accumarray", vals); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6312 } |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6313 } |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6314 else |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6315 print_usage (); |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6316 |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6317 return retval; |
|
c2099a4d12ea
partially optimize accumarray
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
6318 } |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6319 |
|
9473
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6320 template <class NDT> |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6321 static NDT |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6322 do_merge (const Array<bool>& mask, |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6323 const NDT& tval, const NDT& fval) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6324 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6325 typedef typename NDT::element_type T; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6326 dim_vector dv = mask.dims (); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6327 NDT retval (dv); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6328 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6329 bool tscl = tval.numel () == 1, fscl = fval.numel () == 1; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6330 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6331 if ((! tscl && tval.dims () != dv) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6332 || (! fscl && fval.dims () != dv)) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6333 error ("merge: dimensions mismatch"); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6334 else |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6335 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6336 T *rv = retval.fortran_vec (); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6337 octave_idx_type n = retval.numel (); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6338 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6339 const T *tv = tval.data (), *fv = fval.data (); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6340 const bool *mv = mask.data (); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6341 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6342 if (tscl) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6343 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6344 if (fscl) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6345 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6346 T ts = tv[0], fs = fv[0]; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6347 for (octave_idx_type i = 0; i < n; i++) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6348 rv[i] = mv[i] ? ts : fs; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6349 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6350 else |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6351 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6352 T ts = tv[0]; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6353 for (octave_idx_type i = 0; i < n; i++) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6354 rv[i] = mv[i] ? ts : fv[i]; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6355 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6356 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6357 else |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6358 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6359 if (fscl) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6360 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6361 T fs = fv[0]; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6362 for (octave_idx_type i = 0; i < n; i++) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6363 rv[i] = mv[i] ? tv[i] : fs; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6364 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6365 else |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6366 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6367 for (octave_idx_type i = 0; i < n; i++) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6368 rv[i] = mv[i] ? tv[i] : fv[i]; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6369 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6370 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6371 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6372 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6373 return retval; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6374 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6375 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6376 #define MAKE_INT_BRANCH(INTX) \ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6377 else if (tval.is_ ## INTX ## _type () && fval.is_ ## INTX ## _type ()) \ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6378 { \ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6379 retval = do_merge (mask, \ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6380 tval.INTX ## _array_value (), \ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6381 fval.INTX ## _array_value ()); \ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6382 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6383 |
|
9505
a321a1c227c8
make ifelse an alias or merge
Jaroslav Hajek <highegg@gmail.com>
parents:
9475
diff
changeset
|
6384 DEFUN (merge, args, , |
|
9473
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6385 "-*- texinfo -*-\n\ |
|
9505
a321a1c227c8
make ifelse an alias or merge
Jaroslav Hajek <highegg@gmail.com>
parents:
9475
diff
changeset
|
6386 @deftypefn {Built-in Function} {} merge (@var{mask}, @var{tval}, @var{fval})\n\ |
|
a321a1c227c8
make ifelse an alias or merge
Jaroslav Hajek <highegg@gmail.com>
parents:
9475
diff
changeset
|
6387 @deftypefnx {Built-in Function} {} ifelse (@var{mask}, @var{tval}, @var{fval})\n\ |
|
9473
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6388 Merges elements of @var{true_val} and @var{false_val}, depending on the value of\n\ |
|
9758
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
6389 @var{mask}. If @var{mask} is a logical scalar, the other two arguments can be\n\ |
|
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
6390 arbitrary values. Otherwise, @var{mask} must be a logical array, and @var{tval},\n\ |
|
9473
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6391 @var{fval} should be arrays of matching class, or cell arrays.\n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6392 In the scalar mask case, @var{tval} is returned if @var{mask} is true, otherwise\n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6393 @var{fval} is returned.\n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6394 \n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6395 In the array mask case, both @var{tval} and @var{fval} must be either scalars or\n\ |
|
9758
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
6396 arrays with dimensions equal to @var{mask}. The result is constructed as follows:\n\ |
|
9473
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6397 @example\n\ |
|
9758
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
6398 @group\n\ |
|
9473
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6399 result(mask) = tval(mask);\n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6400 result(! mask) = fval(! mask);\n\ |
|
9758
09da0bd91412
Periodic grammar check of Octave documentation files to ensure common format
Rik <rdrider0-list@yahoo.com>
parents:
9736
diff
changeset
|
6401 @end group\n\ |
|
9473
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6402 @end example\n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6403 \n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6404 @var{mask} can also be arbitrary numeric type, in which case\n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6405 it is first converted to logical.\n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6406 @seealso{logical}\n\ |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6407 @end deftypefn") |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6408 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6409 int nargin = args.length (); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6410 octave_value retval; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6411 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6412 if (nargin == 3 && args(0).is_numeric_type ()) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6413 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6414 octave_value mask_val = args(0); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6415 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6416 if (mask_val.is_scalar_type ()) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6417 retval = mask_val.is_true () ? args(1) : args(2); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6418 else |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6419 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6420 boolNDArray mask = mask_val.bool_array_value (); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6421 octave_value tval = args(1), fval = args(2); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6422 if (tval.is_double_type () && fval.is_double_type ()) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6423 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6424 if (tval.is_complex_type () || fval.is_complex_type ()) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6425 retval = do_merge (mask, |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6426 tval.complex_array_value (), |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6427 fval.complex_array_value ()); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6428 else |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6429 retval = do_merge (mask, |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6430 tval.array_value (), |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6431 fval.array_value ()); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6432 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6433 else if (tval.is_single_type () && fval.is_single_type ()) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6434 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6435 if (tval.is_complex_type () || fval.is_complex_type ()) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6436 retval = do_merge (mask, |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6437 tval.float_complex_array_value (), |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6438 fval.float_complex_array_value ()); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6439 else |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6440 retval = do_merge (mask, |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6441 tval.float_array_value (), |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6442 fval.float_array_value ()); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6443 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6444 else if (tval.is_string () && fval.is_string ()) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6445 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6446 bool sq_string = tval.is_sq_string () || fval.is_sq_string (); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6447 retval = octave_value (do_merge (mask, |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6448 tval.char_array_value (), |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6449 fval.char_array_value ()), |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9685
diff
changeset
|
6450 sq_string ? '\'' : '"'); |
|
9473
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6451 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6452 else if (tval.is_cell () && fval.is_cell ()) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6453 { |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6454 retval = do_merge (mask, |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6455 tval.cell_value (), |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6456 fval.cell_value ()); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6457 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6458 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6459 MAKE_INT_BRANCH (int8) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6460 MAKE_INT_BRANCH (int16) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6461 MAKE_INT_BRANCH (int32) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6462 MAKE_INT_BRANCH (int64) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6463 MAKE_INT_BRANCH (uint8) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6464 MAKE_INT_BRANCH (uint16) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6465 MAKE_INT_BRANCH (uint32) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6466 MAKE_INT_BRANCH (uint64) |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6467 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6468 else |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6469 error ("merge: cannot merge %s with %s with array mask", |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6470 tval.class_name ().c_str (), |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6471 fval.class_name ().c_str ()); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6472 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6473 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6474 else |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6475 print_usage (); |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6476 |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6477 return retval; |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6478 } |
|
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6479 |
|
9505
a321a1c227c8
make ifelse an alias or merge
Jaroslav Hajek <highegg@gmail.com>
parents:
9475
diff
changeset
|
6480 DEFALIAS (ifelse, merge); |
|
a321a1c227c8
make ifelse an alias or merge
Jaroslav Hajek <highegg@gmail.com>
parents:
9475
diff
changeset
|
6481 |
|
9473
833109a9f37f
implement merge function
Jaroslav Hajek <highegg@gmail.com>
parents:
9428
diff
changeset
|
6482 #undef MAKE_INT_BRANCH |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8527
diff
changeset
|
6483 |
|
9513
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6484 template <class SparseT> |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6485 static SparseT |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6486 do_sparse_diff (const SparseT& array, octave_idx_type order, |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6487 int dim) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6488 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6489 SparseT retval = array; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6490 if (dim == 1) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6491 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6492 octave_idx_type k = retval.columns (); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6493 while (order > 0 && k > 0) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6494 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6495 idx_vector col1 (':'), col2 (':'), sl1 (1, k), sl2 (0, k-1); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6496 retval = retval.index (col1, sl1, 0) - retval.index (col2, sl2, 0); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6497 assert (retval.columns () == k-1); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6498 order--; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6499 k--; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6500 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6501 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6502 else |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6503 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6504 octave_idx_type k = retval.rows (); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6505 while (order > 0 && k > 0) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6506 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6507 idx_vector col1 (':'), col2 (':'), sl1 (1, k), sl2 (0, k-1); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6508 retval = retval.index (sl1, col1, 0) - retval.index (sl2, col2, 0); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6509 assert (retval.rows () == k-1); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6510 order--; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6511 k--; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6512 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6513 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6514 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6515 return retval; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6516 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6517 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6518 static octave_value |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6519 do_diff (const octave_value& array, octave_idx_type order, |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6520 int dim = -1) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6521 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6522 octave_value retval; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6523 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6524 const dim_vector& dv = array.dims (); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6525 if (dim == -1) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6526 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6527 dim = array.dims ().first_non_singleton (); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6528 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6529 // Bother Matlab. This behavior is really wicked. |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6530 if (dv(dim) <= order) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6531 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6532 if (dv(dim) == 1) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6533 retval = array.resize (dim_vector (0, 0)); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6534 else |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6535 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6536 retval = array; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6537 while (order > 0) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6538 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6539 if (dim == dv.length ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6540 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6541 retval = do_diff (array, order, dim - 1); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6542 order = 0; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6543 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6544 else if (dv(dim) == 1) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6545 dim++; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6546 else |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6547 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6548 retval = do_diff (array, dv(dim) - 1, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6549 order -= dv(dim) - 1; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6550 dim++; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6551 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6552 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6553 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6554 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6555 return retval; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6556 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6557 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6558 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6559 if (array.is_integer_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6560 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6561 if (array.is_int8_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6562 retval = array.int8_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6563 else if (array.is_int16_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6564 retval = array.int16_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6565 else if (array.is_int32_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6566 retval = array.int32_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6567 else if (array.is_int64_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6568 retval = array.int64_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6569 else if (array.is_uint8_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6570 retval = array.uint8_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6571 else if (array.is_uint16_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6572 retval = array.uint16_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6573 else if (array.is_uint32_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6574 retval = array.uint32_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6575 else if (array.is_uint64_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6576 retval = array.uint64_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6577 else |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6578 panic_impossible (); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6579 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6580 else if (array.is_sparse_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6581 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6582 if (array.is_complex_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6583 retval = do_sparse_diff (array.sparse_complex_matrix_value (), order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6584 else |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6585 retval = do_sparse_diff (array.sparse_matrix_value (), order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6586 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6587 else if (array.is_single_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6588 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6589 if (array.is_complex_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6590 retval = array.float_complex_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6591 else |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6592 retval = array.float_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6593 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6594 else |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6595 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6596 if (array.is_complex_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6597 retval = array.complex_array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6598 else |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6599 retval = array.array_value ().diff (order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6600 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6601 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6602 return retval; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6603 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6604 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6605 DEFUN (diff, args, , |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6606 "-*- texinfo -*-\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6607 @deftypefn {Built-in Function} {} diff (@var{x}, @var{k}, @var{dim})\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6608 If @var{x} is a vector of length @var{n}, @code{diff (@var{x})} is the\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6609 vector of first differences\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6610 @tex\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6611 $x_2 - x_1, \\ldots{}, x_n - x_{n-1}$.\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6612 @end tex\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6613 @ifnottex\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6614 @var{x}(2) - @var{x}(1), @dots{}, @var{x}(n) - @var{x}(n-1).\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6615 @end ifnottex\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6616 \n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6617 If @var{x} is a matrix, @code{diff (@var{x})} is the matrix of column\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6618 differences along the first non-singleton dimension.\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6619 \n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6620 The second argument is optional. If supplied, @code{diff (@var{x},\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6621 @var{k})}, where @var{k} is a non-negative integer, returns the\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6622 @var{k}-th differences. It is possible that @var{k} is larger than\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6623 then first non-singleton dimension of the matrix. In this case,\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6624 @code{diff} continues to take the differences along the next\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6625 non-singleton dimension.\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6626 \n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6627 The dimension along which to take the difference can be explicitly\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6628 stated with the optional variable @var{dim}. In this case the \n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6629 @var{k}-th order differences are calculated along this dimension.\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6630 In the case where @var{k} exceeds @code{size (@var{x}, @var{dim})}\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6631 then an empty matrix is returned.\n\ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6632 @end deftypefn") |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6633 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6634 int nargin = args.length (); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6635 octave_value retval; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6636 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6637 if (nargin < 1 || nargin > 3) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6638 print_usage (); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6639 else if (! args(0).is_numeric_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6640 error ("diff: X must be numeric"); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6641 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6642 if (! error_state) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6643 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6644 int dim = -1; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6645 octave_idx_type order = 1; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6646 if (nargin > 1) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6647 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6648 if (args(1).is_scalar_type ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6649 order = args(1).idx_type_value (true, false); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6650 else if (! args(1).is_zero_by_zero ()) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6651 error ("order must be a scalar or []"); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6652 if (! error_state && order < 0) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6653 error ("order must be non-negative"); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6654 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6655 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6656 if (nargin > 2) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6657 { |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6658 dim = args(2).int_value (true, false); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6659 if (! error_state && (dim < 1 || dim > args(0).ndims ())) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6660 error ("needs a valid dimension"); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6661 else |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6662 dim -= 1; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6663 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6664 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6665 if (! error_state) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6666 retval = do_diff (args(0), order, dim); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6667 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6668 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6669 return retval; |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6670 } |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6671 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6672 /* |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6673 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6674 %!assert (diff ([1, 2, 3, 4]), [1, 1, 1]) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6675 %!assert (diff ([1, 3, 7, 19], 2), [2, 8]) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6676 %!assert (diff ([1, 2; 5, 4; 8, 7; 9, 6; 3, 1]), [4, 2; 3, 3; 1, -1; -6, -5]) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6677 %!assert (diff ([1, 2; 5, 4; 8, 7; 9, 6; 3, 1], 3), [-1, -5; -5, 0]) |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6678 %!assert (isempty (diff (1))); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6679 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6680 %!error diff ([1, 2; 3, 4], -1); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6681 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6682 %!error diff ("foo"); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6683 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6684 %!error diff (); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6685 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6686 %!error diff (1, 2, 3, 4); |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6687 |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6688 */ |
|
9f870f73ab7d
implement built-in diff
Jaroslav Hajek <highegg@gmail.com>
parents:
9505
diff
changeset
|
6689 |
| 523 | 6690 /* |
| 6691 ;;; Local Variables: *** | |
| 6692 ;;; mode: C++ *** | |
| 6693 ;;; End: *** | |
| 6694 */ |