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