Mercurial > hg > octave-nkf
annotate src/data.cc @ 8347:fa78cb8d8a5c
corrections for typos
Here is a patch with some corrections for typos and missing/extra
words in the manual.
changeset: 8347:34fd1d1c2294
user: Brian Gough <bjg@gnu.org>
date: Wed Nov 26 11:00:15 2008 -0500
summary: [docs] can not => cannot
| author | Brian Gough<bjg@network-theory.co.uk> |
|---|---|
| date | Thu, 27 Nov 2008 10:28:24 +0100 |
| parents | b11c31849b44 |
| children | 8b1a2555c4e2 |
| rev | line source |
|---|---|
| 523 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, |
| 4 2003, 2004, 2005, 2006, 2007 John W. Eaton | |
| 523 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 523 | 12 |
| 13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 7016 | 19 along with Octave; see the file COPYING. If not, see |
| 20 <http://www.gnu.org/licenses/>. | |
| 523 | 21 |
| 22 */ | |
| 23 | |
| 24 #ifdef HAVE_CONFIG_H | |
| 1192 | 25 #include <config.h> |
| 523 | 26 #endif |
| 27 | |
| 7078 | 28 #include "systime.h" |
| 29 | |
| 30 #ifdef HAVE_SYS_TYPES_H | |
| 31 #include <sys/types.h> | |
| 32 #endif | |
| 33 | |
| 34 #ifdef HAVE_SYS_RESOURCE_H | |
| 35 #include <sys/resource.h> | |
| 36 #endif | |
| 37 | |
| 2184 | 38 #include <cfloat> |
| 39 | |
| 1728 | 40 #include <string> |
| 41 | |
| 2184 | 42 #include "lo-ieee.h" |
| 7231 | 43 #include "lo-math.h" |
| 1755 | 44 #include "str-vec.h" |
| 4153 | 45 #include "quit.h" |
| 1755 | 46 |
| 6953 | 47 #include "Cell.h" |
| 1352 | 48 #include "defun.h" |
| 49 #include "error.h" | |
| 50 #include "gripes.h" | |
| 6953 | 51 #include "oct-map.h" |
| 52 #include "oct-obj.h" | |
| 2366 | 53 #include "ov.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
54 #include "ov-float.h" |
| 5476 | 55 #include "ov-complex.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
56 #include "ov-flt-complex.h" |
| 5476 | 57 #include "ov-cx-mat.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
58 #include "ov-flt-cx-mat.h" |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
59 #include "ov-cx-sparse.h" |
| 6953 | 60 #include "parse.h" |
| 61 #include "pt-mat.h" | |
| 523 | 62 #include "utils.h" |
| 6953 | 63 #include "variables.h" |
| 7045 | 64 #include "pager.h" |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
65 #include "xnorm.h" |
| 523 | 66 |
|
7914
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
67 #if ! defined (HAVE_HYPOTF) && defined (HAVE__HYPOTF) |
|
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
68 #define hypotf _hypotf |
|
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
69 #define HAVE_HYPOTF 1 |
|
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
70 #endif |
|
e998e81224b5
Various compilation fixes for MSVC.
John W. Eaton <jwe@octave.org>
parents:
7815
diff
changeset
|
71 |
| 4015 | 72 #define ANY_ALL(FCN) \ |
| 73 \ | |
| 4233 | 74 octave_value retval; \ |
| 4015 | 75 \ |
| 76 int nargin = args.length (); \ | |
| 77 \ | |
| 4021 | 78 if (nargin == 1 || nargin == 2) \ |
| 4015 | 79 { \ |
| 4021 | 80 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \ |
| 81 \ | |
| 82 if (! error_state) \ | |
| 83 { \ | |
| 4556 | 84 if (dim >= -1) \ |
| 4015 | 85 retval = args(0).FCN (dim); \ |
| 4021 | 86 else \ |
| 87 error (#FCN ": invalid dimension argument = %d", dim + 1); \ | |
| 88 } \ | |
| 4015 | 89 else \ |
| 4021 | 90 error (#FCN ": expecting dimension argument to be an integer"); \ |
| 4015 | 91 } \ |
| 4021 | 92 else \ |
| 5823 | 93 print_usage (); \ |
| 4015 | 94 \ |
| 95 return retval | |
| 96 | |
| 1957 | 97 DEFUN (all, args, , |
| 3369 | 98 "-*- texinfo -*-\n\ |
| 4015 | 99 @deftypefn {Built-in Function} {} all (@var{x}, @var{dim})\n\ |
| 3369 | 100 The function @code{all} behaves like the function @code{any}, except\n\ |
| 101 that it returns true only if all the elements of a vector, or all the\n\ | |
| 4015 | 102 elements along dimension @var{dim} of a matrix, are nonzero.\n\ |
| 3369 | 103 @end deftypefn") |
| 523 | 104 { |
| 4015 | 105 ANY_ALL (all); |
| 523 | 106 } |
| 107 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
108 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
109 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
110 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
111 %! 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
|
112 %! 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
|
113 %! 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
|
114 %! && 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
|
115 %! && 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
|
116 %! && 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
|
117 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
118 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
119 %! 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
|
120 %! 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
|
121 %! 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
|
122 %! && 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
|
123 %! && 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
|
124 %! && 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
|
125 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
126 %!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
|
127 %!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
|
128 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
129 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
130 |
| 1957 | 131 DEFUN (any, args, , |
| 3369 | 132 "-*- texinfo -*-\n\ |
| 4015 | 133 @deftypefn {Built-in Function} {} any (@var{x}, @var{dim})\n\ |
| 3369 | 134 For a vector argument, return 1 if any element of the vector is\n\ |
| 135 nonzero.\n\ | |
| 136 \n\ | |
| 137 For a matrix argument, return a row vector of ones and\n\ | |
| 138 zeros with each element indicating whether any of the elements of the\n\ | |
| 139 corresponding column of the matrix are nonzero. For example,\n\ | |
| 140 \n\ | |
| 141 @example\n\ | |
| 142 @group\n\ | |
| 143 any (eye (2, 4))\n\ | |
| 144 @result{} [ 1, 1, 0, 0 ]\n\ | |
| 145 @end group\n\ | |
| 146 @end example\n\ | |
| 147 \n\ | |
| 4015 | 148 If the optional argument @var{dim} is supplied, work along dimension\n\ |
| 149 @var{dim}. For example,\n\ | |
| 3369 | 150 \n\ |
| 151 @example\n\ | |
| 4015 | 152 @group\n\ |
| 153 any (eye (2, 4), 2)\n\ | |
| 154 @result{} [ 1; 1 ]\n\ | |
| 155 @end group\n\ | |
| 3369 | 156 @end example\n\ |
| 157 @end deftypefn") | |
| 523 | 158 { |
| 4015 | 159 ANY_ALL (any); |
| 523 | 160 } |
| 161 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
162 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
163 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
164 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
165 %! 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
|
166 %! 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
|
167 %! 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
|
168 %! && 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
|
169 %! && 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
|
170 %! && 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
|
171 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
172 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
173 %! 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
|
174 %! 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
|
175 %! 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
|
176 %! && 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
|
177 %! && 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
|
178 %! && 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
|
179 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
180 %!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
|
181 %!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
|
182 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
183 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
184 |
| 649 | 185 // These mapping functions may also be useful in other places, eh? |
| 186 | |
| 187 typedef double (*d_dd_fcn) (double, double); | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
188 typedef float (*f_ff_fcn) (float, float); |
| 649 | 189 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
190 static NDArray |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
191 map_d_m (d_dd_fcn f, double x, const NDArray& y) |
| 649 | 192 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
193 NDArray retval (y.dims ()); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
194 double *r_data = retval.fortran_vec (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
195 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
196 const double *y_data = y.data (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
197 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
198 octave_idx_type nel = y.numel (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
199 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
200 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
|
201 { |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
202 OCTAVE_QUIT; |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
203 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
|
204 } |
| 649 | 205 |
| 206 return retval; | |
| 207 } | |
| 208 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
209 static FloatNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
210 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
|
211 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
212 FloatNDArray retval (y.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
213 float *r_data = retval.fortran_vec (); |
|
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 const float *y_data = y.data (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
216 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
217 octave_idx_type nel = y.numel (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
218 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
219 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
|
220 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
221 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
222 r_data[i] = f (x, y_data[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 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
225 return retval; |
|
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 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
228 static NDArray |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
229 map_m_d (d_dd_fcn f, const NDArray& x, double y) |
| 649 | 230 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
231 NDArray retval (x.dims ()); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
232 double *r_data = retval.fortran_vec (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
233 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
234 const double *x_data = x.data (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
235 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
236 octave_idx_type nel = x.numel (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
237 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
238 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
|
239 { |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
240 OCTAVE_QUIT; |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
241 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
|
242 } |
| 649 | 243 |
| 244 return retval; | |
| 245 } | |
| 246 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
247 static FloatNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
248 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
|
249 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
250 FloatNDArray retval (x.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
251 float *r_data = retval.fortran_vec (); |
|
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 const float *x_data = x.data (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
254 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
255 octave_idx_type nel = x.numel (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
256 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
257 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
|
258 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
259 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
260 r_data[i] = f (x_data[i], y); |
|
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 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
263 return retval; |
|
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 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
266 static NDArray |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
267 map_m_m (d_dd_fcn f, const NDArray& x, const NDArray& y) |
| 649 | 268 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
269 assert (x.dims () == y.dims ()); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
270 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
271 NDArray retval (x.dims ()); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
272 double *r_data = retval.fortran_vec (); |
|
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 const double *x_data = x.data (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
275 const double *y_data = y.data (); |
|
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 octave_idx_type nel = x.numel (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
278 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
279 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
|
280 { |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
281 OCTAVE_QUIT; |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
282 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
|
283 } |
| 649 | 284 |
| 285 return retval; | |
| 286 } | |
| 287 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
288 static FloatNDArray |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
289 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
|
290 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
291 assert (x.dims () == y.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
292 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
293 FloatNDArray retval (x.dims ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
294 float *r_data = retval.fortran_vec (); |
|
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 const float *x_data = x.data (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
297 const float *y_data = y.data (); |
|
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 octave_idx_type nel = x.numel (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
300 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
301 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
|
302 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
303 OCTAVE_QUIT; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
304 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
|
305 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
306 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
307 return retval; |
|
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 |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
310 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
|
311 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
|
312 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
313 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
|
314 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
|
315 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
|
316 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
|
317 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
318 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
|
319 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
320 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
|
321 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
322 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
|
323 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
|
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 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
|
326 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
|
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 |
|
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.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
|
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 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
332 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
333 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
|
334 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
|
335 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
|
336 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
|
337 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
338 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
|
339 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
340 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
|
341 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
342 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
|
343 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
|
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 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
|
346 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
347 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
|
348 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
|
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 } |
|
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.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
|
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.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
|
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 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
|
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 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
|
361 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
|
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 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
|
364 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
|
365 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
|
366 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
|
367 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
368 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
|
369 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
370 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
|
371 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
372 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
|
373 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
|
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 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
|
376 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
|
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 |
|
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.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
|
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 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
382 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
383 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
|
384 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
|
385 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
|
386 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
|
387 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
388 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
|
389 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
390 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
|
391 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
392 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
|
393 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
|
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 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
|
396 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
397 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
|
398 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
|
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 } |
|
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.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
|
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.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
|
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 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
|
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 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
|
411 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
|
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 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
|
414 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
|
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 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
|
417 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
|
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 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
|
420 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
421 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
|
422 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
|
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 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
|
425 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
426 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
|
427 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
|
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 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
|
430 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
431 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
|
432 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
433 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
|
434 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
|
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 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
|
437 k2++; |
|
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 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
|
440 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
441 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
|
442 k1++; |
|
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 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
445 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
446 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
|
447 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
|
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 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
|
450 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
451 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
|
452 k1++; |
|
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 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
|
455 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
456 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
|
457 k2++; |
|
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 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
460 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
461 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
|
462 k1++; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
463 k2++; |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
464 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
465 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
466 } |
|
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 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
|
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 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
472 { |
| 7631 | 473 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
|
474 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
|
475 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
|
476 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
|
477 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
|
478 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
479 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
|
480 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
481 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
|
482 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
483 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
|
484 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
|
485 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
|
486 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
|
487 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
488 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
|
489 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
|
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 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
|
492 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
493 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
|
494 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
|
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 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
497 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
498 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
|
499 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
|
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 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
|
502 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
503 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
|
504 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
|
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 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
|
507 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
508 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
|
509 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
|
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 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
512 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
513 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
|
514 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
|
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 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
517 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
|
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 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
|
520 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
|
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 } |
| 7631 | 523 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
|
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 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
526 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
|
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 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
|
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 |
| 1957 | 532 DEFUN (atan2, args, , |
| 3428 | 533 "-*- texinfo -*-\n\ |
| 534 @deftypefn {Mapping Function} {} atan2 (@var{y}, @var{x})\n\ | |
| 535 Compute atan (@var{y} / @var{x}) for corresponding elements of @var{y}\n\ | |
|
8347
fa78cb8d8a5c
corrections for typos
Brian Gough<bjg@network-theory.co.uk>
parents:
8303
diff
changeset
|
536 and @var{x}. The result is in the range -pi to pi.\n\ |
| 3439 | 537 @end deftypefn") |
| 649 | 538 { |
| 4233 | 539 octave_value retval; |
| 649 | 540 |
| 712 | 541 int nargin = args.length (); |
| 542 | |
| 543 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ()) | |
| 649 | 544 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
545 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
|
546 error ("atan2: not defined for integer types"); |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
547 else |
| 649 | 548 { |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
549 octave_value arg_y = args(0); |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
550 octave_value arg_x = args(1); |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
551 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
552 dim_vector y_dims = arg_y.dims (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
553 dim_vector x_dims = arg_x.dims (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
554 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
555 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
|
556 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
|
557 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
558 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
|
559 |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
560 if (y_is_scalar && x_is_scalar) |
| 649 | 561 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
562 if (is_float) |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
563 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
564 float y = arg_y.float_value (); |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
565 |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
566 if (! error_state) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
567 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
568 float x = arg_x.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
569 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
570 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
571 retval = atan2f (y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
572 } |
|
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 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
575 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
576 double y = arg_y.double_value (); |
|
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 if (! error_state) |
|
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 x = arg_x.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 retval = atan2 (y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
584 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
585 } |
| 649 | 586 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
587 else if (y_is_scalar) |
| 649 | 588 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
589 if (is_float) |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
590 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
591 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
|
592 |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
593 if (! error_state) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
594 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
595 // 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
|
596 FloatNDArray x = arg_x.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
597 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
598 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
599 retval = map_f_fm (atan2f, y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
600 } |
|
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 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
603 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
604 double y = arg_y.double_value (); |
|
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 if (! error_state) |
|
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 // 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
|
609 NDArray x = arg_x.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
610 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
611 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
612 retval = map_d_m (atan2, y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
613 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
614 } |
| 649 | 615 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
616 else if (x_is_scalar) |
| 649 | 617 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
618 if (arg_y.is_sparse_type ()) |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
619 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
620 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
|
621 |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
622 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
|
623 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
624 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
|
625 |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
626 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
|
627 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
|
628 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
629 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
630 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
631 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
632 FloatNDArray y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
633 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
634 if (! error_state) |
|
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 float x = arg_x.float_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 retval = map_fm_f (atan2f, y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
640 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
641 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
642 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
643 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
644 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
|
645 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
646 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
|
647 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
648 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
|
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 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
|
652 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
653 } |
| 649 | 654 } |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
655 else if (y_dims == x_dims) |
| 649 | 656 { |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
657 // 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
|
658 if (arg_x.is_sparse_type ()) |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
659 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
660 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
|
661 |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
662 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
|
663 { |
|
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 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
|
665 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
666 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
|
667 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
|
668 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
669 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
670 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
671 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
672 FloatNDArray y = arg_y.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
673 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
674 if (! error_state) |
|
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 x = arg_x.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 retval = map_fm_fm (atan2f, y, x); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
680 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
681 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
682 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
683 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
684 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
|
685 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
686 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
|
687 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
688 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
|
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 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
|
692 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
693 } |
| 649 | 694 } |
|
7494
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
695 else |
|
bd2bd04e68ca
Treat integer types for mod/rem correctly
David Bateman <dbateman@free.fr>
parents:
7433
diff
changeset
|
696 error ("atan2: nonconformant matrices"); |
| 649 | 697 } |
| 698 } | |
| 712 | 699 else |
| 5823 | 700 print_usage (); |
| 649 | 701 |
| 702 return retval; | |
| 703 } | |
| 704 | |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
705 /* |
| 7741 | 706 %!assert (size (atan2 (zeros (0, 2), zeros (0, 2))), [0, 2]) |
| 707 %!assert (size (atan2 (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4]) | |
| 708 %!assert (size (atan2 (rand (2, 3, 4), 1)), [2, 3, 4]) | |
| 709 %!assert (size (atan2 (1, rand (2, 3, 4))), [2, 3, 4]) | |
| 710 %!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
|
711 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
712 %!test |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
713 %! rt2 = sqrt (2); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
714 %! rt3 = sqrt (3); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
715 %! 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
|
716 %! 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
|
717 %! 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
|
718 %! 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
|
719 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
720 %!test |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
721 %! rt2 = sqrt (2); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
722 %! rt3 = sqrt (3); |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
723 %! 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
|
724 %! 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
|
725 %! 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
|
726 %! 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
|
727 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
728 %!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
|
729 %!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
|
730 |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
731 */ |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
732 |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
733 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
734 |
| 7631 | 735 DEFUN (hypot, args, , |
| 736 "-*- texinfo -*-\n\ | |
| 737 @deftypefn {Mapping Function} {} hypot (@var{x}, @var{y})\n\ | |
| 738 Compute square-root of the squares of @var{x} and @var{y}\n\ | |
| 739 element-by-element. This equivalent to @code{sqrt (@var{x}.^ 2 + @var{y}\n\ | |
| 740 .^ 2)}, but calculated in a manner that avoids overflows for large\n\ | |
| 741 values of @var{x} or @var{y}.\n\ | |
| 742 @end deftypefn") | |
| 743 { | |
| 744 octave_value retval; | |
| 745 | |
| 746 int nargin = args.length (); | |
| 747 | |
| 748 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ()) | |
| 749 { | |
| 750 if (args(0).is_integer_type () || args(1).is_integer_type ()) | |
| 751 error ("hypot: not defined for integer types"); | |
| 752 else | |
| 753 { | |
| 754 octave_value arg_x = args(0); | |
| 755 octave_value arg_y = args(1); | |
| 756 | |
| 757 dim_vector x_dims = arg_x.dims (); | |
| 758 dim_vector y_dims = arg_y.dims (); | |
| 759 | |
| 760 bool x_is_scalar = x_dims.all_ones (); | |
| 761 bool y_is_scalar = y_dims.all_ones (); | |
| 762 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
763 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
|
764 |
| 7631 | 765 if (y_is_scalar && x_is_scalar) |
| 766 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
767 if (is_float) |
| 7631 | 768 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
769 float x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
770 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
771 x = abs (arg_x.float_complex_value ()); |
| 7631 | 772 else |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
773 x = arg_x.float_value (); |
| 7631 | 774 |
| 775 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
776 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
777 float y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
778 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
779 y = abs (arg_y.float_complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
780 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
781 y = arg_y.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
782 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
783 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
784 retval = hypotf (x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
785 } |
|
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 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
788 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
789 double x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
790 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
791 x = abs (arg_x.complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
792 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
793 x = arg_x.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
794 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
795 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
796 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
797 double y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
798 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
799 y = abs (arg_y.complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
800 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
801 y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
802 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
803 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
804 retval = hypot (x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
805 } |
| 7631 | 806 } |
| 807 } | |
| 808 else if (y_is_scalar) | |
| 809 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
810 if (is_float) |
| 7631 | 811 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
812 FloatNDArray x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
813 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
814 x = arg_x.float_complex_array_value ().abs (); |
| 7631 | 815 else |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
816 x = arg_x.float_array_value (); |
| 7631 | 817 |
| 818 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
819 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
820 float y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
821 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
822 y = abs (arg_y.float_complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
823 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
824 y = arg_y.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
825 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
826 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
827 retval = map_fm_f (hypotf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
828 } |
|
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 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
831 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
832 NDArray x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
833 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
834 x = arg_x.complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
835 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
836 x = arg_x.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
837 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
838 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
839 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
840 double y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
841 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
842 y = abs (arg_y.complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
843 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
844 y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
845 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
846 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
847 retval = map_m_d (hypot, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
848 } |
| 7631 | 849 } |
| 850 } | |
| 851 else if (x_is_scalar) | |
| 852 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
853 if (is_float) |
| 7631 | 854 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
855 float x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
856 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
857 x = abs (arg_x.float_complex_value ()); |
| 7631 | 858 else |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
859 x = arg_x.float_value (); |
| 7631 | 860 |
| 861 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
862 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
863 FloatNDArray y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
864 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
865 y = arg_y.float_complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
866 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
867 y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
868 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
869 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
870 retval = map_f_fm (hypotf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
871 } |
|
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 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
874 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
875 double x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
876 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
877 x = abs (arg_x.complex_value ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
878 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
879 x = arg_x.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
880 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
881 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
882 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
883 NDArray y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
884 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
885 y = arg_y.complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
886 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
887 y = arg_y.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
888 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
889 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
890 retval = map_d_m (hypot, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
891 } |
| 7631 | 892 } |
| 893 } | |
| 894 else if (y_dims == x_dims) | |
| 895 { | |
| 896 if (arg_x.is_sparse_type () && arg_y.is_sparse_type ()) | |
| 897 { | |
| 898 SparseMatrix x; | |
| 899 if (arg_x.is_complex_type ()) | |
| 900 x = arg_x.sparse_complex_matrix_value ().abs (); | |
| 901 else | |
| 902 x = arg_x.sparse_matrix_value (); | |
| 903 | |
| 904 if (! error_state) | |
| 905 { | |
| 906 SparseMatrix y; | |
| 907 if (arg_y.is_complex_type ()) | |
| 908 y = arg_y.sparse_complex_matrix_value ().abs (); | |
| 909 else | |
| 910 y = arg_y.sparse_matrix_value (); | |
| 911 | |
| 912 if (! error_state) | |
| 913 retval = map_s_s (hypot, x, y); | |
| 914 } | |
| 915 } | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
916 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
917 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
918 FloatNDArray x; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
919 if (arg_x.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
920 x = arg_x.float_complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
921 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
922 x = arg_x.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
923 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
924 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
925 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
926 FloatNDArray y; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
927 if (arg_y.is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
928 y = arg_y.float_complex_array_value ().abs (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
929 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
930 y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
931 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
932 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
933 retval = map_fm_fm (hypotf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
934 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
935 } |
| 7631 | 936 else |
| 937 { | |
| 938 NDArray x; | |
| 939 if (arg_x.is_complex_type ()) | |
| 940 x = arg_x.complex_array_value ().abs (); | |
| 941 else | |
| 942 x = arg_x.array_value (); | |
| 943 | |
| 944 if (! error_state) | |
| 945 { | |
| 946 NDArray y; | |
| 947 if (arg_y.is_complex_type ()) | |
| 948 y = arg_y.complex_array_value ().abs (); | |
| 949 else | |
| 950 y = arg_y.array_value (); | |
| 951 | |
| 952 if (! error_state) | |
| 953 retval = map_m_m (hypot, x, y); | |
| 954 } | |
| 955 } | |
| 956 } | |
| 957 else | |
| 958 error ("hypot: nonconformant matrices"); | |
| 959 } | |
| 960 } | |
| 961 else | |
| 962 print_usage (); | |
| 963 | |
| 964 return retval; | |
| 965 } | |
| 966 | |
| 967 /* | |
| 7741 | 968 %!assert (size (hypot (zeros (0, 2), zeros (0, 2))), [0, 2]) |
| 969 %!assert (size (hypot (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4]) | |
| 970 %!assert (size (hypot (rand (2, 3, 4), 1)), [2, 3, 4]) | |
| 971 %!assert (size (hypot (1, rand (2, 3, 4))), [2, 3, 4]) | |
| 972 %!assert (size (hypot (1, 2)), [1, 1]) | |
| 973 %!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
|
974 %!assert (hypot (single(1:10), single(1:10)), single(sqrt(2) * [1:10])); |
| 7631 | 975 */ |
| 976 | |
| 7740 | 977 template<typename T, typename ET> |
| 978 void | |
| 979 map_2_xlog2 (const Array<T>& x, Array<T>& f, Array<ET>& e) | |
| 980 { | |
| 981 f = Array<T>(x.dims ()); | |
| 982 e = Array<ET>(x.dims ()); | |
| 983 for (octave_idx_type i = 0; i < x.numel (); i++) | |
| 984 { | |
| 985 int exp; | |
| 986 f.xelem (i) = xlog2 (x(i), exp); | |
| 987 e.xelem (i) = exp; | |
| 988 } | |
| 989 } | |
| 990 | |
| 991 DEFUN (log2, args, nargout, | |
| 992 "-*- texinfo -*-\n\ | |
| 993 @deftypefn {Mapping Function} {} log2 (@var{x})\n\ | |
| 994 @deftypefnx {Mapping Function} {[@var{f}, @var{e}] = } log2 (@var{x})\n\ | |
| 995 Compute the base-2 logarithm for each element of @var{x}.\n\ | |
| 996 If called with two output arguments, split @var{x} to\n\ | |
| 997 binary mantissa and exponent so that @code{1/2 <= abs(f) < 1} and\n\ | |
| 998 @var{e} is an integer. If @code{x = 0}, @code{f = e = 0}.\n\ | |
| 999 @seealso{log, log10, log2, exp}\n\ | |
| 1000 @end deftypefn") | |
| 1001 { | |
| 1002 octave_value_list retval; | |
| 1003 | |
| 1004 if (args.length () == 1) | |
| 1005 { | |
| 1006 if (nargout < 2) | |
| 1007 retval(0) = args(0).log2 (); | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1008 else if (args(0).is_single_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1009 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1010 if (args(0).is_real_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1011 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1012 FloatNDArray f; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1013 FloatNDArray x = args(0).float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1014 // FIXME -- should E be an int value? |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1015 FloatMatrix e; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1016 map_2_xlog2 (x, f, e); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1017 retval (1) = e; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1018 retval (0) = f; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1019 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1020 else if (args(0).is_complex_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1021 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1022 FloatComplexNDArray f; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1023 FloatComplexNDArray x = args(0).float_complex_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1024 // FIXME -- should E be an int value? |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1025 FloatNDArray e; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1026 map_2_xlog2 (x, f, e); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1027 retval (1) = e; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1028 retval (0) = f; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1029 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1030 } |
| 7740 | 1031 else if (args(0).is_real_type ()) |
| 1032 { | |
| 1033 NDArray f; | |
| 1034 NDArray x = args(0).array_value (); | |
| 1035 // FIXME -- should E be an int value? | |
| 1036 Matrix e; | |
| 1037 map_2_xlog2 (x, f, e); | |
| 1038 retval (1) = e; | |
| 1039 retval (0) = f; | |
| 1040 } | |
| 1041 else if (args(0).is_complex_type ()) | |
| 1042 { | |
| 1043 ComplexNDArray f; | |
| 1044 ComplexNDArray x = args(0).complex_array_value (); | |
| 1045 // FIXME -- should E be an int value? | |
| 1046 NDArray e; | |
| 1047 map_2_xlog2 (x, f, e); | |
| 1048 retval (1) = e; | |
| 1049 retval (0) = f; | |
| 1050 } | |
| 1051 else | |
| 1052 gripe_wrong_type_arg ("log2", args(0)); | |
| 1053 } | |
| 1054 else | |
| 1055 print_usage (); | |
| 1056 | |
| 1057 return retval; | |
| 1058 } | |
| 1059 | |
| 1060 /* | |
| 7741 | 1061 %!assert(log2 ([1/4, 1/2, 1, 2, 4]), [-2, -1, 0, 1, 2]); |
| 1062 %!assert(log2(Inf), Inf); | |
| 1063 %!assert(isnan(log2(NaN))); | |
| 1064 %!assert(log2(4*i), 2 + log2(1*i)); | |
| 1065 %!assert(log2(complex(0,Inf)), Inf + log2(i)); | |
| 1066 | |
| 7740 | 1067 %!test |
| 1068 %! [f, e] = log2 ([0,-1; 2,-4; Inf,-Inf]); | |
| 1069 %! assert (f, [0,-0.5; 0.5,-0.5; Inf,-Inf]); | |
| 1070 %! assert (e, [0,1;2,3;0,0]) | |
| 7741 | 1071 |
| 7740 | 1072 %!test |
| 1073 %! [f, e] = log2 (complex (zeros (3, 2), [0,-1; 2,-4; Inf,-Inf])); | |
| 1074 %! assert (f, complex (zeros (3, 2), [0,-0.5; 0.5,-0.5; Inf,-Inf])); | |
| 1075 %! assert (e, [0,1; 2,3; 0,0]); | |
| 1076 */ | |
| 1077 | |
| 4311 | 1078 DEFUN (fmod, args, , |
| 1079 "-*- texinfo -*-\n\ | |
| 1080 @deftypefn {Mapping Function} {} fmod (@var{x}, @var{y})\n\ | |
| 4685 | 1081 Compute the floating point remainder of dividing @var{x} by @var{y}\n\ |
| 1082 using the C library function @code{fmod}. The result has the same\n\ | |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1083 sign as @var{x}. If @var{y} is zero, the result is implementation-defined.\n\ |
| 4311 | 1084 @end deftypefn") |
| 1085 { | |
| 1086 octave_value retval; | |
| 1087 | |
| 1088 int nargin = args.length (); | |
| 1089 | |
| 1090 if (nargin == 2 && args(0).is_defined () && args(1).is_defined ()) | |
| 1091 { | |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1092 octave_value arg_y = args(0); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1093 octave_value arg_x = args(1); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1094 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1095 dim_vector y_dims = arg_y.dims (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1096 dim_vector x_dims = arg_x.dims (); |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1097 |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1098 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
|
1099 bool x_is_scalar = x_dims.all_ones (); |
| 4311 | 1100 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1101 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
|
1102 |
| 4311 | 1103 if (y_is_scalar && x_is_scalar) |
| 1104 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1105 if (is_float) |
| 4311 | 1106 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1107 float y = arg_y.float_value (); |
| 4311 | 1108 |
| 1109 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1110 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1111 float x = arg_x.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1112 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1113 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1114 retval = fmod (x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1115 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1116 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1117 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1118 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1119 double y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1120 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1121 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1122 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1123 double x = arg_x.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1124 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1125 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1126 retval = fmod (x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1127 } |
| 4311 | 1128 } |
| 1129 } | |
| 1130 else if (y_is_scalar) | |
| 1131 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1132 if (is_float) |
| 4311 | 1133 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1134 float y = arg_y.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1135 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1136 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
|
1137 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1138 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
|
1139 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1140 if (! error_state) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1141 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
|
1142 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1143 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1144 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1145 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1146 double y = arg_y.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1147 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1148 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
|
1149 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1150 if (arg_x.is_sparse_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1151 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1152 SparseMatrix x = arg_x.sparse_matrix_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) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1155 retval = map_s_d (fmod, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1156 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1157 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1158 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1159 NDArray x = arg_x.array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1160 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1161 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1162 retval = map_m_d (fmod, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1163 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1164 } |
| 4311 | 1165 } |
| 1166 } | |
| 1167 else if (x_is_scalar) | |
| 1168 { | |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1169 if (arg_y.is_sparse_type ()) |
| 4311 | 1170 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1171 SparseMatrix y = arg_y.sparse_matrix_value (); |
| 4311 | 1172 |
| 1173 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
|
1174 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1175 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
|
1176 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1177 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
|
1178 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
|
1179 } |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1180 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1181 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1182 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1183 FloatNDArray y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1184 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1185 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1186 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1187 float x = arg_x.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1188 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1189 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1190 retval = map_f_fm (fmodf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1191 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1192 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1193 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1194 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1195 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
|
1196 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1197 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
|
1198 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1199 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
|
1200 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1201 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
|
1202 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
|
1203 } |
| 4311 | 1204 } |
| 1205 } | |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1206 else if (y_dims == x_dims) |
| 4311 | 1207 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1208 if (arg_y.is_sparse_type () || arg_x.is_sparse_type ()) |
| 4311 | 1209 { |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1210 SparseMatrix y = arg_y.sparse_matrix_value (); |
| 4311 | 1211 |
| 1212 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
|
1213 { |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1214 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
|
1215 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1216 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
|
1217 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
|
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 } |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1220 else if (is_float) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1221 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1222 FloatNDArray y = arg_y.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1223 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1224 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1225 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1226 FloatNDArray x = arg_x.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1227 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1228 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1229 retval = map_fm_fm (fmodf, x, y); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1230 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1231 } |
|
7505
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1232 else |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1233 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1234 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
|
1235 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1236 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
|
1237 { |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1238 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
|
1239 |
|
f5005d9510f4
Remove dispatched sparse functions and treat in the generic versions of the functions
David Bateman <dbateman@free.fr>
parents:
7494
diff
changeset
|
1240 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
|
1241 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
|
1242 } |
| 4311 | 1243 } |
| 1244 } | |
| 1245 else | |
| 1246 error ("fmod: nonconformant matrices"); | |
| 1247 } | |
| 1248 else | |
| 5823 | 1249 print_usage (); |
| 4311 | 1250 |
| 1251 return retval; | |
| 1252 } | |
| 1253 | |
|
7506
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1254 /* |
| 7741 | 1255 %!assert (size (fmod (zeros (0, 2), zeros (0, 2))), [0, 2]) |
| 1256 %!assert (size (fmod (rand (2, 3, 4), zeros (2, 3, 4))), [2, 3, 4]) | |
| 7743 | 1257 %!assert (size (fmod (rand (2, 3, 4), 1)), [2, 3, 4]) |
| 1258 %!assert (size (fmod (1, rand (2, 3, 4))), [2, 3, 4]) | |
| 1259 %!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
|
1260 */ |
|
798b0a00e80c
atan2, fmod: accept N-d arrays
John W. Eaton <jwe@octave.org>
parents:
7505
diff
changeset
|
1261 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1262 // 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
|
1263 |
| 7112 | 1264 #define NATIVE_REDUCTION_1(FCN, TYPE, DIM) \ |
| 1265 (arg.is_ ## TYPE ## _type ()) \ | |
| 1266 { \ | |
| 1267 TYPE ## NDArray tmp = arg. TYPE ##_array_value (); \ | |
| 1268 \ | |
| 1269 if (! error_state) \ | |
| 1270 retval = tmp.FCN (DIM); \ | |
| 1271 } | |
| 1272 | |
| 1273 #define NATIVE_REDUCTION(FCN) \ | |
| 1274 \ | |
| 1275 octave_value retval; \ | |
| 1276 \ | |
| 1277 int nargin = args.length (); \ | |
| 1278 \ | |
| 1279 bool isnative = false; \ | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1280 bool isdouble = false; \ |
| 7112 | 1281 \ |
| 1282 if (nargin > 1 && args(nargin - 1).is_string ()) \ | |
| 1283 { \ | |
| 1284 std::string str = args(nargin - 1).string_value (); \ | |
| 1285 \ | |
| 1286 if (! error_state) \ | |
| 1287 { \ | |
| 1288 if (str == "native") \ | |
| 1289 isnative = true; \ | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1290 else if (str == "double") \ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1291 isdouble = true; \ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1292 else \ |
| 7112 | 1293 error ("sum: unrecognized string argument"); \ |
| 1294 nargin --; \ | |
| 1295 } \ | |
| 1296 } \ | |
| 1297 \ | |
| 1298 if (nargin == 1 || nargin == 2) \ | |
| 1299 { \ | |
| 1300 octave_value arg = args(0); \ | |
| 1301 \ | |
| 1302 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \ | |
| 1303 \ | |
| 1304 if (! error_state) \ | |
| 1305 { \ | |
| 1306 if (dim >= -1) \ | |
| 1307 { \ | |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1308 if (arg.is_sparse_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1309 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1310 if (arg.is_real_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1311 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1312 SparseMatrix tmp = arg.sparse_matrix_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1313 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1314 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1315 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1316 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1317 else \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1318 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1319 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
|
1320 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1321 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1322 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1323 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1324 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1325 else \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1326 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1327 if (isnative) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1328 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1329 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
|
1330 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
|
1331 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
|
1332 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
|
1333 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
|
1334 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
|
1335 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
|
1336 else if NATIVE_REDUCTION_1 (FCN, int64, dim) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1337 else if NATIVE_REDUCTION_1 (FCN, bool, dim) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1338 else if (arg.is_char_matrix ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1339 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1340 error (#FCN, ": invalid char type"); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1341 } \ |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1342 else if (!isdouble && arg.is_single_type ()) \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1343 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1344 if (arg.is_complex_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1345 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1346 FloatComplexNDArray tmp = \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1347 arg.float_complex_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1348 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1349 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1350 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1351 } \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1352 else if (arg.is_real_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1353 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1354 FloatNDArray tmp = arg.float_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1355 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1356 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1357 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1358 } \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1359 } \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1360 else if (arg.is_complex_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1361 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1362 ComplexNDArray tmp = arg.complex_array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1363 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1364 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1365 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1366 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1367 else if (arg.is_real_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1368 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1369 NDArray tmp = arg.array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1370 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1371 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1372 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1373 } \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1374 else \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1375 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1376 gripe_wrong_type_arg (#FCN, arg); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1377 return retval; \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1378 } \ |
| 7112 | 1379 } \ |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1380 else if (!isdouble && arg.is_single_type ()) \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1381 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1382 if (arg.is_real_type ()) \ |
|
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 FloatNDArray tmp = arg.float_array_value (); \ |
|
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 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1387 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1388 } \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1389 else if (arg.is_complex_type ()) \ |
|
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 FloatComplexNDArray tmp = \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1392 arg.float_complex_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1393 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1394 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1395 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1396 } \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1397 } \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1398 else if (arg.is_real_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1399 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1400 NDArray tmp = arg.array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1401 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1402 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1403 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1404 } \ |
| 7112 | 1405 else if (arg.is_complex_type ()) \ |
| 1406 { \ | |
| 1407 ComplexNDArray tmp = arg.complex_array_value (); \ | |
| 1408 \ | |
| 1409 if (! error_state) \ | |
| 1410 retval = tmp.FCN (dim); \ | |
| 1411 } \ | |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1412 else \ |
| 7112 | 1413 { \ |
| 1414 gripe_wrong_type_arg (#FCN, arg); \ | |
| 1415 return retval; \ | |
| 1416 } \ | |
| 1417 } \ | |
| 1418 } \ | |
| 1419 else \ | |
| 1420 error (#FCN ": invalid dimension argument = %d", dim + 1); \ | |
| 1421 } \ | |
| 1422 \ | |
| 1423 } \ | |
| 1424 else \ | |
| 1425 print_usage (); \ | |
| 1426 \ | |
| 1427 return retval | |
| 1428 | |
| 3723 | 1429 #define DATA_REDUCTION(FCN) \ |
| 1430 \ | |
| 4233 | 1431 octave_value retval; \ |
| 3723 | 1432 \ |
| 1433 int nargin = args.length (); \ | |
| 1434 \ | |
| 1435 if (nargin == 1 || nargin == 2) \ | |
| 1436 { \ | |
| 1437 octave_value arg = args(0); \ | |
| 1438 \ | |
| 3864 | 1439 int dim = (nargin == 1 ? -1 : args(1).int_value (true) - 1); \ |
| 3723 | 1440 \ |
| 1441 if (! error_state) \ | |
| 1442 { \ | |
| 4556 | 1443 if (dim >= -1) \ |
| 3723 | 1444 { \ |
| 1445 if (arg.is_real_type ()) \ | |
| 1446 { \ | |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1447 if (arg.is_sparse_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1448 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1449 SparseMatrix tmp = arg.sparse_matrix_value (); \ |
| 3723 | 1450 \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1451 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1452 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1453 } \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1454 else if (arg.is_single_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1455 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1456 FloatNDArray tmp = arg.float_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1457 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1458 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1459 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1460 } \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1461 else \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1462 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1463 NDArray tmp = arg.array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1464 \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1465 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1466 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1467 } \ |
| 3723 | 1468 } \ |
| 1469 else if (arg.is_complex_type ()) \ | |
| 1470 { \ | |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1471 if (arg.is_sparse_type ()) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1472 { \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1473 SparseComplexMatrix tmp = arg.sparse_complex_matrix_value (); \ |
| 3723 | 1474 \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1475 if (! error_state) \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1476 retval = tmp.FCN (dim); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1477 } \ |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1478 else if (arg.is_single_type ()) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1479 { \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1480 FloatComplexNDArray tmp = arg.float_complex_array_value (); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1481 \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1482 if (! error_state) \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1483 retval = tmp.FCN (dim); \ |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
1484 } \ |
|
7515
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1485 else \ |
|
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 ComplexNDArray tmp = arg.complex_array_value (); \ |
|
f3c00dc0912b
Eliminate the rest of the dispatched sparse functions
David Bateman <dbateman@free.fr>
parents:
7506
diff
changeset
|
1488 \ |
|
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 } \ |
| 3723 | 1492 } \ |
| 1493 else \ | |
| 1494 { \ | |
| 1495 gripe_wrong_type_arg (#FCN, arg); \ | |
| 1496 return retval; \ | |
| 1497 } \ | |
| 1498 } \ | |
| 1499 else \ | |
| 1500 error (#FCN ": invalid dimension argument = %d", dim + 1); \ | |
| 1501 } \ | |
| 1502 } \ | |
| 1503 else \ | |
| 5823 | 1504 print_usage (); \ |
| 3723 | 1505 \ |
| 1506 return retval | |
| 1507 | |
| 1957 | 1508 DEFUN (cumprod, args, , |
| 3428 | 1509 "-*- texinfo -*-\n\ |
| 3723 | 1510 @deftypefn {Built-in Function} {} cumprod (@var{x}, @var{dim})\n\ |
| 1511 Cumulative product of elements along dimension @var{dim}. If\n\ | |
| 1512 @var{dim} is omitted, it defaults to 1 (column-wise cumulative\n\ | |
| 1513 products).\n\ | |
| 5061 | 1514 \n\ |
| 1515 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\ | |
| 1516 return the cumulative product of the elements as a vector with the\n\ | |
| 1517 same orientation as @var{x}.\n\ | |
| 3428 | 1518 @end deftypefn") |
| 523 | 1519 { |
| 3723 | 1520 DATA_REDUCTION (cumprod); |
| 523 | 1521 } |
| 1522 | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1523 /* |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1524 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1525 %!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
|
1526 %!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
|
1527 %!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
|
1528 %!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
|
1529 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1530 %!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
|
1531 %!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
|
1532 %!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
|
1533 %!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
|
1534 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1535 %!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
|
1536 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1537 %!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
|
1538 %!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
|
1539 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1540 %!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
|
1541 %!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
|
1542 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1543 */ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1544 |
| 1957 | 1545 DEFUN (cumsum, args, , |
| 3428 | 1546 "-*- texinfo -*-\n\ |
| 3723 | 1547 @deftypefn {Built-in Function} {} cumsum (@var{x}, @var{dim})\n\ |
| 1548 Cumulative sum of elements along dimension @var{dim}. If @var{dim}\n\ | |
| 1549 is omitted, it defaults to 1 (column-wise cumulative sums).\n\ | |
| 5061 | 1550 \n\ |
| 1551 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\ | |
| 1552 return the cumulative sum of the elements as a vector with the\n\ | |
| 1553 same orientation as @var{x}.\n\ | |
| 3428 | 1554 @end deftypefn") |
| 523 | 1555 { |
| 3723 | 1556 DATA_REDUCTION (cumsum); |
| 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 (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
|
1562 %!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
|
1563 %!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
|
1564 %!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
|
1565 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1566 %!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
|
1567 %!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
|
1568 %!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
|
1569 %!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
|
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 cumsum.*> cumsum (); |
|
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 (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
|
1574 %!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
|
1575 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1576 %!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
|
1577 %!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
|
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 (diag, args, , |
| 3369 | 1582 "-*- texinfo -*-\n\ |
| 1583 @deftypefn {Built-in Function} {} diag (@var{v}, @var{k})\n\ | |
| 1584 Return a diagonal matrix with vector @var{v} on diagonal @var{k}. The\n\ | |
| 1585 second argument is optional. If it is positive, the vector is placed on\n\ | |
| 1586 the @var{k}-th super-diagonal. If it is negative, it is placed on the\n\ | |
| 1587 @var{-k}-th sub-diagonal. The default value of @var{k} is 0, and the\n\ | |
| 1588 vector is placed on the main diagonal. For example,\n\ | |
| 1589 \n\ | |
| 1590 @example\n\ | |
| 1591 @group\n\ | |
| 1592 diag ([1, 2, 3], 1)\n\ | |
| 1593 @result{} 0 1 0 0\n\ | |
| 1594 0 0 2 0\n\ | |
| 1595 0 0 0 3\n\ | |
| 1596 0 0 0 0\n\ | |
| 1597 @end group\n\ | |
| 1598 @end example\n\ | |
| 6772 | 1599 \n\ |
| 1600 @noindent\n\ | |
| 1601 Given a matrix argument, instead of a vector, @code{diag} extracts the\n\ | |
| 6774 | 1602 @var{k}-th diagonal of the matrix.\n\ |
| 3369 | 1603 @end deftypefn") |
| 523 | 1604 { |
| 4233 | 1605 octave_value retval; |
| 523 | 1606 |
| 1607 int nargin = args.length (); | |
| 1608 | |
| 712 | 1609 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
|
1610 retval = args(0).diag(); |
| 712 | 1611 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
|
1612 { |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1613 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
|
1614 |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1615 if (error_state) |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1616 error ("diag: invalid second argument"); |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1617 else |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1618 retval = args(0).diag(k); |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7618
diff
changeset
|
1619 } |
| 523 | 1620 else |
| 5823 | 1621 print_usage (); |
| 523 | 1622 |
| 1623 return retval; | |
| 1624 } | |
| 1625 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1626 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1627 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1628 %!assert(diag ([1; 2; 3]), [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
|
1629 %!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
|
1630 %!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
|
1631 %!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
|
1632 %!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
|
1633 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1634 %!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
|
1635 %!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
|
1636 %!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
|
1637 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1638 %!assert(diag (single([1; 2; 3])), single([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
|
1639 %!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
|
1640 %!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
|
1641 %!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
|
1642 %!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
|
1643 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1644 %!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
|
1645 %!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
|
1646 %!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
|
1647 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1648 %!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
|
1649 %!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
|
1650 %!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
|
1651 %!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
|
1652 %!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
|
1653 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1654 %!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
|
1655 %!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
|
1656 %!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
|
1657 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1658 %!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
|
1659 %!error <Invalid call to diag.*> diag (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
|
1660 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1661 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1662 |
| 1957 | 1663 DEFUN (prod, args, , |
| 3428 | 1664 "-*- texinfo -*-\n\ |
| 3723 | 1665 @deftypefn {Built-in Function} {} prod (@var{x}, @var{dim})\n\ |
| 1666 Product of elements along dimension @var{dim}. If @var{dim} is\n\ | |
| 1667 omitted, it defaults to 1 (column-wise products).\n\ | |
| 5061 | 1668 \n\ |
| 1669 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\ | |
| 1670 return the product of the elements.\n\ | |
| 3428 | 1671 @end deftypefn") |
| 523 | 1672 { |
| 3723 | 1673 DATA_REDUCTION (prod); |
| 523 | 1674 } |
| 1675 | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1676 /* |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1677 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1678 %!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
|
1679 %!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
|
1680 %!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
|
1681 %!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
|
1682 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1683 %!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
|
1684 %!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
|
1685 %!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
|
1686 %!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
|
1687 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1688 %!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
|
1689 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1690 %!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
|
1691 %!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
|
1692 %!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
|
1693 %!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
|
1694 %!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
|
1695 %!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
|
1696 %!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
|
1697 %!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
|
1698 %!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
|
1699 %!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
|
1700 %!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
|
1701 %!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
|
1702 %!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
|
1703 %!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
|
1704 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
1705 %!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
|
1706 %!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
|
1707 %!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
|
1708 %!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
|
1709 %!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
|
1710 %!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
|
1711 %!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
|
1712 %!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
|
1713 %!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
|
1714 %!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
|
1715 %!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
|
1716 %!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
|
1717 %!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
|
1718 %!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
|
1719 |
|
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 |
|
8107
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1722 #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
|
1723 do \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1724 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1725 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
|
1726 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
|
1727 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1728 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
|
1729 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1730 OCTAVE_QUIT; \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1731 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1732 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
|
1733 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1734 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
|
1735 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1736 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
|
1737 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1738 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
|
1739 return retval; \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1740 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1741 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
|
1742 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1743 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
|
1744 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1745 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
|
1746 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
|
1747 break; \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1748 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1749 else \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1750 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
|
1751 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1752 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1753 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1754 while (0) |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1755 |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1756 #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
|
1757 do \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1758 { \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1759 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
|
1760 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1761 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
|
1762 \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1763 retval = result; \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1764 } \ |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1765 while (0) |
|
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1766 |
| 4824 | 1767 static octave_value |
| 1768 do_cat (const octave_value_list& args, std::string fname) | |
| 4806 | 1769 { |
| 1770 octave_value retval; | |
| 1771 | |
| 4824 | 1772 int n_args = args.length (); |
| 4806 | 1773 |
| 5714 | 1774 if (n_args == 1) |
| 1775 retval = Matrix (); | |
| 1776 else if (n_args == 2) | |
| 1777 retval = args(1); | |
| 5507 | 1778 else if (n_args > 2) |
| 4824 | 1779 { |
| 5275 | 1780 octave_idx_type dim = args(0).int_value () - 1; |
| 4806 | 1781 |
| 4824 | 1782 if (error_state) |
| 4806 | 1783 { |
| 4824 | 1784 error ("cat: expecting first argument to be a integer"); |
| 4806 | 1785 return retval; |
| 1786 } | |
| 1787 | |
| 4824 | 1788 if (dim >= 0) |
| 1789 { | |
| 4915 | 1790 |
| 1791 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
|
1792 std::string result_type = args(1).class_name (); |
| 4824 | 1793 |
|
8107
8655dc0906e6
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
7991
diff
changeset
|
1794 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
|
1795 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
|
1796 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
|
1797 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
|
1798 |
| 4915 | 1799 for (int i = 2; i < args.length (); i++) |
| 1800 { | |
| 1801 // add_dims constructs a dimension vector which holds the | |
| 4824 | 1802 // dimensions of the final array after concatenation. |
| 4806 | 1803 |
| 4915 | 1804 if (! dv.concat (args(i).dims (), dim)) |
| 4806 | 1805 { |
| 4824 | 1806 // Dimensions do not match. |
| 4915 | 1807 error ("cat: dimension mismatch"); |
| 4806 | 1808 return retval; |
| 1809 } | |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1810 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1811 result_type = |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1812 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
|
1813 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1814 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
|
1815 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
|
1816 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
|
1817 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
|
1818 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
|
1819 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
|
1820 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
|
1821 any_sparse_p = true; |
| 4824 | 1822 } |
| 1823 | |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1824 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
|
1825 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1826 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
|
1827 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1828 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
|
1829 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
|
1830 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1831 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
|
1832 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1833 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1834 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1835 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
|
1836 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
|
1837 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1838 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
|
1839 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1840 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1841 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
|
1842 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1843 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
|
1844 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
|
1845 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1846 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
|
1847 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
|
1848 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1849 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
|
1850 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1851 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
|
1852 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1853 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
|
1854 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1855 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
|
1856 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1857 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
|
1858 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1859 retval = octave_value (result, true, type); |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1860 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1861 else if (result_type == "logical") |
| 5533 | 1862 { |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1863 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
|
1864 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
|
1865 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1866 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
|
1867 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1868 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
|
1869 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
|
1870 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
|
1871 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
|
1872 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
|
1873 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
|
1874 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
|
1875 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
|
1876 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
|
1877 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
|
1878 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
|
1879 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
|
1880 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
|
1881 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
|
1882 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
|
1883 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
|
1884 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1885 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1886 // 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
|
1887 // 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
|
1888 // 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
|
1889 // 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
|
1890 // 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
|
1891 // 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
|
1892 // 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
|
1893 // |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1894 // 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
|
1895 // 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
|
1896 // (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
|
1897 // 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
|
1898 // 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
|
1899 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1900 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
|
1901 tmp = tmp.resize (dim_vector (0,0)).resize (dv); |
| 4824 | 1902 |
| 4915 | 1903 if (error_state) |
| 1904 return retval; | |
| 4806 | 1905 |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1906 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
|
1907 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
|
1908 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1909 for (int j = 1; j < n_args; j++) |
| 6401 | 1910 { |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1911 // 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
|
1912 // 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
|
1913 // 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
|
1914 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
|
1915 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1916 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
|
1917 return retval; |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1918 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1919 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
|
1920 |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1921 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
|
1922 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1923 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
|
1924 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
|
1925 break; |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1926 } |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1927 else |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1928 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
|
1929 dv_tmp (dim) : 1); |
| 6401 | 1930 } |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1931 retval = tmp; |
| 4915 | 1932 } |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
1933 |
|
8113
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1934 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
|
1935 { |
|
38a797766a2a
Special case single type conacation in Fcat. Rework cell2mat to take advantage
David Bateman <dbateman@free.fr>
parents:
8111
diff
changeset
|
1936 // 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
|
1937 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
|
1938 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
|
1939 } |
| 4806 | 1940 } |
| 5533 | 1941 else |
| 1942 error ("%s: invalid dimension argument", fname.c_str ()); | |
| 4806 | 1943 } |
| 1944 else | |
| 5823 | 1945 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
|
1946 |
| 4806 | 1947 return retval; |
| 1948 } | |
| 1949 | |
| 1950 DEFUN (horzcat, args, , | |
| 4824 | 1951 "-*- texinfo -*-\n\ |
| 4806 | 1952 @deftypefn {Built-in Function} {} horzcat (@var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\ |
| 1953 Return the horizontal concatenation of N-d array objects, @var{array1},\n\ | |
| 1954 @var{array2}, @dots{}, @var{arrayN} along dimension 2.\n\ | |
| 5642 | 1955 @seealso{cat, vertcat}\n\ |
| 1956 @end deftypefn") | |
| 4806 | 1957 { |
| 1958 octave_value_list args_tmp = args; | |
| 1959 | |
| 1960 int dim = 2; | |
| 1961 | |
| 1962 octave_value d (dim); | |
| 1963 | |
| 1964 args_tmp.prepend (d); | |
| 1965 | |
| 4824 | 1966 return do_cat (args_tmp, "horzcat"); |
| 4806 | 1967 } |
| 1968 | |
| 1969 DEFUN (vertcat, args, , | |
| 1970 "-*- texinfo -*-\n\ | |
| 1971 @deftypefn {Built-in Function} {} vertcat (@var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\ | |
| 1972 Return the vertical concatenation of N-d array objects, @var{array1},\n\ | |
| 1973 @var{array2}, @dots{}, @var{arrayN} along dimension 1.\n\ | |
| 5642 | 1974 @seealso{cat, horzcat}\n\ |
| 1975 @end deftypefn") | |
| 4806 | 1976 { |
| 1977 octave_value_list args_tmp = args; | |
| 1978 | |
| 1979 int dim = 1; | |
| 1980 | |
| 1981 octave_value d (dim); | |
| 1982 | |
| 1983 args_tmp.prepend (d); | |
| 1984 | |
| 4824 | 1985 return do_cat (args_tmp, "vertcat"); |
| 4806 | 1986 } |
| 1987 | |
| 4758 | 1988 DEFUN (cat, args, , |
| 1989 "-*- texinfo -*-\n\ | |
| 1990 @deftypefn {Built-in Function} {} cat (@var{dim}, @var{array1}, @var{array2}, @dots{}, @var{arrayN})\n\ | |
| 4806 | 1991 Return the concatenation of N-d array objects, @var{array1},\n\ |
| 1992 @var{array2}, @dots{}, @var{arrayN} along dimension @var{dim}.\n\ | |
| 4758 | 1993 \n\ |
| 1994 @example\n\ | |
| 1995 @group\n\ | |
| 1996 A = ones (2, 2);\n\ | |
| 1997 B = zeros (2, 2);\n\ | |
| 1998 cat (2, A, B)\n\ | |
| 1999 @result{} ans =\n\ | |
| 2000 \n\ | |
| 2001 1 1 0 0\n\ | |
| 2002 1 1 0 0\n\ | |
| 2003 @end group\n\ | |
| 2004 @end example\n\ | |
| 2005 \n\ | |
| 2006 Alternatively, we can concatenate @var{A} and @var{B} along the\n\ | |
| 2007 second dimension the following way:\n\ | |
| 2008 \n\ | |
| 2009 @example\n\ | |
| 2010 @group\n\ | |
| 2011 [A, B].\n\ | |
| 2012 @end group\n\ | |
| 2013 @end example\n\ | |
| 2014 \n\ | |
| 2015 @var{dim} can be larger than the dimensions of the N-d array objects\n\ | |
| 2016 and the result will thus have @var{dim} dimensions as the\n\ | |
| 2017 following example shows:\n\ | |
| 2018 @example\n\ | |
| 2019 @group\n\ | |
| 2020 cat (4, ones(2, 2), zeros (2, 2))\n\ | |
| 2021 @result{} ans =\n\ | |
| 2022 \n\ | |
| 2023 ans(:,:,1,1) =\n\ | |
| 2024 \n\ | |
| 2025 1 1\n\ | |
| 2026 1 1\n\ | |
| 2027 \n\ | |
| 2028 ans(:,:,1,2) =\n\ | |
| 2029 0 0\n\ | |
| 2030 0 0\n\ | |
| 2031 @end group\n\ | |
| 2032 @end example\n\ | |
| 5642 | 2033 @seealso{horzcat, vertcat}\n\ |
| 2034 @end deftypefn") | |
| 4758 | 2035 { |
| 4824 | 2036 return do_cat (args, "cat"); |
| 4758 | 2037 } |
| 2038 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2039 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2040 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2041 %!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
|
2042 %! 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
|
2043 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2044 %! 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
|
2045 %! 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
|
2046 %! 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
|
2047 %! 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
|
2048 %! 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
|
2049 %! 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
|
2050 %! 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
|
2051 %! 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
|
2052 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2053 %! 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
|
2054 %! 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
|
2055 %! 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
|
2056 %! 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
|
2057 %! 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
|
2058 %! 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
|
2059 %! 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
|
2060 %! 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
|
2061 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2062 %! 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
|
2063 %! 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
|
2064 %! 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
|
2065 %! 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
|
2066 %! 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
|
2067 %! 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
|
2068 %! 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
|
2069 %! 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
|
2070 %! 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
|
2071 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2072 %! 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
|
2073 %! 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
|
2074 %! 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
|
2075 %! 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
|
2076 %! 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
|
2077 %! 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
|
2078 %! 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
|
2079 %! 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
|
2080 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2081 %! 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
|
2082 %! 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
|
2083 %! 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
|
2084 %! 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
|
2085 %! 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
|
2086 %! 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
|
2087 %! 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
|
2088 %! 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
|
2089 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2090 %! 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
|
2091 %! 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
|
2092 %! 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
|
2093 %! 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
|
2094 %! 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
|
2095 %! 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
|
2096 %! 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
|
2097 %! 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
|
2098 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2099 %! 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
|
2100 %! 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
|
2101 %! 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
|
2102 %! 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
|
2103 %! 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
|
2104 %! 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
|
2105 %! 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
|
2106 %! 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
|
2107 %! |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2108 %! 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
|
2109 %! 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
|
2110 %! 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
|
2111 %! 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
|
2112 %! 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
|
2113 %! 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
|
2114 %! 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
|
2115 %! 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
|
2116 %! endif |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2117 %! ret = true; |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2118 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2119 %!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
|
2120 %!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
|
2121 %!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
|
2122 %!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
|
2123 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2124 %!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
|
2125 %!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
|
2126 %!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
|
2127 %!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
|
2128 %!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
|
2129 %!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
|
2130 %!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
|
2131 %!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
|
2132 %!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
|
2133 %!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
|
2134 %!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
|
2135 %!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
|
2136 %!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
|
2137 %!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
|
2138 %!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
|
2139 %!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
|
2140 %!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
|
2141 %!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
|
2142 %!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
|
2143 %!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
|
2144 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2145 %!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
|
2146 %!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
|
2147 %!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
|
2148 %!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
|
2149 %!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
|
2150 %!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
|
2151 %!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
|
2152 %!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
|
2153 %!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
|
2154 %!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
|
2155 %!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
|
2156 %!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
|
2157 %!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
|
2158 %!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
|
2159 %!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
|
2160 %!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
|
2161 %!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
|
2162 %!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
|
2163 %!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
|
2164 %!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
|
2165 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2166 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
2167 |
| 4593 | 2168 static octave_value |
| 6959 | 2169 do_permute (const octave_value_list& args, bool inv) |
| 4593 | 2170 { |
| 2171 octave_value retval; | |
| 2172 | |
| 5148 | 2173 if (args.length () == 2 && args(1).length () >= args(1).ndims ()) |
| 4593 | 2174 { |
| 2175 Array<int> vec = args(1).int_vector_value (); | |
| 2176 | |
| 5775 | 2177 // FIXME -- maybe we should create an idx_vector object |
| 5148 | 2178 // here and pass that to permute? |
| 2179 | |
| 2180 int n = vec.length (); | |
| 2181 | |
| 2182 for (int i = 0; i < n; i++) | |
| 2183 vec(i)--; | |
| 2184 | |
| 4593 | 2185 octave_value ret = args(0).permute (vec, inv); |
| 2186 | |
| 2187 if (! error_state) | |
| 2188 retval = ret; | |
| 2189 } | |
| 2190 else | |
| 5823 | 2191 print_usage (); |
| 4593 | 2192 |
| 2193 return retval; | |
| 2194 } | |
| 2195 | |
| 2196 DEFUN (permute, args, , | |
| 2197 "-*- texinfo -*-\n\ | |
| 2198 @deftypefn {Built-in Function} {} permute (@var{a}, @var{perm})\n\ | |
| 2199 Return the generalized transpose for an N-d array object @var{a}.\n\ | |
| 2200 The permutation vector @var{perm} must contain the elements\n\ | |
| 2201 @code{1:ndims(a)} (in any order, but each element must appear just once).\n\ | |
| 5642 | 2202 @seealso{ipermute}\n\ |
| 2203 @end deftypefn") | |
| 4593 | 2204 { |
| 6959 | 2205 return do_permute (args, false); |
| 4593 | 2206 } |
| 2207 | |
| 2208 DEFUN (ipermute, args, , | |
| 2209 "-*- texinfo -*-\n\ | |
| 2210 @deftypefn {Built-in Function} {} ipermute (@var{a}, @var{iperm})\n\ | |
| 2211 The inverse of the @code{permute} function. The expression\n\ | |
| 2212 \n\ | |
| 2213 @example\n\ | |
| 2214 ipermute (permute (a, perm), perm)\n\ | |
| 2215 @end example\n\ | |
| 2216 returns the original array @var{a}.\n\ | |
| 5642 | 2217 @seealso{permute}\n\ |
| 2218 @end deftypefn") | |
| 4593 | 2219 { |
| 6959 | 2220 return do_permute (args, true); |
| 4593 | 2221 } |
| 2222 | |
| 3195 | 2223 DEFUN (length, args, , |
| 3373 | 2224 "-*- texinfo -*-\n\ |
| 2225 @deftypefn {Built-in Function} {} length (@var{a})\n\ | |
| 4176 | 2226 Return the `length' of the object @var{a}. For matrix objects, the\n\ |
| 3373 | 2227 length is the number of rows or columns, whichever is greater (this\n\ |
| 6556 | 2228 odd definition is used for compatibility with @sc{Matlab}).\n\ |
| 3373 | 2229 @end deftypefn") |
| 3195 | 2230 { |
| 2231 octave_value retval; | |
| 2232 | |
| 2233 if (args.length () == 1) | |
| 2234 { | |
| 2235 int len = args(0).length (); | |
| 2236 | |
| 2237 if (! error_state) | |
| 4233 | 2238 retval = len; |
| 3195 | 2239 } |
| 2240 else | |
| 5823 | 2241 print_usage (); |
| 3195 | 2242 |
| 2243 return retval; | |
| 2244 } | |
| 2245 | |
| 4554 | 2246 DEFUN (ndims, args, , |
| 2247 "-*- texinfo -*-\n\ | |
| 2248 @deftypefn {Built-in Function} {} ndims (@var{a})\n\ | |
| 2249 Returns the number of dimensions of array @var{a}.\n\ | |
| 2250 For any array, the result will always be larger than or equal to 2.\n\ | |
| 2251 Trailing singleton dimensions are not counted.\n\ | |
| 2252 @end deftypefn") | |
| 2253 { | |
| 2254 octave_value retval; | |
| 2255 | |
| 2256 if (args.length () == 1) | |
| 2257 { | |
| 2258 int n_dims = args(0).ndims (); | |
| 2259 | |
| 2260 if (! error_state) | |
| 2261 retval = n_dims; | |
| 2262 } | |
| 2263 else | |
| 5823 | 2264 print_usage (); |
| 4554 | 2265 |
| 2266 return retval; | |
| 2267 } | |
| 2268 | |
| 4559 | 2269 DEFUN (numel, args, , |
| 2270 "-*- texinfo -*-\n\ | |
| 2271 @deftypefn {Built-in Function} {} numel (@var{a})\n\ | |
| 2272 Returns the number of elements in the object @var{a}.\n\ | |
| 5724 | 2273 @seealso{size}\n\ |
| 4559 | 2274 @end deftypefn") |
| 2275 { | |
| 2276 octave_value retval; | |
| 2277 | |
| 2278 if (args.length () == 1) | |
| 2279 { | |
| 2280 int numel = args(0).numel (); | |
| 2281 | |
| 2282 if (! error_state) | |
| 2283 { | |
| 2284 if (numel < 0) | |
| 2285 numel = 0; | |
| 2286 | |
| 2287 retval = numel; | |
| 2288 } | |
| 2289 } | |
| 2290 else | |
| 5823 | 2291 print_usage (); |
| 4559 | 2292 |
| 2293 return retval; | |
| 2294 } | |
| 2295 | |
| 1957 | 2296 DEFUN (size, args, nargout, |
| 3373 | 2297 "-*- texinfo -*-\n\ |
| 2298 @deftypefn {Built-in Function} {} size (@var{a}, @var{n})\n\ | |
| 2299 Return the number rows and columns of @var{a}.\n\ | |
| 2300 \n\ | |
| 2301 With one input argument and one output argument, the result is returned\n\ | |
| 4741 | 2302 in a row vector. If there are multiple output arguments, the number of\n\ |
| 2303 rows is assigned to the first, and the number of columns to the second,\n\ | |
| 2304 etc. For example,\n\ | |
| 3373 | 2305 \n\ |
| 2306 @example\n\ | |
| 2307 @group\n\ | |
| 2308 size ([1, 2; 3, 4; 5, 6])\n\ | |
| 2309 @result{} [ 3, 2 ]\n\ | |
| 1031 | 2310 \n\ |
| 3373 | 2311 [nr, nc] = size ([1, 2; 3, 4; 5, 6])\n\ |
| 2312 @result{} nr = 3\n\ | |
| 2313 @result{} nc = 2\n\ | |
| 2314 @end group\n\ | |
| 2315 @end example\n\ | |
| 2316 \n\ | |
| 4741 | 2317 If given a second argument, @code{size} will return the size of the\n\ |
| 2318 corresponding dimension. For example\n\ | |
| 1031 | 2319 \n\ |
| 3373 | 2320 @example\n\ |
| 2321 size ([1, 2; 3, 4; 5, 6], 2)\n\ | |
| 2322 @result{} 2\n\ | |
| 2323 @end example\n\ | |
| 2324 \n\ | |
| 2325 @noindent\n\ | |
| 2326 returns the number of columns in the given matrix.\n\ | |
| 5724 | 2327 @seealso{numel}\n\ |
| 3373 | 2328 @end deftypefn") |
| 523 | 2329 { |
| 2086 | 2330 octave_value_list retval; |
| 523 | 2331 |
| 2332 int nargin = args.length (); | |
| 2333 | |
| 4513 | 2334 if (nargin == 1) |
| 523 | 2335 { |
| 4513 | 2336 dim_vector dimensions = args(0).dims (); |
| 2337 | |
| 2338 int ndims = dimensions.length (); | |
| 1031 | 2339 |
| 4513 | 2340 Matrix m (1, ndims); |
| 2341 | |
| 2342 if (nargout > 1) | |
| 523 | 2343 { |
| 5991 | 2344 for (int i = nargout-1; i >= ndims; i--) |
| 2345 retval(i) = 1; | |
| 2346 | |
| 6197 | 2347 if (ndims > nargout) |
| 2348 { | |
| 2349 octave_idx_type d = 1; | |
| 2350 | |
| 2351 while (ndims >= nargout) | |
| 2352 d *= dimensions(--ndims); | |
| 2353 | |
| 2354 retval(ndims) = d; | |
| 2355 } | |
| 2356 | |
| 4513 | 2357 while (ndims--) |
| 2358 retval(ndims) = dimensions(ndims); | |
| 523 | 2359 } |
| 4513 | 2360 else |
| 712 | 2361 { |
| 4513 | 2362 for (int i = 0; i < ndims; i++) |
| 2363 m(0, i) = dimensions(i); | |
| 2364 | |
| 2365 retval(0) = m; | |
| 712 | 2366 } |
| 1031 | 2367 } |
| 2368 else if (nargin == 2 && nargout < 2) | |
| 2369 { | |
| 5275 | 2370 octave_idx_type nd = args(1).int_value (true); |
| 1031 | 2371 |
| 2372 if (error_state) | |
| 2373 error ("size: expecting scalar as second argument"); | |
| 712 | 2374 else |
| 1031 | 2375 { |
| 4741 | 2376 dim_vector dv = args(0).dims (); |
| 2377 | |
| 4911 | 2378 if (nd > 0) |
| 2379 { | |
| 2380 if (nd <= dv.length ()) | |
| 2381 retval(0) = dv(nd-1); | |
| 2382 else | |
| 2383 retval(0) = 1; | |
| 2384 } | |
| 1031 | 2385 else |
| 4741 | 2386 error ("size: requested dimension (= %d) out of range", nd); |
| 1031 | 2387 } |
| 523 | 2388 } |
| 712 | 2389 else |
| 5823 | 2390 print_usage (); |
| 523 | 2391 |
| 2392 return retval; | |
| 2393 } | |
| 2394 | |
| 6156 | 2395 DEFUN (size_equal, args, , |
| 2396 "-*- texinfo -*-\n\ | |
| 6561 | 2397 @deftypefn {Built-in Function} {} size_equal (@var{a}, @var{b}, @dots{})\n\ |
| 2398 Return true if the dimensions of all arguments agree.\n\ | |
| 6156 | 2399 Trailing singleton dimensions are ignored.\n\ |
| 2400 @seealso{size, numel}\n\ | |
| 2401 @end deftypefn") | |
| 2402 { | |
| 2403 octave_value retval; | |
| 2404 | |
| 6561 | 2405 int nargin = args.length (); |
| 2406 | |
| 2407 if (nargin >= 2) | |
| 6156 | 2408 { |
| 6561 | 2409 retval = true; |
| 2410 | |
| 6156 | 2411 dim_vector a_dims = args(0).dims (); |
| 2412 a_dims.chop_trailing_singletons (); | |
| 6561 | 2413 |
| 2414 for (int i = 1; i < nargin; ++i) | |
| 2415 { | |
| 2416 dim_vector b_dims = args(i).dims (); | |
| 2417 b_dims.chop_trailing_singletons (); | |
| 2418 | |
| 2419 if (a_dims != b_dims) | |
| 2420 { | |
| 2421 retval = false; | |
| 2422 break; | |
| 2423 } | |
| 2424 } | |
| 6156 | 2425 } |
| 2426 else | |
| 2427 print_usage (); | |
| 2428 | |
| 2429 return retval; | |
| 2430 } | |
| 2431 | |
| 5602 | 2432 DEFUN (nnz, args, , |
| 2433 "-*- texinfo -*-\n\ | |
| 6156 | 2434 @deftypefn {Built-in Function} {@var{scalar} =} nnz (@var{a})\n\ |
| 2435 Returns the number of non zero elements in @var{a}.\n\ | |
| 5602 | 2436 @seealso{sparse}\n\ |
| 2437 @end deftypefn") | |
| 2438 { | |
| 2439 octave_value retval; | |
| 2440 | |
| 2441 if (args.length () == 1) | |
| 2442 retval = args(0).nnz (); | |
| 2443 else | |
| 5823 | 2444 print_usage (); |
| 5602 | 2445 |
| 2446 return retval; | |
| 2447 } | |
| 2448 | |
| 5604 | 2449 DEFUN (nzmax, args, , |
| 2450 "-*- texinfo -*-\n\ | |
| 6156 | 2451 @deftypefn {Built-in Function} {@var{scalar} =} nzmax (@var{SM})\n\ |
| 5604 | 2452 Return the amount of storage allocated to the sparse matrix @var{SM}.\n\ |
| 7001 | 2453 Note that Octave tends to crop unused memory at the first opportunity\n\ |
| 5604 | 2454 for sparse objects. There are some cases of user created sparse objects\n\ |
| 2455 where the value returned by @dfn{nzmaz} will not be the same as @dfn{nnz},\n\ | |
| 2456 but in general they will give the same result.\n\ | |
| 2457 @seealso{sparse, spalloc}\n\ | |
| 2458 @end deftypefn") | |
| 2459 { | |
| 2460 octave_value retval; | |
| 2461 | |
| 2462 if (args.length() == 1) | |
| 2463 retval = args(0).nzmax (); | |
| 2464 else | |
| 5823 | 2465 print_usage (); |
| 5604 | 2466 |
| 2467 return retval; | |
| 2468 } | |
| 2469 | |
| 5677 | 2470 DEFUN (rows, args, , |
| 2471 "-*- texinfo -*-\n\ | |
| 2472 @deftypefn {Built-in Function} {} rows (@var{a})\n\ | |
| 2473 Return the number of rows of @var{a}.\n\ | |
| 5724 | 2474 @seealso{size, numel, columns, length, isscalar, isvector, ismatrix}\n\ |
| 5677 | 2475 @end deftypefn") |
| 2476 { | |
| 2477 octave_value retval; | |
| 2478 | |
| 2479 if (args.length () == 1) | |
| 2480 retval = args(0).rows (); | |
| 2481 else | |
| 5823 | 2482 print_usage (); |
| 5677 | 2483 |
| 2484 return retval; | |
| 2485 } | |
| 2486 | |
| 2487 DEFUN (columns, args, , | |
| 2488 "-*- texinfo -*-\n\ | |
| 2489 @deftypefn {Built-in Function} {} columns (@var{a})\n\ | |
| 2490 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
|
2491 @seealso{size, numel, rows, length, isscalar, isvector, ismatrix}\n\ |
| 5677 | 2492 @end deftypefn") |
| 2493 { | |
| 2494 octave_value retval; | |
| 2495 | |
| 2496 if (args.length () == 1) | |
| 2497 retval = args(0).columns (); | |
| 2498 else | |
| 5823 | 2499 print_usage (); |
| 5677 | 2500 |
| 2501 return retval; | |
| 2502 } | |
| 2503 | |
| 1957 | 2504 DEFUN (sum, args, , |
| 3428 | 2505 "-*- texinfo -*-\n\ |
| 3723 | 2506 @deftypefn {Built-in Function} {} sum (@var{x}, @var{dim})\n\ |
| 7112 | 2507 @deftypefnx {Built-in Function} {} sum (@dots{}, 'native')\n\ |
| 3723 | 2508 Sum of elements along dimension @var{dim}. If @var{dim} is\n\ |
| 2509 omitted, it defaults to 1 (column-wise sum).\n\ | |
| 5061 | 2510 \n\ |
| 2511 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\ | |
| 2512 return the sum of the elements.\n\ | |
| 7112 | 2513 \n\ |
| 2514 If the optional argument 'native' is given, then the sum is performed\n\ | |
| 2515 in the same type as the original argument, rather than in the default\n\ | |
| 2516 double type. For example\n\ | |
| 2517 \n\ | |
| 2518 @example\n\ | |
| 2519 sum ([true, true])\n\ | |
| 2520 @result{} 2\n\ | |
| 2521 sum ([true, true], 'native')\n\ | |
| 2522 @result{} true\n\ | |
| 2523 @end example\n\ | |
| 3428 | 2524 @end deftypefn") |
| 523 | 2525 { |
| 7112 | 2526 NATIVE_REDUCTION (sum); |
| 523 | 2527 } |
| 2528 | |
| 7112 | 2529 /* |
| 2530 | |
| 2531 %!assert (sum([true,true]), 2) | |
| 2532 %!assert (sum([true,true],'native'), true) | |
| 2533 %!assert (sum(int8([127,10,-20])), 117); | |
| 2534 %!assert (sum(int8([127,10,-20]),'native'), int8(107)); | |
| 2535 | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2536 %!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
|
2537 %!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
|
2538 %!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
|
2539 %!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
|
2540 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2541 %!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
|
2542 %!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
|
2543 %!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
|
2544 %!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
|
2545 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2546 %!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
|
2547 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2548 %!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
|
2549 %!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
|
2550 %!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
|
2551 %!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
|
2552 %!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
|
2553 %!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
|
2554 %!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
|
2555 %!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
|
2556 %!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
|
2557 %!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
|
2558 %!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
|
2559 %!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
|
2560 %!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
|
2561 %!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
|
2562 %!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
|
2563 %!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
|
2564 %!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
|
2565 %!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
|
2566 %!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
|
2567 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2568 %!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
|
2569 %!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
|
2570 %!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
|
2571 %!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
|
2572 %!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
|
2573 %!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
|
2574 %!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
|
2575 %!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
|
2576 %!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
|
2577 %!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
|
2578 %!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
|
2579 %!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
|
2580 %!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
|
2581 %!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
|
2582 %!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
|
2583 %!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
|
2584 %!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
|
2585 %!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
|
2586 %!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
|
2587 |
| 7112 | 2588 */ |
| 2589 | |
| 1957 | 2590 DEFUN (sumsq, args, , |
| 3428 | 2591 "-*- texinfo -*-\n\ |
| 3723 | 2592 @deftypefn {Built-in Function} {} sumsq (@var{x}, @var{dim})\n\ |
| 2593 Sum of squares of elements along dimension @var{dim}. If @var{dim}\n\ | |
| 2594 is omitted, it defaults to 1 (column-wise sum of squares).\n\ | |
| 3095 | 2595 \n\ |
| 5061 | 2596 As a special case, if @var{x} is a vector and @var{dim} is omitted,\n\ |
| 2597 return the sum of squares of the elements.\n\ | |
| 2598 \n\ | |
| 2599 This function is conceptually equivalent to computing\n\ | |
| 3723 | 2600 @example\n\ |
| 2601 sum (x .* conj (x), dim)\n\ | |
| 2602 @end example\n\ | |
| 2603 but it uses less memory and avoids calling conj if @var{x} is real.\n\ | |
| 3428 | 2604 @end deftypefn") |
| 523 | 2605 { |
| 3723 | 2606 DATA_REDUCTION (sumsq); |
| 523 | 2607 } |
| 2608 | |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2609 /* |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2610 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2611 %!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
|
2612 %!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
|
2613 %!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
|
2614 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2615 %!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
|
2616 %!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
|
2617 %!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
|
2618 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2619 %!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
|
2620 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2621 %!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
|
2622 %!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
|
2623 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2624 %!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
|
2625 %!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
|
2626 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2627 */ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2628 |
| 6688 | 2629 DEFUN (islogical, args, , |
| 3428 | 2630 "-*- texinfo -*-\n\ |
| 7144 | 2631 @deftypefn {Built-in Function} {} islogical (@var{x})\n\ |
| 6688 | 2632 Return true if @var{x} is a logical object.\n\ |
| 3439 | 2633 @end deftypefn") |
| 3209 | 2634 { |
| 2635 octave_value retval; | |
| 2636 | |
| 2637 if (args.length () == 1) | |
| 3258 | 2638 retval = args(0).is_bool_type (); |
| 3209 | 2639 else |
| 5823 | 2640 print_usage (); |
| 3209 | 2641 |
| 2642 return retval; | |
| 2643 } | |
| 2644 | |
| 6688 | 2645 DEFALIAS (isbool, islogical); |
| 3209 | 2646 |
|
7815
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2647 /* |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2648 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2649 %!assert (islogical(true), true) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2650 %!assert (islogical(false), true) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2651 %!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
|
2652 %!assert (islogical(1), false) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2653 %!assert (islogical(1i), false) |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2654 %!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
|
2655 %!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
|
2656 %!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
|
2657 %!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
|
2658 |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2659 */ |
|
a41df65f3f00
Add some single precision test code and fix resulting bugs
David Bateman <dbateman@free.fr>
parents:
7814
diff
changeset
|
2660 |
| 6223 | 2661 DEFUN (isinteger, args, , |
| 2662 "-*- texinfo -*-\n\ | |
| 6230 | 2663 @deftypefn {Built-in Function} {} isinteger (@var{x})\n\ |
| 6223 | 2664 Return true if @var{x} is an integer object (int8, uint8, int16, etc.).\n\ |
| 2665 Note that @code{isinteger (14)} is false because numeric constants in\n\ | |
| 2666 are double precision floating point values.\n\ | |
| 2667 @seealso{isreal, isnumeric, class, isa}\n\ | |
| 2668 @end deftypefn") | |
| 2669 { | |
| 2670 octave_value retval; | |
| 2671 | |
| 2672 if (args.length () == 1) | |
| 2673 retval = args(0).is_integer_type (); | |
| 2674 else | |
| 2675 print_usage (); | |
| 2676 | |
| 2677 return retval; | |
| 2678 } | |
| 2679 | |
| 4028 | 2680 DEFUN (iscomplex, args, , |
| 3428 | 2681 "-*- texinfo -*-\n\ |
| 4028 | 2682 @deftypefn {Built-in Function} {} iscomplex (@var{x})\n\ |
| 3428 | 2683 Return true if @var{x} is a complex-valued numeric object.\n\ |
| 2684 @end deftypefn") | |
| 3186 | 2685 { |
| 2686 octave_value retval; | |
| 2687 | |
| 2688 if (args.length () == 1) | |
| 3258 | 2689 retval = args(0).is_complex_type (); |
| 3186 | 2690 else |
| 5823 | 2691 print_usage (); |
| 3186 | 2692 |
| 2693 return retval; | |
| 2694 } | |
| 2695 | |
| 7576 | 2696 DEFUN (isfloat, args, , |
| 2697 "-*- texinfo -*-\n\ | |
| 2698 @deftypefn {Built-in Function} {} isfloat (@var{x})\n\ | |
| 2699 Return true if @var{x} is a floating-point numeric object.\n\ | |
| 2700 @end deftypefn") | |
| 2701 { | |
| 2702 octave_value retval; | |
| 2703 | |
| 2704 if (args.length () == 1) | |
| 2705 retval = args(0).is_float_type (); | |
| 2706 else | |
| 2707 print_usage (); | |
| 2708 | |
| 2709 return retval; | |
| 2710 } | |
| 2711 | |
| 5775 | 2712 // FIXME -- perhaps this should be implemented with an |
| 5476 | 2713 // octave_value member function? |
| 2714 | |
| 2715 DEFUN (complex, args, , | |
| 2716 "-*- texinfo -*-\n\ | |
| 2717 @deftypefn {Built-in Function} {} complex (@var{val})\n\ | |
| 2718 @deftypefnx {Built-in Function} {} complex (@var{re}, @var{im})\n\ | |
| 2719 Convert @var{x} to a complex value.\n\ | |
| 2720 @end deftypefn") | |
| 2721 { | |
| 2722 octave_value retval; | |
| 2723 | |
| 2724 int nargin = args.length (); | |
| 2725 | |
| 2726 if (nargin == 1) | |
| 2727 { | |
| 2728 octave_value arg = args(0); | |
| 2729 | |
| 2730 if (arg.is_complex_type ()) | |
| 2731 retval = arg; | |
| 2732 else | |
| 2733 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2734 if (arg.is_sparse_type ()) |
| 5476 | 2735 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2736 SparseComplexMatrix val = arg.sparse_complex_matrix_value (); |
| 5476 | 2737 |
| 2738 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2739 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
|
2740 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2741 else if (arg.is_single_type ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2742 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2743 if (arg.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2744 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2745 FloatComplex val = arg.float_complex_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2746 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2747 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2748 retval = octave_value (new octave_float_complex (val)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2749 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2750 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2751 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2752 FloatComplexNDArray val = arg.float_complex_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2753 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2754 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2755 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
|
2756 } |
| 5476 | 2757 } |
| 2758 else | |
| 2759 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2760 if (arg.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2761 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2762 Complex val = arg.complex_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2763 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2764 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2765 retval = octave_value (new octave_complex (val)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2766 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2767 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2768 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2769 ComplexNDArray val = arg.complex_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2770 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2771 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2772 retval = octave_value (new octave_complex_matrix (val)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2773 } |
| 5476 | 2774 } |
| 2775 | |
| 2776 if (error_state) | |
| 2777 error ("complex: invalid conversion"); | |
| 2778 } | |
| 2779 } | |
| 2780 else if (nargin == 2) | |
| 2781 { | |
| 2782 octave_value re = args(0); | |
| 2783 octave_value im = args(1); | |
| 2784 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2785 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
|
2786 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2787 const SparseMatrix re_val = re.sparse_matrix_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2788 const SparseMatrix im_val = im.sparse_matrix_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2789 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2790 if (!error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2791 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2792 if (re.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2793 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2794 SparseComplexMatrix result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2795 if (re_val.nnz () == 0) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2796 result = Complex(0, 1) * SparseComplexMatrix (im_val); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2797 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2798 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2799 result = SparseComplexMatrix (im_val.dims (), re_val (0)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2800 octave_idx_type nr = im_val.rows (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2801 octave_idx_type nc = im_val.cols (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2802 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2803 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
|
2804 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2805 octave_idx_type off = j * nr; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2806 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
|
2807 i < im_val.cidx(j + 1); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2808 result.data (im_val.ridx(i) + off) = |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2809 result.data (im_val.ridx(i) + off) + |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2810 Complex (0, im_val.data (i)); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2811 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2812 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2813 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
|
2814 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2815 else if (im.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2816 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2817 SparseComplexMatrix result; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2818 if (im_val.nnz () == 0) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2819 result = SparseComplexMatrix (re_val); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2820 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2821 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2822 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
|
2823 octave_idx_type nr = re_val.rows (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2824 octave_idx_type nc = re_val.cols (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2825 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2826 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
|
2827 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2828 octave_idx_type off = j * nr; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2829 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
|
2830 i < re_val.cidx(j + 1); i++) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2831 result.data (re_val.ridx(i) + off) = |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2832 result.data (re_val.ridx(i) + off) + |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2833 re_val.data (i); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2834 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2835 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2836 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
|
2837 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2838 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2839 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2840 if (re_val.dims () == im_val.dims ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2841 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2842 SparseComplexMatrix result = SparseComplexMatrix(re_val) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2843 + Complex(0, 1) * SparseComplexMatrix (im_val); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2844 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
|
2845 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2846 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2847 error ("complex: dimension mismatch"); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2848 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2849 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2850 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2851 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
|
2852 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2853 if (re.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2854 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2855 float re_val = re.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2856 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2857 if (im.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2858 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2859 float im_val = im.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2860 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2861 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2862 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
|
2863 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2864 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2865 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2866 const FloatNDArray im_val = im.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2867 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2868 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2869 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2870 FloatComplexNDArray result (im_val.dims (), FloatComplex ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2871 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2872 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
|
2873 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
|
2874 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2875 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
|
2876 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2877 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2878 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2879 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2880 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2881 const FloatNDArray re_val = re.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2882 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2883 if (im.numel () == 1) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2884 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2885 float im_val = im.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2886 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2887 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2888 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2889 FloatComplexNDArray result (re_val.dims (), FloatComplex ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2890 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2891 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
|
2892 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
|
2893 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2894 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
|
2895 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2896 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2897 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2898 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2899 const FloatNDArray im_val = im.float_array_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2900 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2901 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2902 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2903 if (re_val.dims () == im_val.dims ()) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2904 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2905 FloatComplexNDArray result (re_val.dims (), FloatComplex ()); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2906 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2907 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
|
2908 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
|
2909 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2910 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
|
2911 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2912 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2913 error ("complex: dimension mismatch"); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2914 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2915 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2916 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2917 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
2918 else if (re.numel () == 1) |
| 5476 | 2919 { |
| 2920 double re_val = re.double_value (); | |
| 2921 | |
| 2922 if (im.numel () == 1) | |
| 2923 { | |
| 2924 double im_val = im.double_value (); | |
| 2925 | |
| 2926 if (! error_state) | |
| 2927 retval = octave_value (new octave_complex (Complex (re_val, im_val))); | |
| 2928 } | |
| 2929 else | |
| 2930 { | |
| 2931 const NDArray im_val = im.array_value (); | |
| 2932 | |
| 2933 if (! error_state) | |
| 2934 { | |
| 2935 ComplexNDArray result (im_val.dims (), Complex ()); | |
| 2936 | |
| 2937 for (octave_idx_type i = 0; i < im_val.numel (); i++) | |
| 2938 result.xelem (i) = Complex (re_val, im_val(i)); | |
| 2939 | |
| 2940 retval = octave_value (new octave_complex_matrix (result)); | |
| 2941 } | |
| 2942 } | |
| 2943 } | |
| 2944 else | |
| 2945 { | |
| 2946 const NDArray re_val = re.array_value (); | |
| 2947 | |
| 2948 if (im.numel () == 1) | |
| 2949 { | |
| 2950 double im_val = im.double_value (); | |
| 2951 | |
| 2952 if (! error_state) | |
| 2953 { | |
| 2954 ComplexNDArray result (re_val.dims (), Complex ()); | |
| 2955 | |
| 2956 for (octave_idx_type i = 0; i < re_val.numel (); i++) | |
| 2957 result.xelem (i) = Complex (re_val(i), im_val); | |
| 2958 | |
| 2959 retval = octave_value (new octave_complex_matrix (result)); | |
| 2960 } | |
| 2961 } | |
| 2962 else | |
| 2963 { | |
| 2964 const NDArray im_val = im.array_value (); | |
| 2965 | |
| 2966 if (! error_state) | |
| 2967 { | |
| 2968 if (re_val.dims () == im_val.dims ()) | |
| 2969 { | |
| 2970 ComplexNDArray result (re_val.dims (), Complex ()); | |
| 2971 | |
| 2972 for (octave_idx_type i = 0; i < re_val.numel (); i++) | |
| 2973 result.xelem (i) = Complex (re_val(i), im_val(i)); | |
| 2974 | |
| 2975 retval = octave_value (new octave_complex_matrix (result)); | |
| 2976 } | |
| 2977 else | |
| 2978 error ("complex: dimension mismatch"); | |
| 2979 } | |
| 2980 } | |
| 2981 } | |
| 2982 | |
| 2983 if (error_state) | |
| 2984 error ("complex: invalid conversion"); | |
| 2985 } | |
| 2986 else | |
| 5823 | 2987 print_usage (); |
| 5476 | 2988 |
| 2989 return retval; | |
| 2990 } | |
| 2991 | |
| 3258 | 2992 DEFUN (isreal, args, , |
| 3428 | 2993 "-*- texinfo -*-\n\ |
| 2994 @deftypefn {Built-in Function} {} isreal (@var{x})\n\ | |
| 2995 Return true if @var{x} is a real-valued numeric object.\n\ | |
| 2996 @end deftypefn") | |
| 3258 | 2997 { |
| 2998 octave_value retval; | |
| 2999 | |
| 3000 if (args.length () == 1) | |
| 3001 retval = args(0).is_real_type (); | |
| 3002 else | |
| 5823 | 3003 print_usage (); |
| 3258 | 3004 |
| 3005 return retval; | |
| 3006 } | |
| 3007 | |
| 3202 | 3008 DEFUN (isempty, args, , |
| 3373 | 3009 "-*- texinfo -*-\n\ |
| 3010 @deftypefn {Built-in Function} {} isempty (@var{a})\n\ | |
| 3011 Return 1 if @var{a} is an empty matrix (either the number of rows, or\n\ | |
| 3012 the number of columns, or both are zero). Otherwise, return 0.\n\ | |
| 3013 @end deftypefn") | |
| 3202 | 3014 { |
| 4233 | 3015 octave_value retval = false; |
| 3202 | 3016 |
| 3017 if (args.length () == 1) | |
| 4559 | 3018 retval = args(0).is_empty (); |
| 3202 | 3019 else |
| 5823 | 3020 print_usage (); |
| 3202 | 3021 |
| 3022 return retval; | |
| 3023 } | |
| 3024 | |
| 3206 | 3025 DEFUN (isnumeric, args, , |
| 3428 | 3026 "-*- texinfo -*-\n\ |
| 3027 @deftypefn {Built-in Function} {} isnumeric (@var{x})\n\ | |
| 3028 Return nonzero if @var{x} is a numeric object.\n\ | |
| 3029 @end deftypefn") | |
| 3206 | 3030 { |
| 3031 octave_value retval; | |
| 3032 | |
| 3033 if (args.length () == 1) | |
| 3258 | 3034 retval = args(0).is_numeric_type (); |
| 3206 | 3035 else |
| 5823 | 3036 print_usage (); |
| 3206 | 3037 |
| 3038 return retval; | |
| 3039 } | |
| 3040 | |
| 4028 | 3041 DEFUN (islist, args, , |
| 3526 | 3042 "-*- texinfo -*-\n\ |
| 4028 | 3043 @deftypefn {Built-in Function} {} islist (@var{x})\n\ |
| 3428 | 3044 Return nonzero if @var{x} is a list.\n\ |
| 3045 @end deftypefn") | |
| 3204 | 3046 { |
| 3047 octave_value retval; | |
| 3048 | |
| 3049 if (args.length () == 1) | |
| 3258 | 3050 retval = args(0).is_list (); |
| 3204 | 3051 else |
| 5823 | 3052 print_usage (); |
| 3204 | 3053 |
| 3054 return retval; | |
| 3055 } | |
| 3056 | |
| 4028 | 3057 DEFUN (ismatrix, args, , |
| 3321 | 3058 "-*- texinfo -*-\n\ |
| 4028 | 3059 @deftypefn {Built-in Function} {} ismatrix (@var{a})\n\ |
| 3321 | 3060 Return 1 if @var{a} is a matrix. Otherwise, return 0.\n\ |
| 3333 | 3061 @end deftypefn") |
| 3202 | 3062 { |
| 4233 | 3063 octave_value retval = false; |
| 3202 | 3064 |
| 3065 if (args.length () == 1) | |
| 3066 { | |
| 3067 octave_value arg = args(0); | |
| 3068 | |
| 3212 | 3069 if (arg.is_scalar_type () || arg.is_range ()) |
| 4233 | 3070 retval = true; |
| 3202 | 3071 else if (arg.is_matrix_type ()) |
| 4233 | 3072 retval = (arg.rows () >= 1 && arg.columns () >= 1); |
| 3202 | 3073 } |
| 3074 else | |
| 5823 | 3075 print_usage (); |
| 3202 | 3076 |
| 3077 return retval; | |
| 3078 } | |
| 3079 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3080 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3081 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3082 %!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
|
3083 %!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
|
3084 %!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
|
3085 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3086 %% 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
|
3087 %!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
|
3088 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3089 %!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
|
3090 %!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
|
3091 %!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
|
3092 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3093 %% 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
|
3094 %!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
|
3095 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3096 %!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
|
3097 %!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
|
3098 %!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
|
3099 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3100 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3101 %! 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
|
3102 %! 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
|
3103 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3104 %!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
|
3105 %!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
|
3106 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3107 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3108 |
| 3354 | 3109 static octave_value |
| 5747 | 3110 fill_matrix (const octave_value_list& args, int val, const char *fcn) |
| 523 | 3111 { |
| 3354 | 3112 octave_value retval; |
| 523 | 3113 |
| 3114 int nargin = args.length (); | |
| 3115 | |
| 4946 | 3116 oct_data_conv::data_type dt = oct_data_conv::dt_double; |
| 4481 | 3117 |
| 4946 | 3118 dim_vector dims (1, 1); |
| 4481 | 3119 |
| 3120 if (nargin > 0 && args(nargin-1).is_string ()) | |
| 3121 { | |
| 4946 | 3122 std::string nm = args(nargin-1).string_value (); |
| 4481 | 3123 nargin--; |
| 3124 | |
| 4946 | 3125 dt = oct_data_conv::string_to_data_type (nm); |
| 3126 | |
| 3127 if (error_state) | |
| 3128 return retval; | |
| 4481 | 3129 } |
| 3130 | |
| 523 | 3131 switch (nargin) |
| 3132 { | |
| 712 | 3133 case 0: |
| 3134 break; | |
| 777 | 3135 |
| 610 | 3136 case 1: |
| 4481 | 3137 get_dimensions (args(0), fcn, dims); |
| 610 | 3138 break; |
| 777 | 3139 |
| 4563 | 3140 default: |
| 3141 { | |
| 3142 dims.resize (nargin); | |
| 4481 | 3143 |
| 4563 | 3144 for (int i = 0; i < nargin; i++) |
| 3145 { | |
| 6133 | 3146 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value (); |
| 4481 | 3147 |
| 4563 | 3148 if (error_state) |
| 3149 { | |
| 4732 | 3150 error ("%s: expecting scalar integer arguments", fcn); |
| 4563 | 3151 break; |
| 3152 } | |
| 3153 } | |
| 3154 } | |
| 3155 break; | |
| 4481 | 3156 } |
| 3157 | |
| 3158 if (! error_state) | |
| 3159 { | |
| 4946 | 3160 dims.chop_trailing_singletons (); |
| 4565 | 3161 |
| 4481 | 3162 check_dimensions (dims, fcn); |
| 3354 | 3163 |
| 5775 | 3164 // FIXME -- perhaps this should be made extensible by |
| 4946 | 3165 // using the class name to lookup a function to call to create |
| 3166 // the new value. | |
| 3167 | |
| 3168 // Note that automatic narrowing will handle conversion from | |
| 3169 // NDArray to scalar. | |
| 3170 | |
| 4481 | 3171 if (! error_state) |
| 3172 { | |
| 4946 | 3173 switch (dt) |
| 3174 { | |
| 3175 case oct_data_conv::dt_int8: | |
| 3176 retval = int8NDArray (dims, val); | |
| 3177 break; | |
| 4481 | 3178 |
| 4946 | 3179 case oct_data_conv::dt_uint8: |
| 3180 retval = uint8NDArray (dims, val); | |
| 3181 break; | |
| 3182 | |
| 3183 case oct_data_conv::dt_int16: | |
| 3184 retval = int16NDArray (dims, val); | |
| 3185 break; | |
| 3186 | |
| 3187 case oct_data_conv::dt_uint16: | |
| 3188 retval = uint16NDArray (dims, val); | |
| 3189 break; | |
| 3190 | |
| 3191 case oct_data_conv::dt_int32: | |
| 3192 retval = int32NDArray (dims, val); | |
| 3193 break; | |
| 777 | 3194 |
| 4946 | 3195 case oct_data_conv::dt_uint32: |
| 3196 retval = uint32NDArray (dims, val); | |
| 3197 break; | |
| 3198 | |
| 3199 case oct_data_conv::dt_int64: | |
| 3200 retval = int64NDArray (dims, val); | |
| 3201 break; | |
| 4481 | 3202 |
| 4946 | 3203 case oct_data_conv::dt_uint64: |
| 3204 retval = uint64NDArray (dims, val); | |
| 3205 break; | |
| 4481 | 3206 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3207 case oct_data_conv::dt_single: |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3208 retval = FloatNDArray (dims, val); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3209 break; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3210 |
| 4946 | 3211 case oct_data_conv::dt_double: |
| 3212 retval = NDArray (dims, val); | |
| 3213 break; | |
| 3214 | |
| 4986 | 3215 case oct_data_conv::dt_logical: |
| 3216 retval = boolNDArray (dims, val); | |
| 3217 break; | |
| 3218 | |
| 4946 | 3219 default: |
| 3220 error ("%s: invalid class name", fcn); | |
| 3221 break; | |
| 4481 | 3222 } |
| 3223 } | |
| 523 | 3224 } |
| 3225 | |
| 3226 return retval; | |
| 3227 } | |
| 3228 | |
| 5747 | 3229 static octave_value |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3230 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
|
3231 const char *fcn) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3232 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3233 octave_value retval; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3234 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3235 int nargin = args.length (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3236 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3237 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
|
3238 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3239 dim_vector dims (1, 1); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3240 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3241 if (nargin > 0 && args(nargin-1).is_string ()) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3242 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3243 std::string nm = args(nargin-1).string_value (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3244 nargin--; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3245 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3246 dt = oct_data_conv::string_to_data_type (nm); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3247 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3248 if (error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3249 return retval; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3250 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3251 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3252 switch (nargin) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3253 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3254 case 0: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3255 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3256 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3257 case 1: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3258 get_dimensions (args(0), fcn, dims); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3259 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3260 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3261 default: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3262 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3263 dims.resize (nargin); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3264 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3265 for (int i = 0; i < nargin; i++) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3266 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3267 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
|
3268 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3269 if (error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3270 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3271 error ("%s: expecting scalar integer arguments", fcn); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3272 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3273 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3274 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3275 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3276 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3277 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3278 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3279 if (! error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3280 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3281 dims.chop_trailing_singletons (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3282 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3283 check_dimensions (dims, fcn); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3284 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3285 // Note that automatic narrowing will handle conversion from |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3286 // NDArray to scalar. |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3287 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3288 if (! error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3289 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3290 switch (dt) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3291 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3292 case oct_data_conv::dt_single: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3293 retval = FloatNDArray (dims, fval); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3294 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3295 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3296 case oct_data_conv::dt_double: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3297 retval = NDArray (dims, val); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3298 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3299 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3300 default: |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3301 error ("%s: invalid class name", fcn); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3302 break; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3303 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3304 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3305 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3306 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3307 return retval; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3308 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3309 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3310 static octave_value |
| 5747 | 3311 fill_matrix (const octave_value_list& args, double val, const char *fcn) |
| 3312 { | |
| 3313 octave_value retval; | |
| 3314 | |
| 3315 int nargin = args.length (); | |
| 3316 | |
| 3317 oct_data_conv::data_type dt = oct_data_conv::dt_double; | |
| 3318 | |
| 3319 dim_vector dims (1, 1); | |
| 3320 | |
| 3321 if (nargin > 0 && args(nargin-1).is_string ()) | |
| 3322 { | |
| 3323 std::string nm = args(nargin-1).string_value (); | |
| 3324 nargin--; | |
| 3325 | |
| 3326 dt = oct_data_conv::string_to_data_type (nm); | |
| 3327 | |
| 3328 if (error_state) | |
| 3329 return retval; | |
| 3330 } | |
| 3331 | |
| 3332 switch (nargin) | |
| 3333 { | |
| 3334 case 0: | |
| 3335 break; | |
| 3336 | |
| 3337 case 1: | |
| 3338 get_dimensions (args(0), fcn, dims); | |
| 3339 break; | |
| 3340 | |
| 3341 default: | |
| 3342 { | |
| 3343 dims.resize (nargin); | |
| 3344 | |
| 3345 for (int i = 0; i < nargin; i++) | |
| 3346 { | |
| 6133 | 3347 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value (); |
| 5747 | 3348 |
| 3349 if (error_state) | |
| 3350 { | |
| 3351 error ("%s: expecting scalar integer arguments", fcn); | |
| 3352 break; | |
| 3353 } | |
| 3354 } | |
| 3355 } | |
| 3356 break; | |
| 3357 } | |
| 3358 | |
| 3359 if (! error_state) | |
| 3360 { | |
| 3361 dims.chop_trailing_singletons (); | |
| 3362 | |
| 3363 check_dimensions (dims, fcn); | |
| 3364 | |
| 3365 // Note that automatic narrowing will handle conversion from | |
| 3366 // NDArray to scalar. | |
| 3367 | |
| 3368 if (! error_state) | |
| 3369 { | |
| 3370 switch (dt) | |
| 3371 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3372 case oct_data_conv::dt_single: |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3373 retval = FloatNDArray (dims, static_cast <float> (val)); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3374 break; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3375 |
| 5747 | 3376 case oct_data_conv::dt_double: |
| 3377 retval = NDArray (dims, val); | |
| 3378 break; | |
| 3379 | |
| 3380 default: | |
| 3381 error ("%s: invalid class name", fcn); | |
| 3382 break; | |
| 3383 } | |
| 3384 } | |
| 3385 } | |
| 3386 | |
| 3387 return retval; | |
| 3388 } | |
| 3389 | |
| 3390 static octave_value | |
| 3391 fill_matrix (const octave_value_list& args, const Complex& val, | |
| 3392 const char *fcn) | |
| 3393 { | |
| 3394 octave_value retval; | |
| 3395 | |
| 3396 int nargin = args.length (); | |
| 3397 | |
| 3398 oct_data_conv::data_type dt = oct_data_conv::dt_double; | |
| 3399 | |
| 3400 dim_vector dims (1, 1); | |
| 3401 | |
| 3402 if (nargin > 0 && args(nargin-1).is_string ()) | |
| 3403 { | |
| 3404 std::string nm = args(nargin-1).string_value (); | |
| 3405 nargin--; | |
| 3406 | |
| 3407 dt = oct_data_conv::string_to_data_type (nm); | |
| 3408 | |
| 3409 if (error_state) | |
| 3410 return retval; | |
| 3411 } | |
| 3412 | |
| 3413 switch (nargin) | |
| 3414 { | |
| 3415 case 0: | |
| 3416 break; | |
| 3417 | |
| 3418 case 1: | |
| 3419 get_dimensions (args(0), fcn, dims); | |
| 3420 break; | |
| 3421 | |
| 3422 default: | |
| 3423 { | |
| 3424 dims.resize (nargin); | |
| 3425 | |
| 3426 for (int i = 0; i < nargin; i++) | |
| 3427 { | |
| 6133 | 3428 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value (); |
| 5747 | 3429 |
| 3430 if (error_state) | |
| 3431 { | |
| 3432 error ("%s: expecting scalar integer arguments", fcn); | |
| 3433 break; | |
| 3434 } | |
| 3435 } | |
| 3436 } | |
| 3437 break; | |
| 3438 } | |
| 3439 | |
| 3440 if (! error_state) | |
| 3441 { | |
| 3442 dims.chop_trailing_singletons (); | |
| 3443 | |
| 3444 check_dimensions (dims, fcn); | |
| 3445 | |
| 3446 // Note that automatic narrowing will handle conversion from | |
| 3447 // NDArray to scalar. | |
| 3448 | |
| 3449 if (! error_state) | |
| 3450 { | |
| 3451 switch (dt) | |
| 3452 { | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3453 case oct_data_conv::dt_single: |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3454 retval = FloatComplexNDArray (dims, static_cast<FloatComplex> (val)); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3455 break; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
3456 |
| 5747 | 3457 case oct_data_conv::dt_double: |
| 3458 retval = ComplexNDArray (dims, val); | |
| 3459 break; | |
| 3460 | |
| 3461 default: | |
| 3462 error ("%s: invalid class name", fcn); | |
| 3463 break; | |
| 3464 } | |
| 3465 } | |
| 3466 } | |
| 3467 | |
| 3468 return retval; | |
| 3469 } | |
| 3470 | |
| 3471 static octave_value | |
| 3472 fill_matrix (const octave_value_list& args, bool val, const char *fcn) | |
| 3473 { | |
| 3474 octave_value retval; | |
| 3475 | |
| 3476 int nargin = args.length (); | |
| 3477 | |
| 3478 dim_vector dims (1, 1); | |
| 3479 | |
| 3480 switch (nargin) | |
| 3481 { | |
| 3482 case 0: | |
| 3483 break; | |
| 3484 | |
| 3485 case 1: | |
| 3486 get_dimensions (args(0), fcn, dims); | |
| 3487 break; | |
| 3488 | |
| 3489 default: | |
| 3490 { | |
| 3491 dims.resize (nargin); | |
| 3492 | |
| 3493 for (int i = 0; i < nargin; i++) | |
| 3494 { | |
| 6133 | 3495 dims(i) = args(i).is_empty () ? 0 : args(i).idx_type_value (); |
| 5747 | 3496 |
| 3497 if (error_state) | |
| 3498 { | |
| 3499 error ("%s: expecting scalar integer arguments", fcn); | |
| 3500 break; | |
| 3501 } | |
| 3502 } | |
| 3503 } | |
| 3504 break; | |
| 3505 } | |
| 3506 | |
| 3507 if (! error_state) | |
| 3508 { | |
| 3509 dims.chop_trailing_singletons (); | |
| 3510 | |
| 3511 check_dimensions (dims, fcn); | |
| 3512 | |
| 3513 // Note that automatic narrowing will handle conversion from | |
| 3514 // NDArray to scalar. | |
| 3515 | |
| 3516 if (! error_state) | |
| 3517 retval = boolNDArray (dims, val); | |
| 3518 } | |
| 3519 | |
| 3520 return retval; | |
| 3521 } | |
| 3522 | |
| 3354 | 3523 DEFUN (ones, args, , |
| 3369 | 3524 "-*- texinfo -*-\n\ |
| 3525 @deftypefn {Built-in Function} {} ones (@var{x})\n\ | |
| 3526 @deftypefnx {Built-in Function} {} ones (@var{n}, @var{m})\n\ | |
| 4948 | 3527 @deftypefnx {Built-in Function} {} ones (@var{n}, @var{m}, @var{k}, @dots{})\n\ |
| 3528 @deftypefnx {Built-in Function} {} ones (@dots{}, @var{class})\n\ | |
| 4481 | 3529 Return a matrix or N-dimensional array whose elements are all 1.\n\ |
| 3530 The arguments are handled the same as the arguments for @code{eye}.\n\ | |
| 3369 | 3531 \n\ |
| 3532 If you need to create a matrix whose values are all the same, you should\n\ | |
| 3533 use an expression like\n\ | |
| 3534 \n\ | |
| 3535 @example\n\ | |
| 3536 val_matrix = val * ones (n, m)\n\ | |
| 3537 @end example\n\ | |
| 4945 | 3538 \n\ |
| 3539 The optional argument @var{class}, allows @code{ones} to return an array of\n\ | |
| 5747 | 3540 the specified type, for example\n\ |
| 4945 | 3541 \n\ |
| 3542 @example\n\ | |
| 3543 val = ones (n,m, \"uint8\")\n\ | |
| 3544 @end example\n\ | |
| 3369 | 3545 @end deftypefn") |
| 523 | 3546 { |
| 5747 | 3547 return fill_matrix (args, 1, "ones"); |
| 523 | 3548 } |
| 3549 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3550 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3551 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3552 %!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
|
3553 %!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
|
3554 %!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
|
3555 %!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
|
3556 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3557 %!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
|
3558 %!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
|
3559 %!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
|
3560 %!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
|
3561 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3562 %!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
|
3563 %!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
|
3564 %!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
|
3565 %!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
|
3566 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3567 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3568 |
| 3354 | 3569 DEFUN (zeros, args, , |
| 3369 | 3570 "-*- texinfo -*-\n\ |
| 3571 @deftypefn {Built-in Function} {} zeros (@var{x})\n\ | |
| 3572 @deftypefnx {Built-in Function} {} zeros (@var{n}, @var{m})\n\ | |
| 4948 | 3573 @deftypefnx {Built-in Function} {} zeros (@var{n}, @var{m}, @var{k}, @dots{})\n\ |
| 3574 @deftypefnx {Built-in Function} {} zeros (@dots{}, @var{class})\n\ | |
| 4481 | 3575 Return a matrix or N-dimensional array whose elements are all 0.\n\ |
| 3576 The arguments are handled the same as the arguments for @code{eye}.\n\ | |
| 4945 | 3577 \n\ |
| 3578 The optional argument @var{class}, allows @code{zeros} to return an array of\n\ | |
| 5747 | 3579 the specified type, for example\n\ |
| 4945 | 3580 \n\ |
| 3581 @example\n\ | |
| 3582 val = zeros (n,m, \"uint8\")\n\ | |
| 3583 @end example\n\ | |
| 3369 | 3584 @end deftypefn") |
| 523 | 3585 { |
| 5747 | 3586 return fill_matrix (args, 0, "zeros"); |
| 3587 } | |
| 3588 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3589 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3590 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3591 %!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
|
3592 %!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
|
3593 %!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
|
3594 %!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
|
3595 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3596 %!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
|
3597 %!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
|
3598 %!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
|
3599 %!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
|
3600 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3601 %!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
|
3602 %!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
|
3603 %!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
|
3604 %!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
|
3605 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3606 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3607 |
| 5747 | 3608 DEFUN (Inf, args, , |
| 3609 "-*- texinfo -*-\n\ | |
| 3610 @deftypefn {Built-in Function} {} Inf (@var{x})\n\ | |
| 3611 @deftypefnx {Built-in Function} {} Inf (@var{n}, @var{m})\n\ | |
| 3612 @deftypefnx {Built-in Function} {} Inf (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3613 @deftypefnx {Built-in Function} {} Inf (@dots{}, @var{class})\n\ | |
| 3614 Return a matrix or N-dimensional array whose elements are all Infinity.\n\ | |
| 3615 The arguments are handled the same as the arguments for @code{eye}.\n\ | |
| 3616 The optional argument @var{class} may be either @samp{\"single\"} or\n\ | |
| 5798 | 3617 @samp{\"double\"}. The default is @samp{\"double\"}.\n\ |
| 5747 | 3618 @end deftypefn") |
| 3619 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3620 return fill_matrix (args, lo_ieee_inf_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3621 lo_ieee_float_inf_value (), "Inf"); |
| 5747 | 3622 } |
| 3623 | |
| 3624 DEFALIAS (inf, Inf); | |
| 3625 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3626 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3627 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3628 %!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
|
3629 %!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
|
3630 %!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
|
3631 %!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
|
3632 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3633 %!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
|
3634 %!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
|
3635 %!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
|
3636 %!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
|
3637 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3638 %!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
|
3639 %!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
|
3640 %!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
|
3641 %!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
|
3642 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3643 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3644 |
| 5747 | 3645 DEFUN (NaN, args, , |
| 3646 "-*- texinfo -*-\n\ | |
| 3647 @deftypefn {Built-in Function} {} NaN (@var{x})\n\ | |
| 3648 @deftypefnx {Built-in Function} {} NaN (@var{n}, @var{m})\n\ | |
| 3649 @deftypefnx {Built-in Function} {} NaN (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3650 @deftypefnx {Built-in Function} {} NaN (@dots{}, @var{class})\n\ | |
| 3651 Return a matrix or N-dimensional array whose elements are all NaN\n\ | |
| 3652 (Not a Number). The value NaN is the result of an operation like\n\ | |
| 3653 @iftex\n\ | |
| 3654 @tex\n\ | |
| 3655 $0/0$, or $\\infty - \\infty$,\n\ | |
| 3656 @end tex\n\ | |
| 3657 @end iftex\n\ | |
| 3658 @ifinfo\n\ | |
| 3659 0/0, or @samp{Inf - Inf},\n\ | |
| 3660 @end ifinfo\n\ | |
| 3661 or any operation with a NaN.\n\ | |
| 3662 \n\ | |
| 3663 Note that NaN always compares not equal to NaN. This behavior is\n\ | |
| 3664 specified by the IEEE standard for floating point arithmetic. To\n\ | |
| 3665 find NaN values, you must use the @code{isnan} function.\n\ | |
| 3666 \n\ | |
| 3667 The arguments are handled the same as the arguments for @code{eye}.\n\ | |
| 3668 The optional argument @var{class} may be either @samp{\"single\"} or\n\ | |
| 5798 | 3669 @samp{\"double\"}. The default is @samp{\"double\"}.\n\ |
| 5747 | 3670 @end deftypefn") |
| 3671 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3672 return fill_matrix (args, lo_ieee_nan_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3673 lo_ieee_float_nan_value (), "NaN"); |
| 5747 | 3674 } |
| 3675 | |
| 3676 DEFALIAS (nan, NaN); | |
| 3677 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3678 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3679 %!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
|
3680 %!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
|
3681 %!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
|
3682 %!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
|
3683 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3684 %!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
|
3685 %!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
|
3686 %!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
|
3687 %!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
|
3688 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3689 %!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
|
3690 %!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
|
3691 %!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
|
3692 %!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
|
3693 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3694 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
3695 |
| 5747 | 3696 DEFUN (e, args, , |
| 3697 "-*- texinfo -*-\n\ | |
| 3698 @deftypefn {Built-in Function} {} e (@var{x})\n\ | |
| 3699 @deftypefnx {Built-in Function} {} e (@var{n}, @var{m})\n\ | |
| 3700 @deftypefnx {Built-in Function} {} e (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3701 @deftypefnx {Built-in Function} {} e (@dots{}, @var{class})\n\ | |
| 3702 Return a matrix or N-dimensional array whose elements are all equal\n\ | |
| 3703 to the base of natural logarithms. The constant\n\ | |
| 3704 @iftex\n\ | |
| 3705 @tex\n\ | |
| 3706 $e$\n\ | |
| 3707 @end tex\n\ | |
| 3708 @end iftex\n\ | |
| 3709 @ifinfo\n\ | |
| 3710 @var{e}\n\ | |
| 3711 @end ifinfo\n\ | |
| 3712 satisfies the equation\n\ | |
| 3713 @iftex\n\ | |
| 3714 @tex\n\ | |
| 3715 $\\log (e) = 1$.\n\ | |
| 3716 @end tex\n\ | |
| 3717 @end iftex\n\ | |
| 3718 @ifinfo\n\ | |
| 3719 @code{log} (@var{e}) = 1.\n\ | |
| 3720 @end ifinfo\n\ | |
| 3721 @end deftypefn") | |
| 3722 { | |
| 3723 #if defined (M_E) | |
| 3724 double e_val = M_E; | |
| 3725 #else | |
| 3726 double e_val = exp (1.0); | |
| 3727 #endif | |
| 3728 | |
| 3729 return fill_matrix (args, e_val, "e"); | |
| 3730 } | |
| 3731 | |
| 3732 DEFUN (eps, args, , | |
| 3733 "-*- texinfo -*-\n\ | |
| 3734 @deftypefn {Built-in Function} {} eps (@var{x})\n\ | |
| 3735 @deftypefnx {Built-in Function} {} eps (@var{n}, @var{m})\n\ | |
| 3736 @deftypefnx {Built-in Function} {} eps (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3737 @deftypefnx {Built-in Function} {} eps (@dots{}, @var{class})\n\ | |
| 3738 Return a matrix or N-dimensional array whose elements are all eps,\n\ | |
| 3739 the machine precision. More precisely, @code{eps} is the largest\n\ | |
| 3740 relative spacing between any two adjacent numbers in the machine's\n\ | |
| 3741 floating point system. This number is obviously system-dependent. On\n\ | |
| 3742 machines that support 64 bit IEEE floating point arithmetic, @code{eps}\n\ | |
| 3743 is approximately\n\ | |
| 3744 @ifinfo\n\ | |
| 3745 2.2204e-16.\n\ | |
| 3746 @end ifinfo\n\ | |
| 3747 @iftex\n\ | |
| 3748 @tex\n\ | |
| 3749 $2.2204\\times10^{-16}$.\n\ | |
| 3750 @end tex\n\ | |
| 3751 @end iftex\n\ | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3752 for double precision and\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3753 @ifinfo\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3754 1.1921e-07.\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3755 @end ifinfo\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3756 @iftex\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3757 @tex\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3758 $1.1921\\times10^{-7}$.\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3759 @end tex\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3760 @end iftex\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3761 for single precision. Given a single argument @var{x}, return the\n\ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3762 distance between @var{x} and the next largest value.\n\ |
| 5747 | 3763 @end deftypefn") |
| 3764 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3765 int nargin = args.length (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3766 octave_value retval; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3767 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3768 if (nargin == 1 && ! args(0).is_string ()) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3769 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3770 if (args(0).is_single_type ()) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3771 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3772 float val = args(0).float_value (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3773 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3774 if (! error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3775 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3776 val = ::fabsf(val); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3777 if (xisnan (val) || xisinf (val)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3778 retval = fill_matrix (octave_value ("single"), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3779 lo_ieee_nan_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3780 lo_ieee_float_nan_value (), "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3781 else if (val < FLT_MIN) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3782 retval = fill_matrix (octave_value ("single"), 0e0, |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3783 powf (2.0, -149e0), "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3784 else |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3785 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3786 int expon; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3787 frexpf (val, &expon); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3788 val = std::pow (static_cast <float> (2.0), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3789 static_cast <float> (expon - 24)); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3790 retval = fill_matrix (octave_value ("single"), DBL_EPSILON, |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3791 val, "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3792 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3793 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3794 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3795 else |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3796 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3797 double val = args(0).double_value (); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3798 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3799 if (! error_state) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3800 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3801 val = ::fabs(val); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3802 if (xisnan (val) || xisinf (val)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3803 retval = fill_matrix (octave_value_list (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3804 lo_ieee_nan_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3805 lo_ieee_float_nan_value (), "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3806 else if (val < DBL_MIN) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3807 retval = fill_matrix (octave_value_list (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3808 pow (2.0, -1074e0), 0e0, "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3809 else |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3810 { |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3811 int expon; |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3812 frexp (val, &expon); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3813 val = std::pow (static_cast <double> (2.0), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3814 static_cast <double> (expon - 53)); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3815 retval = fill_matrix (octave_value_list (), val, |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3816 FLT_EPSILON, "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3817 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3818 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3819 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3820 } |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3821 else |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3822 retval = fill_matrix (args, DBL_EPSILON, FLT_EPSILON, "eps"); |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3823 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3824 return retval; |
| 5747 | 3825 } |
| 3826 | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3827 /* |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3828 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3829 %!assert(eps(1/2),2^(-53)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3830 %!assert(eps(1),2^(-52)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3831 %!assert(eps(2),2^(-51)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3832 %!assert(eps(realmax),2^971) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3833 %!assert(eps(0),2^(-1074)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3834 %!assert(eps(realmin/2),2^(-1074)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3835 %!assert(eps(realmin/16),2^(-1074)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3836 %!assert(eps(Inf),NaN) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3837 %!assert(eps(NaN),NaN) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3838 %!assert(eps(single(1/2)),single(2^(-24))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3839 %!assert(eps(single(1)),single(2^(-23))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3840 %!assert(eps(single(2)),single(2^(-22))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3841 %!assert(eps(realmax('single')),single(2^104)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3842 %!assert(eps(single(0)),single(2^(-149))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3843 %!assert(eps(realmin('single')/2),single(2^(-149))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3844 %!assert(eps(realmin('single')/16),single(2^(-149))) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3845 %!assert(eps(single(Inf)),single(NaN)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3846 %!assert(eps(single(NaN)),single(NaN)) |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3847 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3848 */ |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3849 |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3850 |
| 5747 | 3851 DEFUN (pi, args, , |
| 3852 "-*- texinfo -*-\n\ | |
| 3853 @deftypefn {Built-in Function} {} pi (@var{x})\n\ | |
| 3854 @deftypefnx {Built-in Function} {} pi (@var{n}, @var{m})\n\ | |
| 3855 @deftypefnx {Built-in Function} {} pi (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3856 @deftypefnx {Built-in Function} {} pi (@dots{}, @var{class})\n\ | |
| 3857 Return a matrix or N-dimensional array whose elements are all equal\n\ | |
| 3858 to the ratio of the circumference of a circle to its diameter.\n\ | |
| 3859 Internally, @code{pi} is computed as @samp{4.0 * atan (1.0)}.\n\ | |
| 3860 @end deftypefn") | |
| 3861 { | |
| 3862 #if defined (M_PI) | |
| 3863 double pi_val = M_PI; | |
| 3864 #else | |
| 3865 double pi_val = 4.0 * atan (1.0); | |
| 3866 #endif | |
| 3867 | |
| 3868 return fill_matrix (args, pi_val, "pi"); | |
| 3869 } | |
| 3870 | |
| 3871 DEFUN (realmax, args, , | |
| 3872 "-*- texinfo -*-\n\ | |
| 3873 @deftypefn {Built-in Function} {} realmax (@var{x})\n\ | |
| 3874 @deftypefnx {Built-in Function} {} realmax (@var{n}, @var{m})\n\ | |
| 3875 @deftypefnx {Built-in Function} {} realmax (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3876 @deftypefnx {Built-in Function} {} realmax (@dots{}, @var{class})\n\ | |
| 3877 Return a matrix or N-dimensional array whose elements are all equal\n\ | |
| 3878 to the largest floating point number that is representable. The actual\n\ | |
| 3879 value is system-dependent. On machines that support 64-bit IEEE\n\ | |
| 3880 floating point arithmetic, @code{realmax} is approximately\n\ | |
| 3881 @ifinfo\n\ | |
| 3882 1.7977e+308\n\ | |
| 3883 @end ifinfo\n\ | |
| 3884 @iftex\n\ | |
| 3885 @tex\n\ | |
| 3886 $1.7977\\times10^{308}$.\n\ | |
| 3887 @end tex\n\ | |
| 3888 @end iftex\n\ | |
| 3889 @seealso{realmin}\n\ | |
| 3890 @end deftypefn") | |
| 3891 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3892 return fill_matrix (args, DBL_MAX, FLT_MAX, "realmax"); |
| 5747 | 3893 } |
| 3894 | |
| 3895 DEFUN (realmin, args, , | |
| 3896 "-*- texinfo -*-\n\ | |
| 3897 @deftypefn {Built-in Function} {} realmin (@var{x})\n\ | |
| 3898 @deftypefnx {Built-in Function} {} realmin (@var{n}, @var{m})\n\ | |
| 3899 @deftypefnx {Built-in Function} {} realmin (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3900 @deftypefnx {Built-in Function} {} realmin (@dots{}, @var{class})\n\ | |
| 3901 Return a matrix or N-dimensional array whose elements are all equal\n\ | |
| 3902 to the smallest normalized floating point number that is representable.\n\ | |
| 3903 The actual value is system-dependent. On machines that support\n\ | |
| 3904 64-bit IEEE floating point arithmetic, @code{realmin} is approximately\n\ | |
| 3905 @ifinfo\n\ | |
| 3906 2.2251e-308\n\ | |
| 3907 @end ifinfo\n\ | |
| 3908 @iftex\n\ | |
| 3909 @tex\n\ | |
| 3910 $2.2251\\times10^{-308}$.\n\ | |
| 3911 @end tex\n\ | |
| 3912 @end iftex\n\ | |
| 3913 @seealso{realmax}\n\ | |
| 3914 @end deftypefn") | |
| 3915 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3916 return fill_matrix (args, DBL_MIN, FLT_MIN, "realmin"); |
| 5747 | 3917 } |
| 3918 | |
| 3919 DEFUN (I, args, , | |
| 3920 "-*- texinfo -*-\n\ | |
| 3921 @deftypefn {Built-in Function} {} I (@var{x})\n\ | |
| 3922 @deftypefnx {Built-in Function} {} I (@var{n}, @var{m})\n\ | |
| 3923 @deftypefnx {Built-in Function} {} I (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3924 @deftypefnx {Built-in Function} {} I (@dots{}, @var{class})\n\ | |
| 3925 Return a matrix or N-dimensional array whose elements are all equal\n\ | |
| 3926 to the pure imaginary unit, defined as\n\ | |
| 3927 @iftex\n\ | |
| 3928 @tex\n\ | |
| 3929 $\\sqrt{-1}$.\n\ | |
| 3930 @end tex\n\ | |
| 3931 @end iftex\n\ | |
| 3932 @ifinfo\n\ | |
| 3933 @code{sqrt (-1)}.\n\ | |
| 3934 @end ifinfo\n\ | |
| 7001 | 3935 Since I (also i, J, and j) is a function, you can use the name(s) for\n\ |
| 5747 | 3936 other purposes.\n\ |
| 3937 @end deftypefn") | |
| 3938 { | |
| 3939 return fill_matrix (args, Complex (0.0, 1.0), "I"); | |
| 3940 } | |
| 3941 | |
| 3942 DEFALIAS (i, I); | |
| 3943 DEFALIAS (J, I); | |
| 3944 DEFALIAS (j, I); | |
| 3945 | |
| 3946 DEFUN (NA, args, , | |
| 3947 "-*- texinfo -*-\n\ | |
| 3948 @deftypefn {Built-in Function} {} NA (@var{x})\n\ | |
| 3949 @deftypefnx {Built-in Function} {} NA (@var{n}, @var{m})\n\ | |
| 3950 @deftypefnx {Built-in Function} {} NA (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3951 @deftypefnx {Built-in Function} {} NA (@dots{}, @var{class})\n\ | |
| 3952 Return a matrix or N-dimensional array whose elements are all equal\n\ | |
| 3953 to the special constant used to designate missing values.\n\ | |
| 3954 @end deftypefn") | |
| 3955 { | |
|
7795
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3956 return fill_matrix (args, lo_ieee_na_value (), |
|
df9519e9990c
Handle single precision eps values
David Bateman <dbateman@free.fr>
parents:
7789
diff
changeset
|
3957 lo_ieee_float_na_value (), "NA"); |
| 5747 | 3958 } |
| 3959 | |
|
7991
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
3960 /* |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
3961 |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
3962 %!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
|
3963 %!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
|
3964 |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
3965 */ |
|
139f47cf17ab
Change NA value to support single to double precision conversion
David Bateman <dbateman@free.fr>
parents:
7919
diff
changeset
|
3966 |
| 5747 | 3967 DEFUN (false, args, , |
| 3968 "-*- texinfo -*-\n\ | |
| 3969 @deftypefn {Built-in Function} {} false (@var{x})\n\ | |
| 3970 @deftypefnx {Built-in Function} {} false (@var{n}, @var{m})\n\ | |
| 3971 @deftypefnx {Built-in Function} {} false (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3972 Return a matrix or N-dimensional array whose elements are all logical 0.\n\ | |
| 3973 The arguments are handled the same as the arguments for @code{eye}.\n\ | |
| 3974 @end deftypefn") | |
| 3975 { | |
| 3976 return fill_matrix (args, false, "false"); | |
| 3977 } | |
| 3978 | |
| 3979 DEFUN (true, args, , | |
| 3980 "-*- texinfo -*-\n\ | |
| 3981 @deftypefn {Built-in Function} {} true (@var{x})\n\ | |
| 3982 @deftypefnx {Built-in Function} {} true (@var{n}, @var{m})\n\ | |
| 3983 @deftypefnx {Built-in Function} {} true (@var{n}, @var{m}, @var{k}, @dots{})\n\ | |
| 3984 Return a matrix or N-dimensional array whose elements are all logical 1.\n\ | |
| 3985 The arguments are handled the same as the arguments for @code{eye}.\n\ | |
| 3986 @end deftypefn") | |
| 3987 { | |
| 3988 return fill_matrix (args, true, "true"); | |
| 3354 | 3989 } |
| 523 | 3990 |
| 4946 | 3991 template <class MT> |
| 3992 octave_value | |
| 3993 identity_matrix (int nr, int nc) | |
| 3994 { | |
| 3995 octave_value retval; | |
| 3996 | |
| 3997 typename octave_array_type_traits<MT>::element_type one (1); | |
| 3998 | |
| 3999 if (nr == 1 && nc == 1) | |
| 4000 retval = one; | |
| 4001 else | |
| 4002 { | |
| 4003 dim_vector dims (nr, nc); | |
| 4004 | |
| 4005 typename octave_array_type_traits<MT>::element_type zero (0); | |
| 4006 | |
| 4007 MT m (dims, zero); | |
| 4008 | |
| 4009 if (nr > 0 && nc > 0) | |
| 4010 { | |
| 4011 int n = std::min (nr, nc); | |
| 4012 | |
| 4013 for (int i = 0; i < n; i++) | |
| 4014 m(i,i) = one; | |
| 4015 } | |
| 4016 | |
| 4017 retval = m; | |
| 4018 } | |
| 4019 | |
| 4020 return retval; | |
| 4021 } | |
| 4022 | |
| 5058 | 4023 #define INSTANTIATE_EYE(T) \ |
| 4024 template octave_value identity_matrix<T> (int, int) | |
| 4025 | |
| 4026 INSTANTIATE_EYE (int8NDArray); | |
| 4027 INSTANTIATE_EYE (uint8NDArray); | |
| 4028 INSTANTIATE_EYE (int16NDArray); | |
| 4029 INSTANTIATE_EYE (uint16NDArray); | |
| 4030 INSTANTIATE_EYE (int32NDArray); | |
| 4031 INSTANTIATE_EYE (uint32NDArray); | |
| 4032 INSTANTIATE_EYE (int64NDArray); | |
| 4033 INSTANTIATE_EYE (uint64NDArray); | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4034 INSTANTIATE_EYE (FloatNDArray); |
| 5058 | 4035 INSTANTIATE_EYE (NDArray); |
| 4036 INSTANTIATE_EYE (boolNDArray); | |
| 4037 | |
| 4945 | 4038 static octave_value |
| 4948 | 4039 identity_matrix (int nr, int nc, oct_data_conv::data_type dt) |
| 4945 | 4040 { |
| 4041 octave_value retval; | |
| 4042 | |
| 5775 | 4043 // FIXME -- perhaps this should be made extensible by using |
| 4946 | 4044 // the class name to lookup a function to call to create the new |
| 4045 // value. | |
| 4046 | |
| 4047 if (! error_state) | |
| 4048 { | |
| 4049 switch (dt) | |
| 4050 { | |
| 4051 case oct_data_conv::dt_int8: | |
| 4052 retval = identity_matrix<int8NDArray> (nr, nc); | |
| 4053 break; | |
| 4054 | |
| 4055 case oct_data_conv::dt_uint8: | |
| 4056 retval = identity_matrix<uint8NDArray> (nr, nc); | |
| 4057 break; | |
| 4058 | |
| 4059 case oct_data_conv::dt_int16: | |
| 4060 retval = identity_matrix<int16NDArray> (nr, nc); | |
| 4061 break; | |
| 4945 | 4062 |
| 4946 | 4063 case oct_data_conv::dt_uint16: |
| 4064 retval = identity_matrix<uint16NDArray> (nr, nc); | |
| 4065 break; | |
| 4066 | |
| 4067 case oct_data_conv::dt_int32: | |
| 4068 retval = identity_matrix<int32NDArray> (nr, nc); | |
| 4069 break; | |
| 4070 | |
| 4071 case oct_data_conv::dt_uint32: | |
| 4072 retval = identity_matrix<uint32NDArray> (nr, nc); | |
| 4073 break; | |
| 4945 | 4074 |
| 4946 | 4075 case oct_data_conv::dt_int64: |
| 4076 retval = identity_matrix<int64NDArray> (nr, nc); | |
| 4077 break; | |
| 4078 | |
| 4079 case oct_data_conv::dt_uint64: | |
| 4080 retval = identity_matrix<uint64NDArray> (nr, nc); | |
| 4081 break; | |
| 4945 | 4082 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4083 case oct_data_conv::dt_single: |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4084 retval = identity_matrix<FloatNDArray> (nr, nc); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4085 break; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4086 |
| 4946 | 4087 case oct_data_conv::dt_double: |
| 4088 retval = identity_matrix<NDArray> (nr, nc); | |
| 4089 break; | |
| 4945 | 4090 |
| 4986 | 4091 case oct_data_conv::dt_logical: |
| 4092 retval = identity_matrix<boolNDArray> (nr, nc); | |
| 4093 break; | |
| 4094 | |
| 4946 | 4095 default: |
| 4096 error ("eye: invalid class name"); | |
| 4097 break; | |
| 4945 | 4098 } |
| 4099 } | |
| 4100 | |
| 4101 return retval; | |
| 4102 } | |
| 4103 | |
| 4946 | 4104 #undef INT_EYE_MATRIX |
| 4105 | |
| 1957 | 4106 DEFUN (eye, args, , |
| 3369 | 4107 "-*- texinfo -*-\n\ |
| 4108 @deftypefn {Built-in Function} {} eye (@var{x})\n\ | |
| 4109 @deftypefnx {Built-in Function} {} eye (@var{n}, @var{m})\n\ | |
| 4948 | 4110 @deftypefnx {Built-in Function} {} eye (@dots{}, @var{class})\n\ |
| 3369 | 4111 Return an identity matrix. If invoked with a single scalar argument,\n\ |
| 4112 @code{eye} returns a square matrix with the dimension specified. If you\n\ | |
| 4113 supply two scalar arguments, @code{eye} takes them to be the number of\n\ | |
| 4114 rows and columns. If given a vector with two elements, @code{eye} uses\n\ | |
| 4115 the values of the elements as the number of rows and columns,\n\ | |
| 4116 respectively. For example,\n\ | |
| 4117 \n\ | |
| 4118 @example\n\ | |
| 4119 @group\n\ | |
| 4120 eye (3)\n\ | |
| 4121 @result{} 1 0 0\n\ | |
| 4122 0 1 0\n\ | |
| 4123 0 0 1\n\ | |
| 4124 @end group\n\ | |
| 4125 @end example\n\ | |
| 4126 \n\ | |
| 4127 The following expressions all produce the same result:\n\ | |
| 4128 \n\ | |
| 4129 @example\n\ | |
| 4130 @group\n\ | |
| 4131 eye (2)\n\ | |
| 4132 @equiv{}\n\ | |
| 4133 eye (2, 2)\n\ | |
| 4134 @equiv{}\n\ | |
| 4135 eye (size ([1, 2; 3, 4])\n\ | |
| 4136 @end group\n\ | |
| 4137 @end example\n\ | |
| 4138 \n\ | |
| 4945 | 4139 The optional argument @var{class}, allows @code{eye} to return an array of\n\ |
| 4140 the specified type, like\n\ | |
| 4141 \n\ | |
| 4142 @example\n\ | |
| 4143 val = zeros (n,m, \"uint8\")\n\ | |
| 4144 @end example\n\ | |
| 4145 \n\ | |
| 6556 | 4146 Calling @code{eye} with no arguments is equivalent to calling it\n\ |
| 4147 with an argument of 1. This odd definition is for compatibility\n\ | |
| 4148 with @sc{Matlab}.\n\ | |
| 3369 | 4149 @end deftypefn") |
| 523 | 4150 { |
| 3354 | 4151 octave_value retval; |
| 523 | 4152 |
| 4948 | 4153 int nargin = args.length (); |
| 4945 | 4154 |
| 4948 | 4155 oct_data_conv::data_type dt = oct_data_conv::dt_double; |
| 523 | 4156 |
| 4945 | 4157 // Check for type information. |
| 4158 | |
| 4159 if (nargin > 0 && args(nargin-1).is_string ()) | |
| 4160 { | |
| 4948 | 4161 std::string nm = args(nargin-1).string_value (); |
| 4945 | 4162 nargin--; |
| 4948 | 4163 |
| 4164 dt = oct_data_conv::string_to_data_type (nm); | |
| 4165 | |
| 4166 if (error_state) | |
| 4167 return retval; | |
| 4945 | 4168 } |
| 4169 | |
| 523 | 4170 switch (nargin) |
| 4171 { | |
| 712 | 4172 case 0: |
| 4948 | 4173 retval = identity_matrix (1, 1, dt); |
| 712 | 4174 break; |
| 777 | 4175 |
| 610 | 4176 case 1: |
| 3354 | 4177 { |
| 5275 | 4178 octave_idx_type nr, nc; |
| 3354 | 4179 get_dimensions (args(0), "eye", nr, nc); |
| 4180 | |
| 4181 if (! error_state) | |
| 4948 | 4182 retval = identity_matrix (nr, nc, dt); |
| 3354 | 4183 } |
| 610 | 4184 break; |
| 777 | 4185 |
| 523 | 4186 case 2: |
| 3354 | 4187 { |
| 5275 | 4188 octave_idx_type nr, nc; |
| 3354 | 4189 get_dimensions (args(0), args(1), "eye", nr, nc); |
| 4190 | |
| 4191 if (! error_state) | |
| 4948 | 4192 retval = identity_matrix (nr, nc, dt); |
| 3354 | 4193 } |
| 523 | 4194 break; |
| 777 | 4195 |
| 523 | 4196 default: |
| 5823 | 4197 print_usage (); |
| 523 | 4198 break; |
| 4199 } | |
| 4200 | |
| 4201 return retval; | |
| 4202 } | |
| 4203 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4204 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4205 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4206 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4207 %!assert (eye(3), [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
|
4208 %!assert (eye(2, 3), [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
|
4209 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4210 %!assert (eye(3,'single'), single([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
|
4211 %!assert (eye(2, 3,'single'), single([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
|
4212 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4213 %!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
|
4214 %!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
|
4215 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4216 %!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
|
4217 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4218 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4219 |
| 1957 | 4220 DEFUN (linspace, args, , |
| 3369 | 4221 "-*- texinfo -*-\n\ |
| 4222 @deftypefn {Built-in Function} {} linspace (@var{base}, @var{limit}, @var{n})\n\ | |
| 4223 Return a row vector with @var{n} linearly spaced elements between\n\ | |
| 6630 | 4224 @var{base} and @var{limit}. If the number of elements is greater than one,\n\ |
| 4225 then the @var{base} and @var{limit} are always included in\n\ | |
| 3369 | 4226 the range. If @var{base} is greater than @var{limit}, the elements are\n\ |
| 4227 stored in decreasing order. If the number of points is not specified, a\n\ | |
| 4228 value of 100 is used.\n\ | |
| 1100 | 4229 \n\ |
| 4455 | 4230 The @code{linspace} function always returns a row vector.\n\ |
| 6630 | 4231 \n\ |
| 4232 For compatibility with @sc{Matlab}, return the second argument if\n\ | |
| 4233 fewer than two values are requested.\n\ | |
| 3369 | 4234 @end deftypefn") |
| 1100 | 4235 { |
| 3418 | 4236 octave_value retval; |
| 1100 | 4237 |
| 4238 int nargin = args.length (); | |
| 4239 | |
| 6133 | 4240 octave_idx_type npoints = 100; |
| 1100 | 4241 |
| 1940 | 4242 if (nargin != 2 && nargin != 3) |
| 4243 { | |
| 5823 | 4244 print_usage (); |
| 1940 | 4245 return retval; |
| 4246 } | |
| 4247 | |
| 1100 | 4248 if (nargin == 3) |
| 6133 | 4249 npoints = args(2).idx_type_value (); |
| 1100 | 4250 |
| 4251 if (! error_state) | |
| 4252 { | |
| 3322 | 4253 octave_value arg_1 = args(0); |
| 4254 octave_value arg_2 = args(1); | |
| 1100 | 4255 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4256 if (arg_1.is_single_type () || arg_2.is_single_type ()) |
| 3322 | 4257 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4258 if (arg_1.is_complex_type () || arg_2.is_complex_type ()) |
| 1100 | 4259 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4260 FloatComplex x1 = arg_1.float_complex_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4261 FloatComplex x2 = arg_2.float_complex_value (); |
| 1100 | 4262 |
| 4263 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4264 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4265 FloatComplexRowVector rv = linspace (x1, x2, npoints); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4266 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4267 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4268 retval = rv; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4269 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4270 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4271 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4272 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4273 float x1 = arg_1.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4274 float x2 = arg_2.float_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4275 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4276 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4277 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4278 FloatRowVector rv = linspace (x1, x2, npoints); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4279 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4280 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4281 retval = rv; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4282 } |
| 1100 | 4283 } |
| 4284 } | |
| 4285 else | |
| 3322 | 4286 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4287 if (arg_1.is_complex_type () || arg_2.is_complex_type ()) |
| 3322 | 4288 { |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4289 Complex x1 = arg_1.complex_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4290 Complex x2 = arg_2.complex_value (); |
| 3322 | 4291 |
| 4292 if (! error_state) | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4293 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4294 ComplexRowVector rv = linspace (x1, x2, npoints); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4295 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4296 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4297 retval = rv; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4298 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4299 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4300 else |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4301 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4302 double x1 = arg_1.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4303 double x2 = arg_2.double_value (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4304 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4305 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4306 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4307 RowVector rv = linspace (x1, x2, npoints); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4308 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4309 if (! error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4310 retval = rv; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7743
diff
changeset
|
4311 } |
| 3322 | 4312 } |
| 4313 } | |
| 1100 | 4314 } |
| 4732 | 4315 else |
| 4316 error ("linspace: expecting third argument to be an integer"); | |
| 1100 | 4317 |
| 4318 return retval; | |
| 4319 } | |
| 4320 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4321 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4322 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4323 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4324 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4325 %! 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
|
4326 %! 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
|
4327 %! 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
|
4328 %! 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
|
4329 %! && 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
|
4330 %! && 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
|
4331 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4332 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4333 % 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
|
4334 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4335 %!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
|
4336 %!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
|
4337 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4338 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4339 %! 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
|
4340 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4341 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4342 |
| 5775 | 4343 // FIXME -- should accept dimensions as separate args for N-d |
| 5734 | 4344 // arrays as well as 1-d and 2-d arrays. |
| 4345 | |
| 5731 | 4346 DEFUN (resize, args, , |
| 4347 "-*- texinfo -*-\n\ | |
| 4348 @deftypefn {Built-in Function} {} resize (@var{x}, @var{m})\n\ | |
| 4349 @deftypefnx {Built-in Function} {} resize (@var{x}, @var{m}, @var{n})\n\ | |
| 6174 | 4350 Destructively resize @var{x}.\n\ |
| 4351 \n\ | |
| 4352 @strong{Values in @var{x} are not preserved as they are with\n\ | |
| 6175 | 4353 @code{reshape}.}\n\ |
| 6174 | 4354 \n\ |
| 4355 If only @var{m} is supplied and it is a scalar, the dimension of the\n\ | |
| 4356 result is @var{m}-by-@var{m}. If @var{m} is a vector, then the\n\ | |
| 4357 dimensions of the result are given by the elements of @var{m}.\n\ | |
| 4358 If both @var{m} and @var{n} are scalars, then the dimensions of\n\ | |
| 4359 the result are @var{m}-by-@var{n}.\n\ | |
| 4360 @seealso{reshape}\n\ | |
| 5731 | 4361 @end deftypefn") |
| 4362 { | |
| 4363 octave_value retval; | |
| 4364 int nargin = args.length (); | |
| 4365 | |
| 4366 if (nargin == 2) | |
| 4367 { | |
| 4368 Array<double> vec = args(1).vector_value (); | |
| 4369 int ndim = vec.length (); | |
| 4370 if (ndim == 1) | |
| 4371 { | |
| 4372 octave_idx_type m = static_cast<octave_idx_type> (vec(0)); | |
| 4373 retval = args(0); | |
| 4374 retval = retval.resize (dim_vector (m, m), true); | |
| 4375 } | |
| 4376 else | |
| 4377 { | |
| 4378 dim_vector dv; | |
| 4379 dv.resize (ndim); | |
| 4380 for (int i = 0; i < ndim; i++) | |
| 4381 dv(i) = static_cast<octave_idx_type> (vec(i)); | |
| 4382 retval = args(0); | |
| 4383 retval = retval.resize (dv, true); | |
| 4384 } | |
| 4385 } | |
| 4386 else if (nargin == 3) | |
| 4387 { | |
| 4388 octave_idx_type m = static_cast<octave_idx_type> | |
| 4389 (args(1).scalar_value()); | |
| 4390 octave_idx_type n = static_cast<octave_idx_type> | |
| 4391 (args(2).scalar_value()); | |
| 4392 if (!error_state) | |
| 4393 { | |
| 4394 retval = args(0); | |
| 4395 retval = retval.resize (dim_vector (m, n), true); | |
| 4396 } | |
| 4397 } | |
| 4398 else | |
| 5823 | 4399 print_usage (); |
| 5731 | 4400 return retval; |
| 4401 } | |
| 4402 | |
| 5775 | 4403 // FIXME -- should use octave_idx_type for dimensions. |
| 5734 | 4404 |
| 4567 | 4405 DEFUN (reshape, args, , |
| 4406 "-*- texinfo -*-\n\ | |
| 6671 | 4407 @deftypefn {Built-in Function} {} reshape (@var{a}, @var{m}, @var{n}, @dots{})\n\ |
| 4408 @deftypefnx {Built-in Function} {} reshape (@var{a}, @var{siz})\n\ | |
| 4567 | 4409 Return a matrix with the given dimensions whose elements are taken\n\ |
| 6671 | 4410 from the matrix @var{a}. The elements of the matrix are accessed in\n\ |
| 4567 | 4411 column-major order (like Fortran arrays are stored).\n\ |
| 4412 \n\ | |
| 4413 For example,\n\ | |
| 4414 \n\ | |
| 4415 @example\n\ | |
| 4416 @group\n\ | |
| 4417 reshape ([1, 2, 3, 4], 2, 2)\n\ | |
| 4418 @result{} 1 3\n\ | |
| 4419 2 4\n\ | |
| 4420 @end group\n\ | |
| 4421 @end example\n\ | |
| 4422 \n\ | |
| 4423 @noindent\n\ | |
| 4424 Note that the total number of elements in the original\n\ | |
| 4425 matrix must match the total number of elements in the new matrix.\n\ | |
| 5013 | 4426 \n\ |
| 4427 A single dimension of the return matrix can be unknown and is flagged\n\ | |
| 4428 by an empty argument.\n\ | |
| 4567 | 4429 @end deftypefn") |
| 4430 { | |
| 4431 octave_value retval; | |
| 4432 | |
| 4433 int nargin = args.length (); | |
| 4434 | |
| 4435 Array<int> new_size; | |
| 4436 | |
| 4437 if (nargin == 2) | |
| 4438 new_size = args(1).int_vector_value (); | |
| 4439 else if (nargin > 2) | |
| 4440 { | |
| 4441 new_size.resize (nargin-1); | |
| 5013 | 4442 int empty_dim = -1; |
| 4443 | |
| 4567 | 4444 for (int i = 1; i < nargin; i++) |
| 4445 { | |
| 5013 | 4446 if (args(i).is_empty ()) |
| 4447 if (empty_dim > 0) | |
| 4448 { | |
| 4449 error ("reshape: only a single dimension can be unknown"); | |
| 4450 break; | |
| 4451 } | |
| 4452 else | |
| 4453 { | |
| 4454 empty_dim = i; | |
| 4455 new_size(i-1) = 1; | |
| 4456 } | |
| 4457 else | |
| 4458 { | |
| 6133 | 4459 new_size(i-1) = args(i).idx_type_value (); |
| 4567 | 4460 |
| 5013 | 4461 if (error_state) |
| 4462 break; | |
| 4463 } | |
| 4464 } | |
| 4465 | |
| 4466 if (! error_state && (empty_dim > 0)) | |
| 4467 { | |
| 4468 int nel = 1; | |
| 4469 for (int i = 0; i < nargin - 1; i++) | |
| 4470 nel *= new_size(i); | |
| 4471 | |
| 4472 if (nel == 0) | |
| 4473 new_size(empty_dim-1) = 0; | |
| 4474 else | |
| 4475 { | |
| 4476 int size_empty_dim = args(0).numel () / nel; | |
| 4477 | |
| 4478 if (args(0).numel () != size_empty_dim * nel) | |
| 4479 error ("reshape: size is not divisble by the product of known dimensions (= %d)", nel); | |
| 4480 else | |
| 4481 new_size(empty_dim-1) = size_empty_dim; | |
| 4482 } | |
| 4567 | 4483 } |
| 4484 } | |
| 4485 else | |
| 4486 { | |
| 5823 | 4487 print_usage (); |
| 4567 | 4488 return retval; |
| 4489 } | |
| 4490 | |
| 4491 if (error_state) | |
| 4492 { | |
| 4493 error ("reshape: invalid arguments"); | |
| 4494 return retval; | |
| 4495 } | |
| 4496 | |
| 4739 | 4497 // Remove trailing singletons in new_size, but leave at least 2 |
| 4498 // elements. | |
| 4499 | |
| 4567 | 4500 int n = new_size.length (); |
| 4501 | |
| 4739 | 4502 while (n > 2) |
| 4503 { | |
| 4504 if (new_size(n-1) == 1) | |
| 4505 n--; | |
| 4506 else | |
| 4507 break; | |
| 4508 } | |
| 4509 | |
| 4510 new_size.resize (n); | |
| 4511 | |
| 4567 | 4512 if (n < 2) |
| 4513 { | |
| 4514 error ("reshape: expecting size to be vector with at least 2 elements"); | |
| 4515 return retval; | |
| 4516 } | |
| 4517 | |
| 4518 dim_vector new_dims; | |
| 4519 | |
| 4520 new_dims.resize (n); | |
| 4521 | |
| 5275 | 4522 for (octave_idx_type i = 0; i < n; i++) |
| 4567 | 4523 new_dims(i) = new_size(i); |
| 4524 | |
| 4525 octave_value arg = args(0); | |
| 4526 | |
| 4527 if (new_dims.numel () == arg.numel ()) | |
| 4528 retval = (new_dims == arg.dims ()) ? arg : arg.reshape (new_dims); | |
| 4529 else | |
| 4530 error ("reshape: size mismatch"); | |
| 4531 | |
| 4532 return retval; | |
| 4533 } | |
| 4534 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4535 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4536 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4537 %!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
|
4538 %!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
|
4539 %!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
|
4540 %!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
|
4541 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4542 %!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
|
4543 %!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
|
4544 %!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
|
4545 %!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
|
4546 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4547 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4548 %! 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
|
4549 %! 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
|
4550 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4551 %!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
|
4552 %!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
|
4553 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4554 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4555 |
| 4532 | 4556 DEFUN (squeeze, args, , |
| 4557 "-*- texinfo -*-\n\ | |
| 4558 @deftypefn {Built-in Function} {} squeeze (@var{x})\n\ | |
| 4559 Remove singleton dimensions from @var{x} and return the result.\n\ | |
| 6999 | 4560 Note that for compatibility with @sc{Matlab}, all objects have\n\ |
| 7007 | 4561 a minimum of two dimensions and row vectors are left unchanged.\n\ |
| 4532 | 4562 @end deftypefn") |
| 4563 { | |
| 4564 octave_value retval; | |
| 4565 | |
| 4566 if (args.length () == 1) | |
| 4545 | 4567 retval = args(0).squeeze (); |
| 4532 | 4568 else |
| 5823 | 4569 print_usage (); |
| 4532 | 4570 |
| 4571 return retval; | |
| 4572 } | |
| 4573 | |
| 6945 | 4574 // Compute various norms of the vector X. |
| 4575 | |
| 6953 | 4576 DEFUN (norm, args, , |
| 6508 | 4577 "-*- texinfo -*-\n\ |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4578 @deftypefn {Function File} {} norm (@var{a}, @var{p}, @var{opt})\n\ |
| 6953 | 4579 Compute the p-norm of the matrix @var{a}. If the second argument is\n\ |
| 4580 missing, @code{p = 2} is assumed.\n\ | |
| 4581 \n\ | |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4582 If @var{a} is a matrix (or sparse matrix):\n\ |
| 6953 | 4583 \n\ |
| 4584 @table @asis\n\ | |
| 4585 @item @var{p} = @code{1}\n\ | |
| 4586 1-norm, the largest column sum of the absolute values of @var{a}.\n\ | |
| 4587 \n\ | |
| 4588 @item @var{p} = @code{2}\n\ | |
| 4589 Largest singular value of @var{a}.\n\ | |
| 4590 \n\ | |
| 7189 | 4591 @item @var{p} = @code{Inf} or @code{\"inf\"}\n\ |
| 6953 | 4592 @cindex infinity norm\n\ |
| 4593 Infinity norm, the largest row sum of the absolute values of @var{a}.\n\ | |
| 4594 \n\ | |
| 4595 @item @var{p} = @code{\"fro\"}\n\ | |
| 4596 @cindex Frobenius norm\n\ | |
| 4597 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
|
4598 \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4599 @item other @var{p}, @code{@var{p} > 1}\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4600 @cindex general p-norm \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4601 maximum @code{norm (A*x, p)} such that @code{norm (x, p) == 1}\n\ |
| 6953 | 4602 @end table\n\ |
| 4603 \n\ | |
| 4604 If @var{a} is a vector or a scalar:\n\ | |
| 4605 \n\ | |
| 4606 @table @asis\n\ | |
| 7189 | 4607 @item @var{p} = @code{Inf} or @code{\"inf\"}\n\ |
| 6953 | 4608 @code{max (abs (@var{a}))}.\n\ |
| 4609 \n\ | |
| 4610 @item @var{p} = @code{-Inf}\n\ | |
| 4611 @code{min (abs (@var{a}))}.\n\ | |
| 4612 \n\ | |
| 7189 | 4613 @item @var{p} = @code{\"fro\"}\n\ |
| 4614 Frobenius norm of @var{a}, @code{sqrt (sumsq (abs (a)))}.\n\ | |
| 4615 \n\ | |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4616 @item @var{p} = 0\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4617 Hamming norm - the number of nonzero elements.\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4618 \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4619 @item other @var{p}, @code{@var{p} > 1}\n\ |
| 6953 | 4620 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
|
4621 \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4622 @item other @var{p} @code{@var{p} < 1}\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4623 the p-pseudonorm defined as above.\n\ |
| 6953 | 4624 @end table\n\ |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4625 \n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4626 If @code{\"rows\"} is given as @var{opt}, the norms of all rows of the matrix @var{a} are\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4627 returned as a column vector. Similarly, if @code{\"columns\"} or @code{\"cols\"} is passed\n\ |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4628 column norms are computed.\n\ |
| 6953 | 4629 @seealso{cond, svd}\n\ |
| 6508 | 4630 @end deftypefn") |
| 4631 { | |
| 6953 | 4632 octave_value_list retval; |
| 6508 | 4633 |
| 4634 int nargin = args.length (); | |
| 4635 | |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4636 if (nargin >= 1 && nargin <= 3) |
| 6508 | 4637 { |
| 6953 | 4638 octave_value x_arg = args(0); |
| 4639 | |
| 4640 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
|
4641 { |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4642 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
|
4643 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
|
4644 else |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4645 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
|
4646 } |
| 6953 | 4647 else if (x_arg.ndims () == 2) |
| 6508 | 4648 { |
|
8303
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4649 enum { sfmatrix, sfcols, sfrows, sffrob, sfinf } strflag = sfmatrix; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4650 if (nargin > 1 && args(nargin-1).is_string ()) |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4651 { |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4652 std::string str = args(nargin-1).string_value (); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4653 if (str == "cols" || str == "columns") |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4654 strflag = sfcols; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4655 else if (str == "rows") |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4656 strflag = sfrows; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4657 else if (str == "fro") |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4658 strflag = sffrob; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4659 else if (str == "inf") |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4660 strflag = sfinf; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4661 else |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4662 error ("norm: unrecognized option: %s", str.c_str ()); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4663 // 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
|
4664 nargin --; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4665 } |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4666 else if (nargin > 1 && ! args(1).is_scalar_type ()) |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4667 gripe_wrong_type_arg ("norm", args(1), true); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4668 |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4669 if (! error_state) |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4670 { |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4671 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
|
4672 switch (strflag) |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4673 { |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4674 case sfmatrix: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4675 retval(0) = xnorm (x_arg, p_arg); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4676 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4677 case sfcols: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4678 retval(0) = xcolnorms (x_arg, p_arg); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4679 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4680 case sfrows: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4681 retval(0) = xrownorms (x_arg, p_arg); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4682 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4683 case sffrob: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4684 retval(0) = xfrobnorm (x_arg); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4685 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4686 case sfinf: |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4687 retval(0) = xnorm (x_arg, octave_Inf); |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4688 break; |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4689 } |
|
b11c31849b44
improve norm computation capabilities
Jaroslav Hajek <highegg@gmail.com>
parents:
8286
diff
changeset
|
4690 } |
| 6508 | 4691 } |
| 4692 else | |
| 6953 | 4693 error ("norm: only valid for 2-D objects"); |
| 6508 | 4694 } |
| 4695 else | |
| 4696 print_usage (); | |
| 4697 | |
| 4698 return retval; | |
| 4699 } | |
| 4700 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4701 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4702 %!shared x |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4703 %! 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
|
4704 %!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
|
4705 %!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
|
4706 %!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
|
4707 %!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
|
4708 %!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
|
4709 %!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
|
4710 %!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
|
4711 %!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
|
4712 %!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
|
4713 %!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
|
4714 %!shared m |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4715 %! 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
|
4716 %!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
|
4717 %!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
|
4718 %!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
|
4719 %!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
|
4720 %!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
|
4721 %! 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
|
4722 %! 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
|
4723 %! 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
|
4724 %!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
|
4725 %!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
|
4726 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4727 %!shared x |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4728 %! 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
|
4729 %!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
|
4730 %!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
|
4731 %!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
|
4732 %!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
|
4733 %!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
|
4734 %!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
|
4735 %!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
|
4736 %!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
|
4737 %!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
|
4738 %!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
|
4739 %!shared m |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4740 %! 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
|
4741 %!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
|
4742 %!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
|
4743 %!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
|
4744 %!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
|
4745 %!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
|
4746 %! 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
|
4747 %! 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
|
4748 %! 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
|
4749 %!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
|
4750 %!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
|
4751 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4752 |
| 6518 | 4753 #define UNARY_OP_DEFUN_BODY(F) \ |
| 4754 \ | |
| 4755 octave_value retval; \ | |
| 4756 \ | |
| 4757 if (args.length () == 1) \ | |
| 4758 retval = F (args(0)); \ | |
| 4759 else \ | |
| 4760 print_usage (); \ | |
| 4761 \ | |
| 4762 return retval | |
| 4763 | |
| 4764 DEFUN (not, args, , | |
| 4765 "-*- texinfo -*-\n\ | |
| 4766 @deftypefn {Built-in Function} {} not (@var{x})\n\ | |
| 4767 This function is equivalent to @code{! x}.\n\ | |
| 4768 @end deftypefn") | |
| 4769 { | |
| 4770 UNARY_OP_DEFUN_BODY (op_not); | |
| 4771 } | |
| 4772 | |
| 4773 DEFUN (uplus, args, , | |
| 4774 "-*- texinfo -*-\n\ | |
| 4775 @deftypefn {Built-in Function} {} uplus (@var{x})\n\ | |
| 4776 This function is equivalent to @code{+ x}.\n\ | |
| 4777 @end deftypefn") | |
| 4778 { | |
| 4779 UNARY_OP_DEFUN_BODY (op_uplus); | |
| 4780 } | |
| 4781 | |
| 4782 DEFUN (uminus, args, , | |
| 4783 "-*- texinfo -*-\n\ | |
| 4784 @deftypefn {Built-in Function} {} uminus (@var{x})\n\ | |
| 4785 This function is equivalent to @code{- x}.\n\ | |
| 4786 @end deftypefn") | |
| 4787 { | |
| 4788 UNARY_OP_DEFUN_BODY (op_uminus); | |
| 4789 } | |
| 4790 | |
| 4791 DEFUN (transpose, args, , | |
| 4792 "-*- texinfo -*-\n\ | |
| 4793 @deftypefn {Built-in Function} {} transpose (@var{x})\n\ | |
| 4794 This function is equivalent to @code{x.'}.\n\ | |
| 4795 @end deftypefn") | |
| 4796 { | |
| 4797 UNARY_OP_DEFUN_BODY (op_transpose); | |
| 4798 } | |
| 4799 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4800 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4801 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4802 %!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
|
4803 %!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
|
4804 %!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
|
4805 %!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
|
4806 %!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
|
4807 %!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
|
4808 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4809 %!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
|
4810 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4811 %!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
|
4812 %!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
|
4813 %!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
|
4814 %!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
|
4815 %!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
|
4816 %!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
|
4817 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4818 %!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
|
4819 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4820 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4821 |
| 6518 | 4822 DEFUN (ctranspose, args, , |
| 4823 "-*- texinfo -*-\n\ | |
| 4824 @deftypefn {Built-in Function} {} ctranspose (@var{x})\n\ | |
| 4825 This function is equivalent to @code{x'}.\n\ | |
| 4826 @end deftypefn") | |
| 4827 { | |
| 4828 UNARY_OP_DEFUN_BODY (op_hermitian); | |
| 4829 } | |
| 4830 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4831 /* |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4832 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4833 %!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
|
4834 %!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
|
4835 %!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
|
4836 %!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
|
4837 %!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
|
4838 %!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
|
4839 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4840 %!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
|
4841 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4842 %!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
|
4843 %!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
|
4844 %!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
|
4845 %!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
|
4846 %!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
|
4847 %!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
|
4848 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4849 %!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
|
4850 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4851 */ |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
4852 |
| 6518 | 4853 #define BINARY_OP_DEFUN_BODY(F) \ |
| 4854 \ | |
| 4855 octave_value retval; \ | |
| 4856 \ | |
| 4857 if (args.length () == 2) \ | |
| 4858 retval = F (args(0), args(1)); \ | |
| 4859 else \ | |
| 4860 print_usage (); \ | |
| 4861 \ | |
| 4862 return retval | |
| 4863 | |
| 4864 DEFUN (plus, args, , | |
| 4865 "-*- texinfo -*-\n\ | |
| 4866 @deftypefn {Built-in Function} {} plus (@var{x}, @var{y})\n\ | |
| 4867 This function is equivalent to @code{x + y}.\n\ | |
| 4868 @end deftypefn") | |
| 4869 { | |
| 4870 BINARY_OP_DEFUN_BODY (op_add); | |
| 4871 } | |
| 4872 | |
| 4873 DEFUN (minus, args, , | |
| 4874 "-*- texinfo -*-\n\ | |
| 4875 @deftypefn {Built-in Function} {} minus (@var{x}, @var{y})\n\ | |
| 4876 This function is equivalent to @code{x - y}.\n\ | |
| 4877 @end deftypefn") | |
| 4878 { | |
| 4879 BINARY_OP_DEFUN_BODY (op_sub); | |
| 4880 } | |
| 4881 | |
| 4882 DEFUN (mtimes, args, , | |
| 4883 "-*- texinfo -*-\n\ | |
| 4884 @deftypefn {Built-in Function} {} mtimes (@var{x}, @var{y})\n\ | |
| 4885 This function is equivalent to @code{x * y}.\n\ | |
| 4886 @end deftypefn") | |
| 4887 { | |
| 4888 BINARY_OP_DEFUN_BODY (op_mul); | |
| 4889 } | |
| 4890 | |
| 4891 DEFUN (mrdivide, args, , | |
| 4892 "-*- texinfo -*-\n\ | |
| 4893 @deftypefn {Built-in Function} {} mrdivide (@var{x}, @var{y})\n\ | |
| 4894 This function is equivalent to @code{x / y}.\n\ | |
| 4895 @end deftypefn") | |
| 4896 { | |
| 4897 BINARY_OP_DEFUN_BODY (op_div); | |
| 4898 } | |
| 4899 | |
| 4900 DEFUN (mpower, args, , | |
| 4901 "-*- texinfo -*-\n\ | |
| 4902 @deftypefn {Built-in Function} {} mpower (@var{x}, @var{y})\n\ | |
| 4903 This function is equivalent to @code{x ^ y}.\n\ | |
| 4904 @end deftypefn") | |
| 4905 { | |
| 4906 BINARY_OP_DEFUN_BODY (op_pow); | |
| 4907 } | |
| 4908 | |
| 4909 DEFUN (mldivide, args, , | |
| 4910 "-*- texinfo -*-\n\ | |
| 4911 @deftypefn {Built-in Function} {} mldivide (@var{x}, @var{y})\n\ | |
| 4912 This function is equivalent to @code{x \\ y}.\n\ | |
| 4913 @end deftypefn") | |
| 4914 { | |
| 4915 BINARY_OP_DEFUN_BODY (op_ldiv); | |
| 4916 } | |
| 4917 | |
| 4918 DEFUN (lt, args, , | |
| 4919 "-*- texinfo -*-\n\ | |
| 4920 @deftypefn {Built-in Function} {} lt (@var{x}, @var{y})\n\ | |
| 4921 This function is equivalent to @code{x < y}.\n\ | |
| 4922 @end deftypefn") | |
| 4923 { | |
| 4924 BINARY_OP_DEFUN_BODY (op_lt); | |
| 4925 } | |
| 4926 | |
| 4927 DEFUN (le, args, , | |
| 4928 "-*- texinfo -*-\n\ | |
| 4929 @deftypefn {Built-in Function} {} le (@var{x}, @var{y})\n\ | |
| 4930 This function is equivalent to @code{x <= y}.\n\ | |
| 4931 @end deftypefn") | |
| 4932 { | |
| 4933 BINARY_OP_DEFUN_BODY (op_le); | |
| 4934 } | |
| 4935 | |
| 4936 DEFUN (eq, args, , | |
| 4937 "-*- texinfo -*-\n\ | |
| 4938 @deftypefn {Built-in Function} {} eq (@var{x}, @var{y})\n\ | |
| 4939 This function is equivalent to @code{x == y}.\n\ | |
| 4940 @end deftypefn") | |
| 4941 { | |
| 4942 BINARY_OP_DEFUN_BODY (op_eq); | |
| 4943 } | |
| 4944 | |
| 4945 DEFUN (ge, args, , | |
| 4946 "-*- texinfo -*-\n\ | |
| 4947 @deftypefn {Built-in Function} {} ge (@var{x}, @var{y})\n\ | |
| 4948 This function is equivalent to @code{x >= y}.\n\ | |
| 4949 @end deftypefn") | |
| 4950 { | |
| 4951 BINARY_OP_DEFUN_BODY (op_ge); | |
| 4952 } | |
| 4953 | |
| 4954 DEFUN (gt, args, , | |
| 4955 "-*- texinfo -*-\n\ | |
| 4956 @deftypefn {Built-in Function} {} gt (@var{x}, @var{y})\n\ | |
| 4957 This function is equivalent to @code{x > y}.\n\ | |
| 4958 @end deftypefn") | |
| 4959 { | |
| 4960 BINARY_OP_DEFUN_BODY (op_gt); | |
| 4961 } | |
| 4962 | |
| 4963 DEFUN (ne, args, , | |
| 4964 "-*- texinfo -*-\n\ | |
| 4965 @deftypefn {Built-in Function} {} ne (@var{x}, @var{y})\n\ | |
| 4966 This function is equivalent to @code{x != y}.\n\ | |
| 4967 @end deftypefn") | |
| 4968 { | |
| 4969 BINARY_OP_DEFUN_BODY (op_ne); | |
| 4970 } | |
| 4971 | |
| 4972 DEFUN (times, args, , | |
| 4973 "-*- texinfo -*-\n\ | |
| 4974 @deftypefn {Built-in Function} {} times (@var{x}, @var{y})\n\ | |
| 4975 This function is equivalent to @code{x .* y}.\n\ | |
| 4976 @end deftypefn") | |
| 4977 { | |
| 4978 BINARY_OP_DEFUN_BODY (op_el_mul); | |
| 4979 } | |
| 4980 | |
| 4981 DEFUN (rdivide, args, , | |
| 4982 "-*- texinfo -*-\n\ | |
| 4983 @deftypefn {Built-in Function} {} rdivide (@var{x}, @var{y})\n\ | |
| 4984 This function is equivalent to @code{x ./ y}.\n\ | |
| 4985 @end deftypefn") | |
| 4986 { | |
| 4987 BINARY_OP_DEFUN_BODY (op_el_div); | |
| 4988 } | |
| 4989 | |
| 4990 DEFUN (power, args, , | |
| 4991 "-*- texinfo -*-\n\ | |
| 4992 @deftypefn {Built-in Function} {} power (@var{x}, @var{y})\n\ | |
| 7623 | 4993 This function is equivalent to @code{x .^ y}.\n\ |
| 6518 | 4994 @end deftypefn") |
| 4995 { | |
| 4996 BINARY_OP_DEFUN_BODY (op_el_pow); | |
| 4997 } | |
| 4998 | |
| 4999 DEFUN (ldivide, args, , | |
| 5000 "-*- texinfo -*-\n\ | |
| 5001 @deftypefn {Built-in Function} {} ldivide (@var{x}, @var{y})\n\ | |
| 7623 | 5002 This function is equivalent to @code{x .\\ y}.\n\ |
| 6518 | 5003 @end deftypefn") |
| 5004 { | |
| 5005 BINARY_OP_DEFUN_BODY (op_el_ldiv); | |
| 5006 } | |
| 5007 | |
| 5008 DEFUN (and, args, , | |
| 5009 "-*- texinfo -*-\n\ | |
| 5010 @deftypefn {Built-in Function} {} and (@var{x}, @var{y})\n\ | |
| 5011 This function is equivalent to @code{x & y}.\n\ | |
| 5012 @end deftypefn") | |
| 5013 { | |
| 5014 BINARY_OP_DEFUN_BODY (op_el_and); | |
| 5015 } | |
| 5016 | |
| 5017 DEFUN (or, args, , | |
| 5018 "-*- texinfo -*-\n\ | |
| 5019 @deftypefn {Built-in Function} {} or (@var{x}, @var{y})\n\ | |
| 5020 This function is equivalent to @code{x | y}.\n\ | |
| 5021 @end deftypefn") | |
| 5022 { | |
| 5023 BINARY_OP_DEFUN_BODY (op_el_or); | |
| 5024 } | |
| 5025 | |
| 7065 | 5026 static double tic_toc_timestamp = -1.0; |
| 7045 | 5027 |
| 5028 DEFUN (tic, args, nargout, | |
| 5029 "-*- texinfo -*-\n\ | |
| 5030 @deftypefn {Built-in Function} {} tic ()\n\ | |
| 5031 @deftypefnx {Built-in Function} {} toc ()\n\ | |
| 5032 Set or check a wall-clock timer. Calling @code{tic} without an\n\ | |
| 5033 output argument sets the timer. Subsequent calls to @code{toc}\n\ | |
| 5034 return the number of seconds since the timer was set. For example,\n\ | |
| 5035 \n\ | |
| 5036 @example\n\ | |
| 5037 tic ();\n\ | |
| 5038 # many computations later...\n\ | |
| 5039 elapsed_time = toc ();\n\ | |
| 5040 @end example\n\ | |
| 5041 \n\ | |
| 5042 @noindent\n\ | |
| 5043 will set the variable @code{elapsed_time} to the number of seconds since\n\ | |
| 5044 the most recent call to the function @code{tic}.\n\ | |
| 5045 \n\ | |
| 5046 If called with one output argument then this function returns a scalar\n\ | |
| 5047 of type @code{uint64} and the wall-clock timer is not started.\n\ | |
| 5048 \n\ | |
| 5049 @example\n\ | |
| 5050 @group\n\ | |
| 5051 t = tic; sleep (5); (double (tic ()) - double (t)) * 1e-6\n\ | |
| 5052 @result{} 5\n\ | |
| 5053 @end group\n\ | |
| 5054 @end example\n\ | |
| 5055 \n\ | |
| 5056 Nested timing with @code{tic} and @code{toc} is not supported.\n\ | |
| 5057 Therefore @code{toc} will always return the elapsed time from the most\n\ | |
| 5058 recent call to @code{tic}.\n\ | |
| 5059 \n\ | |
| 5060 If you are more interested in the CPU time that your process used, you\n\ | |
| 5061 should use the @code{cputime} function instead. The @code{tic} and\n\ | |
| 5062 @code{toc} functions report the actual wall clock time that elapsed\n\ | |
| 5063 between the calls. This may include time spent processing other jobs or\n\ | |
| 5064 doing nothing at all. For example,\n\ | |
| 5065 \n\ | |
| 5066 @example\n\ | |
| 5067 @group\n\ | |
| 5068 tic (); sleep (5); toc ()\n\ | |
| 5069 @result{} 5\n\ | |
| 5070 t = cputime (); sleep (5); cputime () - t\n\ | |
| 5071 @result{} 0\n\ | |
| 5072 @end group\n\ | |
| 5073 @end example\n\ | |
| 5074 \n\ | |
| 5075 @noindent\n\ | |
| 5076 (This example also illustrates that the CPU timer may have a fairly\n\ | |
| 5077 coarse resolution.)\n\ | |
| 5078 @end deftypefn") | |
| 5079 { | |
| 5080 octave_value retval; | |
| 7065 | 5081 |
| 7045 | 5082 int nargin = args.length (); |
| 5083 | |
| 5084 if (nargin != 0) | |
| 5085 warning ("tic: ignoring extra arguments"); | |
| 5086 | |
| 7065 | 5087 octave_time now; |
| 5088 | |
| 5089 double tmp = now.double_value (); | |
| 5090 | |
| 7045 | 5091 if (nargout > 0) |
| 7065 | 5092 retval = static_cast<octave_uint64> (1e6 * tmp); |
| 7045 | 5093 else |
| 7065 | 5094 tic_toc_timestamp = tmp; |
| 7045 | 5095 |
| 5096 return retval; | |
| 5097 } | |
| 5098 | |
| 5099 DEFUN (toc, args, nargout, | |
| 5100 "-*- texinfo -*-\n\ | |
| 5101 @deftypefn {Built-in Function} {} toc ()\n\ | |
| 5102 See tic.\n\ | |
| 5103 @end deftypefn") | |
| 5104 { | |
| 5105 octave_value retval; | |
| 7065 | 5106 |
| 7045 | 5107 int nargin = args.length (); |
| 5108 | |
| 5109 if (nargin != 0) | |
| 5110 warning ("tic: ignoring extra arguments"); | |
| 5111 | |
| 7065 | 5112 if (tic_toc_timestamp < 0) |
| 7045 | 5113 { |
| 5114 warning ("toc called before timer set"); | |
| 5115 if (nargout > 0) | |
| 7065 | 5116 retval = Matrix (); |
| 7045 | 5117 } |
| 5118 else | |
| 7065 | 5119 { |
| 5120 octave_time now; | |
| 5121 | |
| 5122 double tmp = now.double_value () - tic_toc_timestamp; | |
| 5123 | |
| 5124 if (nargout > 0) | |
| 5125 retval = tmp; | |
| 5126 else | |
| 5127 octave_stdout << "Elapsed time is " << tmp << " seconds.\n"; | |
| 5128 } | |
| 7045 | 5129 |
| 5130 return retval; | |
| 5131 } | |
| 5132 | |
| 5133 DEFUN (cputime, args, , | |
| 5134 "-*- texinfo -*-\n\ | |
| 5135 @deftypefn {Built-in Function} {[@var{total}, @var{user}, @var{system}] =} cputime ();\n\ | |
| 5136 Return the CPU time used by your Octave session. The first output is\n\ | |
| 5137 the total time spent executing your process and is equal to the sum of\n\ | |
| 5138 second and third outputs, which are the number of CPU seconds spent\n\ | |
| 5139 executing in user mode and the number of CPU seconds spent executing in\n\ | |
| 5140 system mode, respectively. If your system does not have a way to report\n\ | |
| 5141 CPU time usage, @code{cputime} returns 0 for each of its output values.\n\ | |
| 5142 Note that because Octave used some CPU time to start, it is reasonable\n\ | |
| 5143 to check to see if @code{cputime} works by checking to see if the total\n\ | |
| 5144 CPU time used is nonzero.\n\ | |
| 5145 @end deftypefn") | |
| 5146 { | |
| 5147 octave_value_list retval; | |
| 5148 int nargin = args.length (); | |
| 5149 double usr = 0.0; | |
| 5150 double sys = 0.0; | |
| 5151 | |
| 5152 if (nargin != 0) | |
| 5153 warning ("tic: ignoring extra arguments"); | |
| 5154 | |
| 5155 #if defined (HAVE_GETRUSAGE) | |
| 5156 | |
| 5157 struct rusage ru; | |
| 5158 | |
| 5159 getrusage (RUSAGE_SELF, &ru); | |
| 5160 | |
| 5161 usr = static_cast<double> (ru.ru_utime.tv_sec) + | |
| 5162 static_cast<double> (ru.ru_utime.tv_usec) * 1e-6; | |
| 5163 | |
| 5164 sys = static_cast<double> (ru.ru_stime.tv_sec) + | |
| 5165 static_cast<double> (ru.ru_stime.tv_usec) * 1e-6; | |
| 5166 | |
| 5167 #elif defined (HAVE_TIMES) && defined (HAVE_SYS_TIMES_H) | |
| 5168 | |
| 5169 struct tms t; | |
| 5170 | |
| 5171 times (&t); | |
| 5172 | |
| 5173 unsigned long ticks; | |
| 5174 unsigned long seconds; | |
| 5175 unsigned long fraction; | |
| 5176 | |
| 5177 ticks = t.tms_utime + t.tms_cutime; | |
| 5178 fraction = ticks % HZ; | |
| 5179 seconds = ticks / HZ; | |
| 5180 | |
| 5181 usr = static_cast<double> (seconds) + static_cast<double>(fraction) / | |
| 5182 static_cast<double>(HZ); | |
| 5183 | |
| 5184 ticks = t.tms_stime + t.tms_cstime; | |
| 5185 fraction = ticks % HZ; | |
| 5186 seconds = ticks / HZ; | |
| 5187 | |
| 5188 sys = static_cast<double> (seconds) + static_cast<double>(fraction) / | |
| 5189 static_cast<double>(HZ); | |
| 5190 | |
| 5191 #elif defined (__WIN32__) | |
| 7145 | 5192 |
| 7045 | 5193 HANDLE hProcess = GetCurrentProcess (); |
| 5194 FILETIME ftCreation, ftExit, ftUser, ftKernel; | |
| 5195 GetProcessTimes (hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser); | |
| 5196 | |
| 5197 int64_t itmp = *(reinterpret_cast<int64_t *> (&ftUser)); | |
| 7145 | 5198 usr = static_cast<double> (itmp) * 1e-7; |
| 7045 | 5199 |
| 5200 itmp = *(reinterpret_cast<int64_t *> (&ftKernel)); | |
| 7145 | 5201 sys = static_cast<double> (itmp) * 1e-7; |
| 7045 | 5202 |
| 5203 #endif | |
| 5204 | |
| 5205 retval (2) = sys; | |
| 5206 retval (1) = usr; | |
| 5207 retval (0) = sys + usr; | |
| 5208 | |
| 5209 return retval; | |
| 5210 } | |
| 5211 | |
| 7433 | 5212 DEFUN (sort, args, nargout, |
| 5213 "-*- texinfo -*-\n\ | |
| 5214 @deftypefn {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x})\n\ | |
| 5215 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{dim})\n\ | |
| 5216 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{mode})\n\ | |
| 5217 @deftypefnx {Loadable Function} {[@var{s}, @var{i}] =} sort (@var{x}, @var{dim}, @var{mode})\n\ | |
| 5218 Return a copy of @var{x} with the elements arranged in increasing\n\ | |
| 5219 order. For matrices, @code{sort} orders the elements in each column.\n\ | |
| 5220 \n\ | |
| 5221 For example,\n\ | |
| 5222 \n\ | |
| 5223 @example\n\ | |
| 5224 @group\n\ | |
| 5225 sort ([1, 2; 2, 3; 3, 1])\n\ | |
| 5226 @result{} 1 1\n\ | |
| 5227 2 2\n\ | |
| 5228 3 3\n\ | |
| 5229 @end group\n\ | |
| 5230 @end example\n\ | |
| 5231 \n\ | |
| 5232 The @code{sort} function may also be used to produce a matrix\n\ | |
| 5233 containing the original row indices of the elements in the sorted\n\ | |
| 5234 matrix. For example,\n\ | |
| 5235 \n\ | |
| 5236 @example\n\ | |
| 5237 @group\n\ | |
| 5238 [s, i] = sort ([1, 2; 2, 3; 3, 1])\n\ | |
| 5239 @result{} s = 1 1\n\ | |
| 5240 2 2\n\ | |
| 5241 3 3\n\ | |
| 5242 @result{} i = 1 3\n\ | |
| 5243 2 1\n\ | |
| 5244 3 2\n\ | |
| 5245 @end group\n\ | |
| 5246 @end example\n\ | |
| 5247 \n\ | |
| 5248 If the optional argument @var{dim} is given, then the matrix is sorted\n\ | |
| 5249 along the dimension defined by @var{dim}. The optional argument @code{mode}\n\ | |
| 5250 defines the order in which the values will be sorted. Valid values of\n\ | |
| 5251 @code{mode} are `ascend' or `descend'.\n\ | |
| 5252 \n\ | |
| 5253 For equal elements, the indices are such that the equal elements are listed\n\ | |
| 5254 in the order that appeared in the original list.\n\ | |
| 5255 \n\ | |
| 5256 The @code{sort} function may also be used to sort strings and cell arrays\n\ | |
| 5257 of strings, in which case the dictionary order of the strings is used.\n\ | |
| 5258 \n\ | |
| 5259 The algorithm used in @code{sort} is optimized for the sorting of partially\n\ | |
| 5260 ordered lists.\n\ | |
| 5261 @end deftypefn") | |
| 5262 { | |
| 5263 octave_value_list retval; | |
| 5264 | |
| 5265 int nargin = args.length (); | |
| 5266 sortmode smode = ASCENDING; | |
| 5267 | |
| 5268 if (nargin < 1 || nargin > 3) | |
| 5269 { | |
| 5270 print_usage (); | |
| 5271 return retval; | |
| 5272 } | |
| 5273 | |
| 5274 bool return_idx = nargout > 1; | |
| 5275 | |
| 5276 octave_value arg = args(0); | |
| 5277 | |
| 5278 int dim = 0; | |
| 5279 if (nargin > 1) | |
| 5280 { | |
| 5281 if (args(1).is_string ()) | |
| 5282 { | |
| 5283 std::string mode = args(1).string_value(); | |
| 5284 if (mode == "ascend") | |
| 5285 smode = ASCENDING; | |
| 5286 else if (mode == "descend") | |
| 5287 smode = DESCENDING; | |
| 5288 else | |
| 5289 { | |
| 5290 error ("sort: mode must be either \"ascend\" or \"descend\""); | |
| 5291 return retval; | |
| 5292 } | |
| 5293 } | |
| 5294 else | |
| 5295 dim = args(1).nint_value () - 1; | |
| 5296 } | |
| 5297 | |
| 5298 if (nargin > 2) | |
| 5299 { | |
| 5300 if (args(1).is_string ()) | |
| 5301 { | |
| 5302 print_usage (); | |
| 5303 return retval; | |
| 5304 } | |
| 5305 | |
| 5306 if (! args(2).is_string ()) | |
| 5307 { | |
| 5308 error ("sort: mode must be a string"); | |
| 5309 return retval; | |
| 5310 } | |
| 5311 std::string mode = args(2).string_value(); | |
| 5312 if (mode == "ascend") | |
| 5313 smode = ASCENDING; | |
| 5314 else if (mode == "descend") | |
| 5315 smode = DESCENDING; | |
| 5316 else | |
| 5317 { | |
| 5318 error ("sort: mode must be either \"ascend\" or \"descend\""); | |
| 5319 return retval; | |
| 5320 } | |
| 5321 } | |
| 5322 | |
| 5323 dim_vector dv = arg.dims (); | |
| 5324 if (error_state) | |
| 5325 { | |
| 5326 gripe_wrong_type_arg ("sort", arg); | |
| 5327 return retval; | |
| 5328 } | |
| 5329 if (nargin == 1 || args(1).is_string ()) | |
| 5330 { | |
| 5331 // Find first non singleton dimension | |
| 5332 for (int i = 0; i < dv.length (); i++) | |
| 5333 if (dv(i) > 1) | |
| 5334 { | |
| 5335 dim = i; | |
| 5336 break; | |
| 5337 } | |
| 5338 } | |
| 5339 else | |
| 5340 { | |
| 5341 if (dim < 0 || dim > dv.length () - 1) | |
| 5342 { | |
| 5343 error ("sort: dim must be a valid dimension"); | |
| 5344 return retval; | |
| 5345 } | |
| 5346 } | |
| 5347 | |
| 5348 if (return_idx) | |
| 5349 { | |
| 5350 Array<octave_idx_type> sidx; | |
| 5351 | |
| 5352 retval (0) = arg.sort (sidx, dim, smode); | |
|
7919
9d080df0c843
new NDArray constructor for ArrayN<octave_idx_type>
David Bateman <dbateman@free.fr>
parents:
7914
diff
changeset
|
5353 retval (1) = NDArray (sidx, true); |
| 7433 | 5354 } |
| 5355 else | |
| 5356 retval(0) = arg.sort (dim, smode); | |
| 5357 | |
| 5358 return retval; | |
| 5359 } | |
| 5360 | |
| 5361 /* | |
| 5362 | |
| 5363 %% Double | |
| 5364 %!assert (sort ([NaN, 1, -1, 2, Inf]), [-1, 1, 2, Inf, NaN]) | |
| 5365 %!assert (sort ([NaN, 1, -1, 2, Inf], 1), [NaN, 1, -1, 2, Inf]) | |
| 5366 %!assert (sort ([NaN, 1, -1, 2, Inf], 2), [-1, 1, 2, Inf, NaN]) | |
| 5367 %!error (sort ([NaN, 1, -1, 2, Inf], 3)) | |
| 5368 %!assert (sort ([NaN, 1, -1, 2, Inf], "ascend"), [-1, 1, 2, Inf, NaN]) | |
| 5369 %!assert (sort ([NaN, 1, -1, 2, Inf], 2, "ascend"), [-1, 1, 2, Inf, NaN]) | |
| 5370 %!assert (sort ([NaN, 1, -1, 2, Inf], "descend"), [NaN, Inf, 2, 1, -1]) | |
| 5371 %!assert (sort ([NaN, 1, -1, 2, Inf], 2, "descend"), [NaN, Inf, 2, 1, -1]) | |
| 5372 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4]), [3, 1, 6, 4; 8, 2, 7, 5]) | |
| 5373 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4], 1), [3, 1, 6, 4; 8, 2, 7, 5]) | |
| 5374 %!assert (sort ([3, 1, 7, 5; 8, 2, 6, 4], 2), [1, 3, 5, 7; 2, 4, 6, 8]) | |
| 5375 %!assert (sort (1), 1) | |
| 5376 | |
| 5377 %!test | |
| 5378 %! [v, i] = sort ([NaN, 1, -1, Inf, 1]); | |
| 5379 %! assert (v, [-1, 1, 1, Inf, NaN]) | |
| 5380 %! assert (i, [3, 2, 5, 4, 1]) | |
| 5381 | |
| 5382 %% Complex | |
| 5383 %!assert (sort ([NaN, 1i, -1, 2, Inf]), [1i, -1, 2, Inf, NaN]) | |
| 5384 %!assert (sort ([NaN, 1i, -1, 2, Inf], 1), [NaN, 1i, -1, 2, Inf]) | |
| 5385 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2), [1i, -1, 2, Inf, NaN]) | |
| 5386 %!error (sort ([NaN, 1i, -1, 2, Inf], 3)) | |
| 5387 %!assert (sort ([NaN, 1i, -1, 2, Inf], "ascend"), [1i, -1, 2, Inf, NaN]) | |
| 5388 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2, "ascend"), [1i, -1, 2, Inf, NaN]) | |
| 5389 %!assert (sort ([NaN, 1i, -1, 2, Inf], "descend"), [NaN, Inf, 2, -1, 1i]) | |
| 5390 %!assert (sort ([NaN, 1i, -1, 2, Inf], 2, "descend"), [NaN, Inf, 2, -1, 1i]) | |
| 5391 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4]), [3, 1i, 6, 4; 8, 2, 7, 5]) | |
| 5392 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4], 1), [3, 1i, 6, 4; 8, 2, 7, 5]) | |
| 5393 %!assert (sort ([3, 1i, 7, 5; 8, 2, 6, 4], 2), [1i, 3, 5, 7; 2, 4, 6, 8]) | |
| 5394 %!assert (sort (1i), 1i) | |
| 5395 | |
| 5396 %!test | |
| 5397 %! [v, i] = sort ([NaN, 1i, -1, Inf, 1, 1i]); | |
| 5398 %! assert (v, [1, 1i, 1i, -1, Inf, NaN]) | |
| 5399 %! assert (i, [5, 2, 6, 3, 4, 1]) | |
| 5400 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5401 %% Single |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5402 %!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
|
5403 %!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
|
5404 %!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
|
5405 %!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
|
5406 %!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
|
5407 %!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
|
5408 %!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
|
5409 %!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
|
5410 %!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
|
5411 %!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
|
5412 %!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
|
5413 %!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
|
5414 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5415 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5416 %! [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
|
5417 %! 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
|
5418 %! 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
|
5419 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5420 %% Single Complex |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5421 %!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
|
5422 %!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
|
5423 %!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
|
5424 %!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
|
5425 %!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
|
5426 %!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
|
5427 %!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
|
5428 %!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
|
5429 %!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
|
5430 %!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
|
5431 %!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
|
5432 %!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
|
5433 |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5434 %!test |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5435 %! [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
|
5436 %! 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
|
5437 %! 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
|
5438 |
| 7433 | 5439 %% Bool |
| 5440 %!assert (sort ([true, false, true, false]), [false, false, true, true]) | |
| 5441 %!assert (sort ([true, false, true, false], 1), [true, false, true, false]) | |
| 5442 %!assert (sort ([true, false, true, false], 2), [false, false, true, true]) | |
| 5443 %!error (sort ([true, false, true, false], 3)) | |
| 5444 %!assert (sort ([true, false, true, false], "ascend"), [false, false, true, true]) | |
| 5445 %!assert (sort ([true, false, true, false], 2, "ascend"), [false, false, true, true]) | |
| 5446 %!assert (sort ([true, false, true, false], "descend"), [true, true, false, false]) | |
| 5447 %!assert (sort ([true, false, true, false], 2, "descend"), [true, true, false, false]) | |
| 5448 %!assert (sort (true), true) | |
| 5449 | |
| 5450 %!test | |
| 5451 %! [v, i] = sort ([true, false, true, false]); | |
| 5452 %! assert (v, [false, false, true, true]) | |
| 5453 %! assert (i, [2, 4, 1, 3]) | |
| 5454 | |
| 5455 %% Sparse Double | |
| 5456 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf])), sparse ([-1, 0, 0, 1, 2, Inf, NaN])) | |
| 5457 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 1), sparse ([0, NaN, 1, 0, -1, 2, Inf])) | |
| 5458 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2), sparse ([-1, 0, 0, 1, 2, Inf, NaN])) | |
| 5459 %!error (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 3)) | |
| 5460 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), "ascend"), sparse ([-1, 0, 0, 1, 2, Inf, NaN])) | |
| 5461 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2, "ascend"), sparse ([-1, 0, 0, 1, 2, Inf, NaN])) | |
| 5462 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), "descend"), sparse ([NaN, Inf, 2, 1, 0, 0, -1])) | |
| 5463 %!assert (sort (sparse ([0, NaN, 1, 0, -1, 2, Inf]), 2, "descend"), sparse ([NaN, Inf, 2, 1, 0, 0, -1])) | |
| 5464 | |
| 5465 %!shared a | |
| 5466 %! a = randn (10, 10); | |
| 5467 %! a (a < 0) = 0; | |
| 5468 %!assert (sort (sparse (a)), sparse (sort (a))) | |
| 5469 %!assert (sort (sparse (a), 1), sparse (sort (a, 1))) | |
| 5470 %!assert (sort (sparse (a), 2), sparse (sort (a, 2))) | |
| 5471 %!test | |
| 5472 %! [v, i] = sort (a); | |
| 5473 %! [vs, is] = sort (sparse (a)); | |
| 5474 %! assert (vs, sparse (v)) | |
| 5475 %! assert (is, i) | |
| 5476 | |
| 5477 %% Sparse Complex | |
| 5478 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf])), sparse ([0, 0, 1i, -1, 2, Inf, NaN])) | |
| 5479 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 1), sparse ([0, NaN, 1i, 0, -1, 2, Inf])) | |
| 5480 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2), sparse ([0, 0, 1i, -1, 2, Inf, NaN])) | |
| 5481 %!error (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 3)) | |
| 5482 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), "ascend"), sparse ([0, 0, 1i, -1, 2, Inf, NaN])) | |
| 5483 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2, "ascend"), sparse ([0, 0, 1i, -1, 2, Inf, NaN])) | |
| 5484 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), "descend"), sparse ([NaN, Inf, 2, -1, 1i, 0, 0])) | |
| 5485 %!assert (sort (sparse ([0, NaN, 1i, 0, -1, 2, Inf]), 2, "descend"), sparse ([NaN, Inf, 2, -1, 1i, 0, 0])) | |
| 5486 | |
| 5487 %!shared a | |
| 5488 %! a = randn (10, 10); | |
| 5489 %! a (a < 0) = 0; | |
| 5490 %! a = 1i * a; | |
| 5491 %!assert (sort (sparse (a)), sparse (sort (a))) | |
| 5492 %!assert (sort (sparse (a), 1), sparse (sort (a, 1))) | |
| 5493 %!assert (sort (sparse (a), 2), sparse (sort (a, 2))) | |
| 5494 %!test | |
| 5495 %! [v, i] = sort (a); | |
| 5496 %! [vs, is] = sort (sparse (a)); | |
| 5497 %! assert (vs, sparse (v)) | |
| 5498 %! assert (is, i) | |
| 5499 | |
| 5500 %% Sparse Bool | |
| 5501 %!assert (sort (sparse ([true, false, true, false])), sparse ([false, false, true, true])) | |
| 5502 %!assert (sort (sparse([true, false, true, false]), 1), sparse ([true, false, true, false])) | |
| 5503 %!assert (sort (sparse ([true, false, true, false]), 2), sparse ([false, false, true, true])) | |
| 5504 %!error (sort (sparse ([true, false, true, false], 3))) | |
| 5505 %!assert (sort (sparse ([true, false, true, false]), "ascend"), sparse([false, false, true, true])) | |
| 5506 %!assert (sort (sparse ([true, false, true, false]), 2, "ascend"), sparse([false, false, true, true])) | |
| 5507 %!assert (sort (sparse ([true, false, true, false]), "descend"), sparse ([true, true, false, false])) | |
| 5508 %!assert (sort (sparse ([true, false, true, false]), 2, "descend"), sparse([true, true, false, false])) | |
| 5509 | |
| 5510 %!test | |
| 5511 %! [v, i] = sort (sparse([true, false, true, false])); | |
| 5512 %! assert (v, sparse([false, false, true, true])) | |
| 5513 %! assert (i, [2, 4, 1, 3]) | |
| 5514 | |
| 5515 %% Cell string array | |
| 5516 %!shared a, b, c | |
| 5517 %! a = {"Alice", "Cecile", "Eric", "Barry", "David"}; | |
| 5518 %! b = {"Alice", "Barry", "Cecile", "David", "Eric"}; | |
| 5519 %! c = {"Eric", "David", "Cecile", "Barry", "Alice"}; | |
| 5520 %!assert (sort (a), b); | |
| 5521 %!assert (sort (a, 1), a) | |
| 5522 %!assert (sort (a, 2), b) | |
| 5523 %!error (sort (a, 3)) | |
| 5524 %!assert (sort (a, "ascend"), b) | |
| 5525 %!assert (sort (a, 2, "ascend"), b) | |
| 5526 %!assert (sort (a, "descend"), c) | |
| 5527 %!assert (sort (a, 2, "descend"), c) | |
| 5528 | |
| 5529 %!test | |
| 5530 %! [v, i] = sort (a); | |
| 5531 %! assert (i, [1, 4, 2, 5, 3]) | |
| 5532 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7795
diff
changeset
|
5533 %!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
|
5534 %!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
|
5535 |
| 7433 | 5536 */ |
| 5537 | |
| 523 | 5538 /* |
| 5539 ;;; Local Variables: *** | |
| 5540 ;;; mode: C++ *** | |
| 5541 ;;; End: *** | |
| 5542 */ |