Mercurial > octave-nkf
annotate src/ov-cx-sparse.cc @ 9812:f80c566bc751
improve unary mapper system
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Thu, 12 Nov 2009 15:47:58 +0100 |
| parents | c6edba80dfae |
| children | 8fa32b527d9a |
| rev | line source |
|---|---|
| 5164 | 1 /* |
| 2 | |
| 8920 | 3 Copyright (C) 2004, 2005, 2006, 2007, 2008 David Bateman |
| 7016 | 4 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 Andy Adler |
| 5 | |
| 6 This file is part of Octave. | |
| 5164 | 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. | |
| 5164 | 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/>. | |
| 5164 | 21 |
| 22 */ | |
| 23 | |
| 24 #ifdef HAVE_CONFIG_H | |
| 25 #include <config.h> | |
| 26 #endif | |
| 27 | |
| 28 #include <climits> | |
| 29 | |
| 30 #include <iostream> | |
| 31 #include <vector> | |
| 32 | |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
33 #include "lo-specfun.h" |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
34 #include "lo-mappers.h" |
|
8377
25bc2d31e1bf
improve OCTAVE_LOCAL_BUFFER
Jaroslav Hajek <highegg@gmail.com>
parents:
7740
diff
changeset
|
35 #include "oct-locbuf.h" |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
36 |
| 5164 | 37 #include "ov-base.h" |
| 38 #include "ov-scalar.h" | |
| 39 #include "ov-complex.h" | |
| 40 #include "gripes.h" | |
| 41 | |
| 42 #include "ov-re-sparse.h" | |
| 43 #include "ov-cx-sparse.h" | |
| 44 | |
| 45 #include "ov-base-sparse.h" | |
| 46 #include "ov-base-sparse.cc" | |
| 47 | |
| 48 #include "ov-bool-sparse.h" | |
| 49 | |
| 6109 | 50 template class OCTINTERP_API octave_base_sparse<SparseComplexMatrix>; |
| 5164 | 51 |
| 52 DEFINE_OCTAVE_ALLOCATOR (octave_sparse_complex_matrix); | |
| 53 | |
| 6823 | 54 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_sparse_complex_matrix, "sparse complex matrix", "double"); |
| 5164 | 55 |
| 5759 | 56 octave_base_value * |
| 5164 | 57 octave_sparse_complex_matrix::try_narrowing_conversion (void) |
| 58 { | |
| 5759 | 59 octave_base_value *retval = 0; |
| 5164 | 60 |
| 7193 | 61 if (Vsparse_auto_mutate) |
| 62 { | |
| 63 int nr = matrix.rows (); | |
| 64 int nc = matrix.cols (); | |
| 5164 | 65 |
| 7193 | 66 // Don't use numel, since it can overflow for very large matrices |
| 67 // Note that for the tests on matrix size, they become approximative | |
| 68 // since they involves a cast to double to avoid issues of overflow | |
| 69 if (matrix.rows () == 1 && matrix.cols () == 1) | |
| 70 { | |
| 71 // Const copy of the matrix, so the right version of () operator used | |
| 72 const SparseComplexMatrix tmp (matrix); | |
| 5164 | 73 |
| 7193 | 74 Complex c = tmp (0, 0); |
| 5164 | 75 |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
76 if (std::imag (c) == 0.0) |
| 7193 | 77 retval = new octave_scalar (std::real (c)); |
| 78 else | |
| 79 retval = new octave_complex (c); | |
| 80 } | |
| 81 else if (nr == 0 || nc == 0) | |
| 82 retval = new octave_matrix (Matrix (nr, nc)); | |
| 83 else if (matrix.all_elements_are_real ()) | |
|
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
84 if (matrix.cols () > 0 && matrix.rows () > 0 |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
85 && (double (matrix.byte_size ()) > double (matrix.rows ()) |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
86 * double (matrix.cols ()) * sizeof (double))) |
| 7193 | 87 retval = new octave_matrix (::real (matrix.matrix_value ())); |
| 88 else | |
| 89 retval = new octave_sparse_matrix (::real (matrix)); | |
|
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
90 else if (matrix.cols () > 0 && matrix.rows () > 0 |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
91 && (double (matrix.byte_size ()) > double (matrix.rows ()) |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
92 * double (matrix.cols ()) * sizeof (Complex))) |
| 7193 | 93 retval = new octave_complex_matrix (matrix.matrix_value ()); |
| 5164 | 94 } |
| 7193 | 95 else |
| 96 { | |
| 97 if (matrix.all_elements_are_real ()) | |
| 98 retval = new octave_sparse_matrix (::real (matrix)); | |
| 99 } | |
| 5164 | 100 |
| 101 return retval; | |
| 102 } | |
| 103 | |
| 104 void | |
| 105 octave_sparse_complex_matrix::assign (const octave_value_list& idx, | |
| 106 const SparseComplexMatrix& rhs) | |
| 107 { | |
| 108 octave_base_sparse<SparseComplexMatrix>::assign (idx, rhs); | |
| 109 } | |
| 110 | |
| 111 void | |
| 112 octave_sparse_complex_matrix::assign (const octave_value_list& idx, | |
| 113 const SparseMatrix& rhs) | |
| 114 { | |
| 115 int len = idx.length (); | |
| 116 | |
| 117 for (int i = 0; i < len; i++) | |
| 118 matrix.set_index (idx(i).index_vector ()); | |
| 119 | |
| 120 ::assign (matrix, rhs); | |
| 121 } | |
| 122 | |
| 123 double | |
| 124 octave_sparse_complex_matrix::double_value (bool force_conversion) const | |
| 125 { | |
| 126 double retval = lo_ieee_nan_value (); | |
| 127 | |
| 5781 | 128 if (! force_conversion) |
| 129 gripe_implicit_conversion ("Octave:imag-to-real", | |
| 130 "complex sparse matrix", "real scalar"); | |
| 5164 | 131 |
| 5775 | 132 // FIXME -- maybe this should be a function, valid_as_scalar() |
| 5164 | 133 if (numel () > 0) |
| 134 { | |
| 6221 | 135 if (numel () > 1) |
| 136 gripe_implicit_conversion ("Octave:array-as-scalar", | |
| 137 "complex sparse matrix", "real scalar"); | |
| 5164 | 138 |
| 139 retval = std::real (matrix (0, 0)); | |
| 140 } | |
| 141 else | |
| 142 gripe_invalid_conversion ("complex sparse matrix", "real scalar"); | |
| 143 | |
| 144 return retval; | |
| 145 } | |
| 146 | |
| 147 Matrix | |
| 148 octave_sparse_complex_matrix::matrix_value (bool force_conversion) const | |
| 149 { | |
| 150 Matrix retval; | |
| 151 | |
| 5781 | 152 if (! force_conversion) |
| 153 gripe_implicit_conversion ("Octave:imag-to-real", | |
| 154 "complex sparse matrix", "real matrix"); | |
| 5164 | 155 |
| 156 retval = ::real (matrix.matrix_value ()); | |
| 157 | |
| 158 return retval; | |
| 159 } | |
| 160 | |
| 161 Complex | |
| 162 octave_sparse_complex_matrix::complex_value (bool) const | |
| 163 { | |
| 164 double tmp = lo_ieee_nan_value (); | |
| 165 | |
| 166 Complex retval (tmp, tmp); | |
| 167 | |
| 5775 | 168 // FIXME -- maybe this should be a function, valid_as_scalar() |
| 5164 | 169 if (numel () > 0) |
| 170 { | |
| 6221 | 171 if (numel () > 1) |
| 172 gripe_implicit_conversion ("Octave:array-as-scalar", | |
| 173 "complex sparse matrix", "real scalar"); | |
| 5164 | 174 |
| 175 retval = matrix (0, 0); | |
| 176 } | |
| 177 else | |
| 178 gripe_invalid_conversion ("complex sparse matrix", "real scalar"); | |
| 179 | |
| 180 return retval; | |
| 181 } | |
| 182 | |
| 183 ComplexMatrix | |
| 184 octave_sparse_complex_matrix::complex_matrix_value (bool) const | |
| 185 { | |
| 186 return matrix.matrix_value (); | |
| 187 } | |
| 188 | |
| 189 ComplexNDArray | |
| 190 octave_sparse_complex_matrix::complex_array_value (bool) const | |
| 191 { | |
| 192 return ComplexNDArray (matrix.matrix_value ()); | |
| 193 } | |
| 194 | |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
195 charNDArray |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
196 octave_sparse_complex_matrix::char_array_value (bool frc_str_conv) const |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
197 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
198 charNDArray retval; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
199 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
200 if (! frc_str_conv) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
201 gripe_implicit_conversion ("Octave:num-to-str", |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
202 "sparse complex matrix", "string"); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
203 else |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
204 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
205 retval = charNDArray (dims (), 0); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
206 octave_idx_type nc = matrix.cols (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
207 octave_idx_type nr = matrix.rows (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
208 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
209 for (octave_idx_type j = 0; j < nc; j++) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
210 for (octave_idx_type i = matrix.cidx(j); i < matrix.cidx(j+1); i++) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
211 retval(matrix.ridx(i) + nr * j) = |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
212 static_cast<char>(std::real (matrix.data (i))); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
213 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
214 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
215 return retval; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
216 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
217 |
| 5164 | 218 SparseMatrix |
| 219 octave_sparse_complex_matrix::sparse_matrix_value (bool force_conversion) const | |
| 220 { | |
| 221 SparseMatrix retval; | |
| 222 | |
| 5781 | 223 if (! force_conversion) |
| 224 gripe_implicit_conversion ("Octave:imag-to-real", | |
| 225 "complex sparse matrix", | |
| 5164 | 226 "real sparse matrix"); |
| 227 | |
| 228 retval = ::real (matrix); | |
| 229 | |
| 230 return retval; | |
| 231 } | |
| 232 | |
| 233 bool | |
| 234 octave_sparse_complex_matrix::save_binary (std::ostream& os, | |
| 235 bool&save_as_floats) | |
| 236 { | |
| 237 dim_vector d = this->dims (); | |
| 238 if (d.length() < 1) | |
| 239 return false; | |
| 240 | |
| 241 // Ensure that additional memory is deallocated | |
| 242 matrix.maybe_compress (); | |
| 243 | |
| 244 int nr = d(0); | |
| 245 int nc = d(1); | |
| 5604 | 246 int nz = nzmax (); |
| 5164 | 247 |
| 5828 | 248 int32_t itmp; |
| 5164 | 249 // Use negative value for ndims to be consistent with other formats |
| 250 itmp= -2; | |
| 5760 | 251 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 252 |
| 253 itmp= nr; | |
| 5760 | 254 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 255 |
| 256 itmp= nc; | |
| 5760 | 257 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 258 |
| 259 itmp= nz; | |
| 5760 | 260 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 261 |
| 262 save_type st = LS_DOUBLE; | |
| 263 if (save_as_floats) | |
| 264 { | |
| 265 if (matrix.too_large_for_float ()) | |
| 266 { | |
| 267 warning ("save: some values too large to save as floats --"); | |
| 268 warning ("save: saving as doubles instead"); | |
| 269 } | |
| 270 else | |
| 271 st = LS_FLOAT; | |
| 272 } | |
| 5775 | 273 else if (matrix.nzmax () > 8192) // FIXME -- make this configurable. |
| 5164 | 274 { |
| 275 double max_val, min_val; | |
| 276 if (matrix.all_integers (max_val, min_val)) | |
| 277 st = get_save_type (max_val, min_val); | |
| 278 } | |
| 279 | |
| 280 // add one to the printed indices to go from | |
| 281 // zero-based to one-based arrays | |
| 282 for (int i = 0; i < nc+1; i++) | |
| 283 { | |
| 284 OCTAVE_QUIT; | |
| 285 itmp = matrix.cidx(i); | |
| 5760 | 286 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 287 } |
| 288 | |
| 289 for (int i = 0; i < nz; i++) | |
| 290 { | |
| 291 OCTAVE_QUIT; | |
| 292 itmp = matrix.ridx(i); | |
| 5760 | 293 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 294 } |
| 295 | |
| 5760 | 296 write_doubles (os, reinterpret_cast<const double *> (matrix.data()), st, 2 * nz); |
| 5164 | 297 |
| 298 return true; | |
| 299 } | |
| 300 | |
| 301 bool | |
| 302 octave_sparse_complex_matrix::load_binary (std::istream& is, bool swap, | |
| 303 oct_mach_info::float_format fmt) | |
| 304 { | |
| 5828 | 305 int32_t nz, nc, nr, tmp; |
| 5327 | 306 char ctmp; |
| 307 | |
| 5760 | 308 if (! is.read (reinterpret_cast<char *> (&tmp), 4)) |
| 5164 | 309 return false; |
| 310 | |
| 311 if (swap) | |
| 312 swap_bytes<4> (&tmp); | |
| 313 | |
| 314 if (tmp != -2) { | |
|
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
315 error ("load: only 2D sparse matrices are supported"); |
| 5164 | 316 return false; |
| 317 } | |
| 318 | |
| 5760 | 319 if (! is.read (reinterpret_cast<char *> (&nr), 4)) |
| 5164 | 320 return false; |
| 5760 | 321 if (! is.read (reinterpret_cast<char *> (&nc), 4)) |
| 5164 | 322 return false; |
| 5760 | 323 if (! is.read (reinterpret_cast<char *> (&nz), 4)) |
| 5164 | 324 return false; |
| 325 | |
| 326 if (swap) | |
| 327 { | |
| 328 swap_bytes<4> (&nr); | |
| 329 swap_bytes<4> (&nc); | |
| 330 swap_bytes<4> (&nz); | |
| 331 } | |
| 332 | |
| 5275 | 333 SparseComplexMatrix m (static_cast<octave_idx_type> (nr), |
| 334 static_cast<octave_idx_type> (nc), | |
| 335 static_cast<octave_idx_type> (nz)); | |
| 5164 | 336 |
| 337 for (int i = 0; i < nc+1; i++) | |
| 338 { | |
| 339 OCTAVE_QUIT; | |
| 5760 | 340 if (! is.read (reinterpret_cast<char *> (&tmp), 4)) |
| 5164 | 341 return false; |
| 342 if (swap) | |
| 343 swap_bytes<4> (&tmp); | |
| 344 m.cidx(i) = tmp; | |
| 345 } | |
| 346 | |
| 347 for (int i = 0; i < nz; i++) | |
| 348 { | |
| 349 OCTAVE_QUIT; | |
| 5760 | 350 if (! is.read (reinterpret_cast<char *> (&tmp), 4)) |
| 5164 | 351 return false; |
| 352 if (swap) | |
| 353 swap_bytes<4> (&tmp); | |
| 354 m.ridx(i) = tmp; | |
| 355 } | |
| 356 | |
| 5760 | 357 if (! is.read (reinterpret_cast<char *> (&ctmp), 1)) |
| 5164 | 358 return false; |
| 359 | |
| 5760 | 360 read_doubles (is, reinterpret_cast<double *> (m.data ()), |
| 361 static_cast<save_type> (ctmp), 2 * nz, swap, fmt); | |
| 5164 | 362 |
| 363 if (error_state || ! is) | |
| 364 return false; | |
|
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
365 |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
366 if (! m.indices_ok ()) |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
367 return false; |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
368 |
| 5164 | 369 matrix = m; |
| 370 | |
| 371 return true; | |
| 372 } | |
| 373 | |
| 374 #if defined (HAVE_HDF5) | |
| 5900 | 375 |
| 5164 | 376 bool |
| 377 octave_sparse_complex_matrix::save_hdf5 (hid_t loc_id, const char *name, | |
| 378 bool save_as_floats) | |
| 379 { | |
| 380 dim_vector dv = dims (); | |
| 381 int empty = save_hdf5_empty (loc_id, name, dv); | |
| 382 if (empty) | |
| 383 return (empty > 0); | |
| 384 | |
| 385 // Ensure that additional memory is deallocated | |
| 386 matrix.maybe_compress (); | |
| 387 | |
| 388 hid_t group_hid = H5Gcreate (loc_id, name, 0); | |
| 389 if (group_hid < 0) | |
| 390 return false; | |
| 391 | |
| 392 hid_t space_hid = -1, data_hid = -1; | |
| 393 bool retval = true; | |
| 394 SparseComplexMatrix m = sparse_complex_matrix_value (); | |
| 5351 | 395 octave_idx_type tmp; |
| 5164 | 396 hsize_t hdims[2]; |
| 397 | |
| 5760 | 398 space_hid = H5Screate_simple (0, hdims, 0); |
| 5164 | 399 if (space_hid < 0) |
| 400 { | |
| 401 H5Gclose (group_hid); | |
| 402 return false; | |
| 403 } | |
| 404 | |
| 5351 | 405 data_hid = H5Dcreate (group_hid, "nr", H5T_NATIVE_IDX, space_hid, |
| 5164 | 406 H5P_DEFAULT); |
| 407 if (data_hid < 0) | |
| 408 { | |
| 409 H5Sclose (space_hid); | |
| 410 H5Gclose (group_hid); | |
| 411 return false; | |
| 412 } | |
| 413 | |
| 414 tmp = m.rows (); | |
| 5351 | 415 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 416 H5P_DEFAULT, &tmp) >= 0; |
| 5164 | 417 H5Dclose (data_hid); |
| 418 if (!retval) | |
| 419 { | |
| 420 H5Sclose (space_hid); | |
| 421 H5Gclose (group_hid); | |
| 422 return false; | |
| 423 } | |
| 424 | |
| 5351 | 425 data_hid = H5Dcreate (group_hid, "nc", H5T_NATIVE_IDX, space_hid, |
| 5164 | 426 H5P_DEFAULT); |
| 427 if (data_hid < 0) | |
| 428 { | |
| 429 H5Sclose (space_hid); | |
| 430 H5Gclose (group_hid); | |
| 431 return false; | |
| 432 } | |
| 433 | |
| 434 tmp = m.cols (); | |
| 5351 | 435 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 436 H5P_DEFAULT, &tmp) >= 0; |
| 5164 | 437 H5Dclose (data_hid); |
| 438 if (!retval) | |
| 439 { | |
| 440 H5Sclose (space_hid); | |
| 441 H5Gclose (group_hid); | |
| 442 return false; | |
| 443 } | |
| 444 | |
| 5351 | 445 data_hid = H5Dcreate (group_hid, "nz", H5T_NATIVE_IDX, space_hid, |
| 5164 | 446 H5P_DEFAULT); |
| 447 if (data_hid < 0) | |
| 448 { | |
| 449 H5Sclose (space_hid); | |
| 450 H5Gclose (group_hid); | |
| 451 return false; | |
| 452 } | |
| 453 | |
| 5604 | 454 tmp = m.nzmax (); |
| 5351 | 455 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 456 H5P_DEFAULT, &tmp) >= 0; |
| 5164 | 457 H5Dclose (data_hid); |
| 458 if (!retval) | |
| 459 { | |
| 460 H5Sclose (space_hid); | |
| 461 H5Gclose (group_hid); | |
| 462 return false; | |
| 463 } | |
| 464 | |
| 465 H5Sclose (space_hid); | |
| 466 | |
| 467 hdims[0] = m.cols() + 1; | |
| 468 hdims[1] = 1; | |
| 469 | |
| 470 space_hid = H5Screate_simple (2, hdims, 0); | |
| 471 | |
| 472 if (space_hid < 0) | |
| 473 { | |
| 474 H5Gclose (group_hid); | |
| 475 return false; | |
| 476 } | |
| 477 | |
| 5351 | 478 data_hid = H5Dcreate (group_hid, "cidx", H5T_NATIVE_IDX, space_hid, |
| 5164 | 479 H5P_DEFAULT); |
| 480 if (data_hid < 0) | |
| 481 { | |
| 482 H5Sclose (space_hid); | |
| 483 H5Gclose (group_hid); | |
| 484 return false; | |
| 485 } | |
| 486 | |
| 5351 | 487 octave_idx_type * itmp = m.xcidx (); |
| 488 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, | |
| 5760 | 489 H5P_DEFAULT, itmp) >= 0; |
| 5164 | 490 H5Dclose (data_hid); |
| 491 if (!retval) | |
| 492 { | |
| 493 H5Sclose (space_hid); | |
| 494 H5Gclose (group_hid); | |
| 495 return false; | |
| 496 } | |
| 497 | |
| 498 H5Sclose (space_hid); | |
| 499 | |
| 5604 | 500 hdims[0] = m.nzmax (); |
| 5164 | 501 hdims[1] = 1; |
| 502 | |
| 503 space_hid = H5Screate_simple (2, hdims, 0); | |
| 504 | |
| 505 if (space_hid < 0) | |
| 506 { | |
| 507 H5Gclose (group_hid); | |
| 508 return false; | |
| 509 } | |
| 510 | |
| 5351 | 511 data_hid = H5Dcreate (group_hid, "ridx", H5T_NATIVE_IDX, space_hid, |
| 5164 | 512 H5P_DEFAULT); |
| 513 if (data_hid < 0) | |
| 514 { | |
| 515 H5Sclose (space_hid); | |
| 516 H5Gclose (group_hid); | |
| 517 return false; | |
| 518 } | |
| 519 | |
| 520 itmp = m.xridx (); | |
| 5760 | 521 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, itmp) >= 0; |
| 5164 | 522 H5Dclose (data_hid); |
| 523 if (!retval) | |
| 524 { | |
| 525 H5Sclose (space_hid); | |
| 526 H5Gclose (group_hid); | |
| 527 return false; | |
| 528 } | |
| 529 | |
| 530 hid_t save_type_hid = H5T_NATIVE_DOUBLE; | |
| 531 | |
| 532 if (save_as_floats) | |
| 533 { | |
| 534 if (m.too_large_for_float ()) | |
| 535 { | |
| 536 warning ("save: some values too large to save as floats --"); | |
| 537 warning ("save: saving as doubles instead"); | |
| 538 } | |
| 539 else | |
| 540 save_type_hid = H5T_NATIVE_FLOAT; | |
| 541 } | |
| 542 #if HAVE_HDF5_INT2FLOAT_CONVERSIONS | |
| 543 // hdf5 currently doesn't support float/integer conversions | |
| 544 else | |
| 545 { | |
| 546 double max_val, min_val; | |
| 547 | |
| 548 if (m.all_integers (max_val, min_val)) | |
| 549 save_type_hid | |
| 550 = save_type_to_hdf5 (get_save_type (max_val, min_val)); | |
| 551 } | |
| 552 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */ | |
| 553 | |
| 554 hid_t type_hid = hdf5_make_complex_type (save_type_hid); | |
| 555 if (type_hid < 0) | |
| 556 { | |
| 557 H5Sclose (space_hid); | |
| 558 H5Gclose (group_hid); | |
| 559 return false; | |
| 560 } | |
| 561 | |
| 5760 | 562 data_hid = H5Dcreate (group_hid, "data", type_hid, space_hid, H5P_DEFAULT); |
| 5164 | 563 if (data_hid < 0) |
| 564 { | |
| 565 H5Sclose (space_hid); | |
| 566 H5Tclose (type_hid); | |
| 567 H5Gclose (group_hid); | |
| 568 return false; | |
| 569 } | |
| 570 | |
| 571 hid_t complex_type_hid = hdf5_make_complex_type (H5T_NATIVE_DOUBLE); | |
| 572 retval = false; | |
| 573 if (complex_type_hid >= 0) | |
| 574 { | |
| 575 Complex * ctmp = m.xdata (); | |
| 576 | |
| 577 retval = H5Dwrite (data_hid, complex_type_hid, H5S_ALL, H5S_ALL, | |
| 5760 | 578 H5P_DEFAULT, ctmp) >= 0; |
| 5164 | 579 } |
| 580 | |
| 581 H5Dclose (data_hid); | |
| 582 H5Sclose (space_hid); | |
| 583 H5Tclose (type_hid); | |
| 584 H5Gclose (group_hid); | |
| 585 | |
| 586 return retval; | |
| 587 } | |
| 588 | |
| 589 bool | |
| 590 octave_sparse_complex_matrix::load_hdf5 (hid_t loc_id, const char *name, | |
| 591 bool /* have_h5giterate_bug */) | |
| 592 { | |
| 5351 | 593 octave_idx_type nr, nc, nz; |
| 5164 | 594 hid_t group_hid, data_hid, space_hid; |
| 595 hsize_t rank; | |
| 596 | |
| 597 dim_vector dv; | |
| 598 int empty = load_hdf5_empty (loc_id, name, dv); | |
| 599 if (empty > 0) | |
| 600 matrix.resize(dv); | |
| 601 if (empty) | |
| 602 return (empty > 0); | |
| 603 | |
| 604 group_hid = H5Gopen (loc_id, name); | |
| 605 if (group_hid < 0 ) return false; | |
| 606 | |
| 607 data_hid = H5Dopen (group_hid, "nr"); | |
| 608 space_hid = H5Dget_space (data_hid); | |
| 609 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 610 | |
| 611 if (rank != 0) | |
| 612 { | |
| 613 H5Dclose (data_hid); | |
| 614 H5Gclose (group_hid); | |
| 615 return false; | |
| 616 } | |
| 617 | |
| 5760 | 618 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, &nr) < 0) |
| 5164 | 619 { |
| 620 H5Dclose (data_hid); | |
| 621 H5Gclose (group_hid); | |
| 622 return false; | |
| 623 } | |
| 624 | |
| 625 H5Dclose (data_hid); | |
| 626 | |
| 627 data_hid = H5Dopen (group_hid, "nc"); | |
| 628 space_hid = H5Dget_space (data_hid); | |
| 629 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 630 | |
| 631 if (rank != 0) | |
| 632 { | |
| 633 H5Dclose (data_hid); | |
| 634 H5Gclose (group_hid); | |
| 635 return false; | |
| 636 } | |
| 637 | |
| 5760 | 638 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, &nc) < 0) |
| 5164 | 639 { |
| 640 H5Dclose (data_hid); | |
| 641 H5Gclose (group_hid); | |
| 642 return false; | |
| 643 } | |
| 644 | |
| 645 H5Dclose (data_hid); | |
| 646 | |
| 647 data_hid = H5Dopen (group_hid, "nz"); | |
| 648 space_hid = H5Dget_space (data_hid); | |
| 649 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 650 | |
| 651 if (rank != 0) | |
| 652 { | |
| 653 H5Dclose (data_hid); | |
| 654 H5Gclose (group_hid); | |
| 655 return false; | |
| 656 } | |
| 657 | |
| 5760 | 658 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, &nz) < 0) |
| 5164 | 659 { |
| 660 H5Dclose (data_hid); | |
| 661 H5Gclose (group_hid); | |
| 662 return false; | |
| 663 } | |
| 664 | |
| 665 H5Dclose (data_hid); | |
| 666 | |
| 5275 | 667 SparseComplexMatrix m (static_cast<octave_idx_type> (nr), |
| 668 static_cast<octave_idx_type> (nc), | |
| 669 static_cast<octave_idx_type> (nz)); | |
| 5164 | 670 |
| 671 data_hid = H5Dopen (group_hid, "cidx"); | |
| 672 space_hid = H5Dget_space (data_hid); | |
| 673 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 674 | |
| 675 if (rank != 2) | |
| 676 { | |
| 677 H5Sclose (space_hid); | |
| 678 H5Dclose (data_hid); | |
| 679 H5Gclose (group_hid); | |
| 680 return false; | |
| 681 } | |
| 682 | |
| 683 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank); | |
| 684 OCTAVE_LOCAL_BUFFER (hsize_t, maxdims, rank); | |
| 685 | |
| 686 H5Sget_simple_extent_dims (space_hid, hdims, maxdims); | |
| 687 | |
|
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
688 if (static_cast<int> (hdims[0]) != nc + 1 |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
689 || static_cast<int> (hdims[1]) != 1) |
| 5164 | 690 { |
| 691 H5Sclose (space_hid); | |
| 692 H5Dclose (data_hid); | |
| 693 H5Gclose (group_hid); | |
| 694 return false; | |
| 695 } | |
| 696 | |
| 5351 | 697 octave_idx_type *itmp = m.xcidx (); |
| 5760 | 698 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, itmp) < 0) |
| 5164 | 699 { |
| 700 H5Sclose (space_hid); | |
| 701 H5Dclose (data_hid); | |
| 702 H5Gclose (group_hid); | |
| 703 return false; | |
| 704 } | |
| 705 | |
| 706 H5Sclose (space_hid); | |
| 707 H5Dclose (data_hid); | |
| 708 | |
| 709 data_hid = H5Dopen (group_hid, "ridx"); | |
| 710 space_hid = H5Dget_space (data_hid); | |
| 711 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 712 | |
| 713 if (rank != 2) | |
| 714 { | |
| 715 H5Sclose (space_hid); | |
| 716 H5Dclose (data_hid); | |
| 717 H5Gclose (group_hid); | |
| 718 return false; | |
| 719 } | |
| 720 | |
| 721 H5Sget_simple_extent_dims (space_hid, hdims, maxdims); | |
| 722 | |
|
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
723 if (static_cast<int> (hdims[0]) != nz |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
724 || static_cast<int> (hdims[1]) != 1) |
| 5164 | 725 { |
| 726 H5Sclose (space_hid); | |
| 727 H5Dclose (data_hid); | |
| 728 H5Gclose (group_hid); | |
| 729 return false; | |
| 730 } | |
| 731 | |
| 732 itmp = m.xridx (); | |
| 5760 | 733 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, itmp) < 0) |
| 5164 | 734 { |
| 735 H5Sclose (space_hid); | |
| 736 H5Dclose (data_hid); | |
| 737 H5Gclose (group_hid); | |
| 738 return false; | |
| 739 } | |
| 740 | |
| 741 H5Sclose (space_hid); | |
| 742 H5Dclose (data_hid); | |
| 743 | |
| 744 data_hid = H5Dopen (group_hid, "data"); | |
| 745 hid_t type_hid = H5Dget_type (data_hid); | |
| 746 | |
| 747 hid_t complex_type = hdf5_make_complex_type (H5T_NATIVE_DOUBLE); | |
| 748 | |
| 749 if (! hdf5_types_compatible (type_hid, complex_type)) | |
| 750 { | |
| 751 H5Tclose (complex_type); | |
| 752 H5Dclose (data_hid); | |
| 753 H5Gclose (group_hid); | |
| 754 return false; | |
| 755 } | |
| 756 | |
| 757 space_hid = H5Dget_space (data_hid); | |
| 758 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 759 | |
| 760 if (rank != 2) | |
| 761 { | |
| 762 H5Sclose (space_hid); | |
| 763 H5Dclose (data_hid); | |
| 764 H5Gclose (group_hid); | |
| 765 return false; | |
| 766 } | |
| 767 | |
| 768 H5Sget_simple_extent_dims (space_hid, hdims, maxdims); | |
| 769 | |
|
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
770 if (static_cast<int> (hdims[0]) != nz |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
771 || static_cast<int> (hdims[1]) != 1) |
| 5164 | 772 { |
| 773 H5Sclose (space_hid); | |
| 774 H5Dclose (data_hid); | |
| 775 H5Gclose (group_hid); | |
| 776 return false; | |
| 777 } | |
| 778 | |
| 779 Complex *ctmp = m.xdata (); | |
| 780 bool retval = false; | |
|
9469
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
781 if (H5Dread (data_hid, complex_type, H5S_ALL, H5S_ALL, |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
782 H5P_DEFAULT, ctmp) >= 0 |
|
c6edba80dfae
sanity checks for loading sparse matrices
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
783 && m.indices_ok ()) |
| 5164 | 784 { |
| 785 retval = true; | |
| 786 matrix = m; | |
| 787 } | |
| 788 | |
| 789 H5Tclose (complex_type); | |
| 790 H5Sclose (space_hid); | |
| 791 H5Dclose (data_hid); | |
| 792 H5Gclose (group_hid); | |
| 793 | |
| 794 return retval; | |
| 795 } | |
| 796 | |
| 797 #endif | |
| 798 | |
| 5900 | 799 mxArray * |
| 800 octave_sparse_complex_matrix::as_mxArray (void) const | |
| 801 { | |
| 6686 | 802 mwSize nz = nzmax (); |
| 5903 | 803 mxArray *retval = new mxArray (mxDOUBLE_CLASS, rows (), columns (), |
| 804 nz, mxCOMPLEX); | |
| 805 double *pr = static_cast<double *> (retval->get_data ()); | |
| 806 double *pi = static_cast<double *> (retval->get_imag_data ()); | |
| 6686 | 807 mwIndex *ir = retval->get_ir (); |
| 808 mwIndex *jc = retval->get_jc (); | |
| 5903 | 809 |
| 6686 | 810 for (mwIndex i = 0; i < nz; i++) |
| 5903 | 811 { |
| 812 Complex val = matrix.data(i); | |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
813 pr[i] = std::real (val); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
814 pi[i] = std::imag (val); |
| 5903 | 815 ir[i] = matrix.ridx(i); |
| 816 } | |
| 817 | |
| 6686 | 818 for (mwIndex i = 0; i < columns() + 1; i++) |
| 5903 | 819 jc[i] = matrix.cidx(i); |
| 820 | |
| 821 return retval; | |
| 5900 | 822 } |
| 823 | |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
824 octave_value |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
825 octave_sparse_complex_matrix::map (unary_mapper_t umap) const |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
826 { |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
827 switch (umap) |
|
7667
fb3a6c53c2b2
Allow negative zero imaginary part to be treated as zero for erf, erfc, gamma and lgamma mapper function
David Bateman <dbateman@free.fr>
parents:
7638
diff
changeset
|
828 { |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
829 // Mappers handled specially. |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
830 case umap_real: |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
831 return ::real (matrix); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
832 case umap_imag: |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
833 return ::imag (matrix); |
|
7667
fb3a6c53c2b2
Allow negative zero imaginary part to be treated as zero for erf, erfc, gamma and lgamma mapper function
David Bateman <dbateman@free.fr>
parents:
7638
diff
changeset
|
834 |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
835 #define ARRAY_METHOD_MAPPER(UMAP, FCN) \ |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
836 case umap_ ## UMAP: \ |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
837 return octave_value (matrix.FCN ()) |
|
7667
fb3a6c53c2b2
Allow negative zero imaginary part to be treated as zero for erf, erfc, gamma and lgamma mapper function
David Bateman <dbateman@free.fr>
parents:
7638
diff
changeset
|
838 |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
839 ARRAY_METHOD_MAPPER (abs, abs); |
|
7667
fb3a6c53c2b2
Allow negative zero imaginary part to be treated as zero for erf, erfc, gamma and lgamma mapper function
David Bateman <dbateman@free.fr>
parents:
7638
diff
changeset
|
840 |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
841 #define ARRAY_MAPPER(UMAP, TYPE, FCN) \ |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
842 case umap_ ## UMAP: \ |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
843 return octave_value (matrix.map<TYPE> (FCN)) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
844 |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
845 ARRAY_MAPPER (acos, Complex, ::acos); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
846 ARRAY_MAPPER (acosh, Complex, ::acosh); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
847 ARRAY_MAPPER (angle, double, std::arg); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
848 ARRAY_MAPPER (arg, double, std::arg); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
849 ARRAY_MAPPER (asin, Complex, ::asin); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
850 ARRAY_MAPPER (asinh, Complex, ::asinh); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
851 ARRAY_MAPPER (atan, Complex, ::atan); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
852 ARRAY_MAPPER (atanh, Complex, ::atanh); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
853 ARRAY_MAPPER (ceil, Complex, ::ceil); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
854 ARRAY_MAPPER (conj, Complex, std::conj); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
855 ARRAY_MAPPER (cos, Complex, std::cos); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
856 ARRAY_MAPPER (cosh, Complex, std::cosh); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
857 ARRAY_MAPPER (exp, Complex, std::exp); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
858 ARRAY_MAPPER (expm1, Complex, ::expm1); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
859 ARRAY_MAPPER (fix, Complex, ::fix); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
860 ARRAY_MAPPER (floor, Complex, ::floor); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
861 ARRAY_MAPPER (log, Complex, std::log); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
862 ARRAY_MAPPER (log2, Complex, xlog2); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
863 ARRAY_MAPPER (log10, Complex, std::log10); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
864 ARRAY_MAPPER (log1p, Complex, ::log1p); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
865 ARRAY_MAPPER (round, Complex, xround); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
866 ARRAY_MAPPER (roundb, Complex, xroundb); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
867 ARRAY_MAPPER (signum, Complex, ::signum); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
868 ARRAY_MAPPER (sin, Complex, std::sin); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
869 ARRAY_MAPPER (sinh, Complex, std::sinh); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
870 ARRAY_MAPPER (sqrt, Complex, std::sqrt); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
871 ARRAY_MAPPER (tan, Complex, std::tan); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
872 ARRAY_MAPPER (tanh, Complex, std::tanh); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
873 ARRAY_MAPPER (isnan, bool, xisnan); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
874 ARRAY_MAPPER (isna, bool, octave_is_NA); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
875 ARRAY_MAPPER (isinf, bool, xisinf); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
876 ARRAY_MAPPER (finite, bool, xfinite); |
|
7667
fb3a6c53c2b2
Allow negative zero imaginary part to be treated as zero for erf, erfc, gamma and lgamma mapper function
David Bateman <dbateman@free.fr>
parents:
7638
diff
changeset
|
877 |
|
9812
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
878 default: // Attempt to go via dense matrix. |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
879 return full_value ().map (umap).sparse_matrix_value (); |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
880 } |
|
f80c566bc751
improve unary mapper system
Jaroslav Hajek <highegg@gmail.com>
parents:
9469
diff
changeset
|
881 } |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
882 |
| 5164 | 883 /* |
| 884 ;;; Local Variables: *** | |
| 885 ;;; mode: C++ *** | |
| 886 ;;; End: *** | |
| 887 */ |