Mercurial > octave-nkf
annotate src/ov-cx-sparse.cc @ 8874:bd1b1fe9c6e9 ss-3-1-53
bump version info for snapshot
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Wed, 25 Feb 2009 18:35:47 -0500 |
| parents | f00578b495e9 |
| children | eb63fbe60fab |
| rev | line source |
|---|---|
| 5164 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 2004, 2005, 2006, 2007 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 ()) | |
| 84 if (matrix.cols () > 0 && matrix.rows () > 0 && | |
| 85 double (matrix.byte_size ()) > double (matrix.rows ()) * | |
| 86 double (matrix.cols ()) * sizeof (double)) | |
| 87 retval = new octave_matrix (::real (matrix.matrix_value ())); | |
| 88 else | |
| 89 retval = new octave_sparse_matrix (::real (matrix)); | |
| 90 else if (matrix.cols () > 0 && matrix.rows () > 0 && | |
| 91 double (matrix.byte_size ()) > double (matrix.rows ()) * | |
| 92 double (matrix.cols ()) * sizeof (Complex)) | |
| 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) { | |
| 315 error("load: only 2D sparse matrices are supported"); | |
| 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; | |
| 365 matrix = m; | |
| 366 | |
| 367 return true; | |
| 368 } | |
| 369 | |
| 370 #if defined (HAVE_HDF5) | |
| 5900 | 371 |
| 5164 | 372 bool |
| 373 octave_sparse_complex_matrix::save_hdf5 (hid_t loc_id, const char *name, | |
| 374 bool save_as_floats) | |
| 375 { | |
| 376 dim_vector dv = dims (); | |
| 377 int empty = save_hdf5_empty (loc_id, name, dv); | |
| 378 if (empty) | |
| 379 return (empty > 0); | |
| 380 | |
| 381 // Ensure that additional memory is deallocated | |
| 382 matrix.maybe_compress (); | |
| 383 | |
| 384 hid_t group_hid = H5Gcreate (loc_id, name, 0); | |
| 385 if (group_hid < 0) | |
| 386 return false; | |
| 387 | |
| 388 hid_t space_hid = -1, data_hid = -1; | |
| 389 bool retval = true; | |
| 390 SparseComplexMatrix m = sparse_complex_matrix_value (); | |
| 5351 | 391 octave_idx_type tmp; |
| 5164 | 392 hsize_t hdims[2]; |
| 393 | |
| 5760 | 394 space_hid = H5Screate_simple (0, hdims, 0); |
| 5164 | 395 if (space_hid < 0) |
| 396 { | |
| 397 H5Gclose (group_hid); | |
| 398 return false; | |
| 399 } | |
| 400 | |
| 5351 | 401 data_hid = H5Dcreate (group_hid, "nr", H5T_NATIVE_IDX, space_hid, |
| 5164 | 402 H5P_DEFAULT); |
| 403 if (data_hid < 0) | |
| 404 { | |
| 405 H5Sclose (space_hid); | |
| 406 H5Gclose (group_hid); | |
| 407 return false; | |
| 408 } | |
| 409 | |
| 410 tmp = m.rows (); | |
| 5351 | 411 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 412 H5P_DEFAULT, &tmp) >= 0; |
| 5164 | 413 H5Dclose (data_hid); |
| 414 if (!retval) | |
| 415 { | |
| 416 H5Sclose (space_hid); | |
| 417 H5Gclose (group_hid); | |
| 418 return false; | |
| 419 } | |
| 420 | |
| 5351 | 421 data_hid = H5Dcreate (group_hid, "nc", H5T_NATIVE_IDX, space_hid, |
| 5164 | 422 H5P_DEFAULT); |
| 423 if (data_hid < 0) | |
| 424 { | |
| 425 H5Sclose (space_hid); | |
| 426 H5Gclose (group_hid); | |
| 427 return false; | |
| 428 } | |
| 429 | |
| 430 tmp = m.cols (); | |
| 5351 | 431 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 432 H5P_DEFAULT, &tmp) >= 0; |
| 5164 | 433 H5Dclose (data_hid); |
| 434 if (!retval) | |
| 435 { | |
| 436 H5Sclose (space_hid); | |
| 437 H5Gclose (group_hid); | |
| 438 return false; | |
| 439 } | |
| 440 | |
| 5351 | 441 data_hid = H5Dcreate (group_hid, "nz", H5T_NATIVE_IDX, space_hid, |
| 5164 | 442 H5P_DEFAULT); |
| 443 if (data_hid < 0) | |
| 444 { | |
| 445 H5Sclose (space_hid); | |
| 446 H5Gclose (group_hid); | |
| 447 return false; | |
| 448 } | |
| 449 | |
| 5604 | 450 tmp = m.nzmax (); |
| 5351 | 451 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 452 H5P_DEFAULT, &tmp) >= 0; |
| 5164 | 453 H5Dclose (data_hid); |
| 454 if (!retval) | |
| 455 { | |
| 456 H5Sclose (space_hid); | |
| 457 H5Gclose (group_hid); | |
| 458 return false; | |
| 459 } | |
| 460 | |
| 461 H5Sclose (space_hid); | |
| 462 | |
| 463 hdims[0] = m.cols() + 1; | |
| 464 hdims[1] = 1; | |
| 465 | |
| 466 space_hid = H5Screate_simple (2, hdims, 0); | |
| 467 | |
| 468 if (space_hid < 0) | |
| 469 { | |
| 470 H5Gclose (group_hid); | |
| 471 return false; | |
| 472 } | |
| 473 | |
| 5351 | 474 data_hid = H5Dcreate (group_hid, "cidx", H5T_NATIVE_IDX, space_hid, |
| 5164 | 475 H5P_DEFAULT); |
| 476 if (data_hid < 0) | |
| 477 { | |
| 478 H5Sclose (space_hid); | |
| 479 H5Gclose (group_hid); | |
| 480 return false; | |
| 481 } | |
| 482 | |
| 5351 | 483 octave_idx_type * itmp = m.xcidx (); |
| 484 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, | |
| 5760 | 485 H5P_DEFAULT, itmp) >= 0; |
| 5164 | 486 H5Dclose (data_hid); |
| 487 if (!retval) | |
| 488 { | |
| 489 H5Sclose (space_hid); | |
| 490 H5Gclose (group_hid); | |
| 491 return false; | |
| 492 } | |
| 493 | |
| 494 H5Sclose (space_hid); | |
| 495 | |
| 5604 | 496 hdims[0] = m.nzmax (); |
| 5164 | 497 hdims[1] = 1; |
| 498 | |
| 499 space_hid = H5Screate_simple (2, hdims, 0); | |
| 500 | |
| 501 if (space_hid < 0) | |
| 502 { | |
| 503 H5Gclose (group_hid); | |
| 504 return false; | |
| 505 } | |
| 506 | |
| 5351 | 507 data_hid = H5Dcreate (group_hid, "ridx", H5T_NATIVE_IDX, space_hid, |
| 5164 | 508 H5P_DEFAULT); |
| 509 if (data_hid < 0) | |
| 510 { | |
| 511 H5Sclose (space_hid); | |
| 512 H5Gclose (group_hid); | |
| 513 return false; | |
| 514 } | |
| 515 | |
| 516 itmp = m.xridx (); | |
| 5760 | 517 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, itmp) >= 0; |
| 5164 | 518 H5Dclose (data_hid); |
| 519 if (!retval) | |
| 520 { | |
| 521 H5Sclose (space_hid); | |
| 522 H5Gclose (group_hid); | |
| 523 return false; | |
| 524 } | |
| 525 | |
| 526 hid_t save_type_hid = H5T_NATIVE_DOUBLE; | |
| 527 | |
| 528 if (save_as_floats) | |
| 529 { | |
| 530 if (m.too_large_for_float ()) | |
| 531 { | |
| 532 warning ("save: some values too large to save as floats --"); | |
| 533 warning ("save: saving as doubles instead"); | |
| 534 } | |
| 535 else | |
| 536 save_type_hid = H5T_NATIVE_FLOAT; | |
| 537 } | |
| 538 #if HAVE_HDF5_INT2FLOAT_CONVERSIONS | |
| 539 // hdf5 currently doesn't support float/integer conversions | |
| 540 else | |
| 541 { | |
| 542 double max_val, min_val; | |
| 543 | |
| 544 if (m.all_integers (max_val, min_val)) | |
| 545 save_type_hid | |
| 546 = save_type_to_hdf5 (get_save_type (max_val, min_val)); | |
| 547 } | |
| 548 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */ | |
| 549 | |
| 550 hid_t type_hid = hdf5_make_complex_type (save_type_hid); | |
| 551 if (type_hid < 0) | |
| 552 { | |
| 553 H5Sclose (space_hid); | |
| 554 H5Gclose (group_hid); | |
| 555 return false; | |
| 556 } | |
| 557 | |
| 5760 | 558 data_hid = H5Dcreate (group_hid, "data", type_hid, space_hid, H5P_DEFAULT); |
| 5164 | 559 if (data_hid < 0) |
| 560 { | |
| 561 H5Sclose (space_hid); | |
| 562 H5Tclose (type_hid); | |
| 563 H5Gclose (group_hid); | |
| 564 return false; | |
| 565 } | |
| 566 | |
| 567 hid_t complex_type_hid = hdf5_make_complex_type (H5T_NATIVE_DOUBLE); | |
| 568 retval = false; | |
| 569 if (complex_type_hid >= 0) | |
| 570 { | |
| 571 Complex * ctmp = m.xdata (); | |
| 572 | |
| 573 retval = H5Dwrite (data_hid, complex_type_hid, H5S_ALL, H5S_ALL, | |
| 5760 | 574 H5P_DEFAULT, ctmp) >= 0; |
| 5164 | 575 } |
| 576 | |
| 577 H5Dclose (data_hid); | |
| 578 H5Sclose (space_hid); | |
| 579 H5Tclose (type_hid); | |
| 580 H5Gclose (group_hid); | |
| 581 | |
| 582 return retval; | |
| 583 } | |
| 584 | |
| 585 bool | |
| 586 octave_sparse_complex_matrix::load_hdf5 (hid_t loc_id, const char *name, | |
| 587 bool /* have_h5giterate_bug */) | |
| 588 { | |
| 5351 | 589 octave_idx_type nr, nc, nz; |
| 5164 | 590 hid_t group_hid, data_hid, space_hid; |
| 591 hsize_t rank; | |
| 592 | |
| 593 dim_vector dv; | |
| 594 int empty = load_hdf5_empty (loc_id, name, dv); | |
| 595 if (empty > 0) | |
| 596 matrix.resize(dv); | |
| 597 if (empty) | |
| 598 return (empty > 0); | |
| 599 | |
| 600 group_hid = H5Gopen (loc_id, name); | |
| 601 if (group_hid < 0 ) return false; | |
| 602 | |
| 603 data_hid = H5Dopen (group_hid, "nr"); | |
| 604 space_hid = H5Dget_space (data_hid); | |
| 605 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 606 | |
| 607 if (rank != 0) | |
| 608 { | |
| 609 H5Dclose (data_hid); | |
| 610 H5Gclose (group_hid); | |
| 611 return false; | |
| 612 } | |
| 613 | |
| 5760 | 614 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, &nr) < 0) |
| 5164 | 615 { |
| 616 H5Dclose (data_hid); | |
| 617 H5Gclose (group_hid); | |
| 618 return false; | |
| 619 } | |
| 620 | |
| 621 H5Dclose (data_hid); | |
| 622 | |
| 623 data_hid = H5Dopen (group_hid, "nc"); | |
| 624 space_hid = H5Dget_space (data_hid); | |
| 625 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 626 | |
| 627 if (rank != 0) | |
| 628 { | |
| 629 H5Dclose (data_hid); | |
| 630 H5Gclose (group_hid); | |
| 631 return false; | |
| 632 } | |
| 633 | |
| 5760 | 634 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, &nc) < 0) |
| 5164 | 635 { |
| 636 H5Dclose (data_hid); | |
| 637 H5Gclose (group_hid); | |
| 638 return false; | |
| 639 } | |
| 640 | |
| 641 H5Dclose (data_hid); | |
| 642 | |
| 643 data_hid = H5Dopen (group_hid, "nz"); | |
| 644 space_hid = H5Dget_space (data_hid); | |
| 645 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 646 | |
| 647 if (rank != 0) | |
| 648 { | |
| 649 H5Dclose (data_hid); | |
| 650 H5Gclose (group_hid); | |
| 651 return false; | |
| 652 } | |
| 653 | |
| 5760 | 654 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, &nz) < 0) |
| 5164 | 655 { |
| 656 H5Dclose (data_hid); | |
| 657 H5Gclose (group_hid); | |
| 658 return false; | |
| 659 } | |
| 660 | |
| 661 H5Dclose (data_hid); | |
| 662 | |
| 5275 | 663 SparseComplexMatrix m (static_cast<octave_idx_type> (nr), |
| 664 static_cast<octave_idx_type> (nc), | |
| 665 static_cast<octave_idx_type> (nz)); | |
| 5164 | 666 |
| 667 data_hid = H5Dopen (group_hid, "cidx"); | |
| 668 space_hid = H5Dget_space (data_hid); | |
| 669 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 670 | |
| 671 if (rank != 2) | |
| 672 { | |
| 673 H5Sclose (space_hid); | |
| 674 H5Dclose (data_hid); | |
| 675 H5Gclose (group_hid); | |
| 676 return false; | |
| 677 } | |
| 678 | |
| 679 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank); | |
| 680 OCTAVE_LOCAL_BUFFER (hsize_t, maxdims, rank); | |
| 681 | |
| 682 H5Sget_simple_extent_dims (space_hid, hdims, maxdims); | |
| 683 | |
| 5322 | 684 if (static_cast<int> (hdims[0]) != nc + 1 || |
| 685 static_cast<int> (hdims[1]) != 1) | |
| 5164 | 686 { |
| 687 H5Sclose (space_hid); | |
| 688 H5Dclose (data_hid); | |
| 689 H5Gclose (group_hid); | |
| 690 return false; | |
| 691 } | |
| 692 | |
| 5351 | 693 octave_idx_type *itmp = m.xcidx (); |
| 5760 | 694 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, itmp) < 0) |
| 5164 | 695 { |
| 696 H5Sclose (space_hid); | |
| 697 H5Dclose (data_hid); | |
| 698 H5Gclose (group_hid); | |
| 699 return false; | |
| 700 } | |
| 701 | |
| 702 H5Sclose (space_hid); | |
| 703 H5Dclose (data_hid); | |
| 704 | |
| 705 data_hid = H5Dopen (group_hid, "ridx"); | |
| 706 space_hid = H5Dget_space (data_hid); | |
| 707 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 708 | |
| 709 if (rank != 2) | |
| 710 { | |
| 711 H5Sclose (space_hid); | |
| 712 H5Dclose (data_hid); | |
| 713 H5Gclose (group_hid); | |
| 714 return false; | |
| 715 } | |
| 716 | |
| 717 H5Sget_simple_extent_dims (space_hid, hdims, maxdims); | |
| 718 | |
| 5351 | 719 if (static_cast<int> (hdims[0]) != nz || |
| 720 static_cast<int> (hdims[1]) != 1) | |
| 5164 | 721 { |
| 722 H5Sclose (space_hid); | |
| 723 H5Dclose (data_hid); | |
| 724 H5Gclose (group_hid); | |
| 725 return false; | |
| 726 } | |
| 727 | |
| 728 itmp = m.xridx (); | |
| 5760 | 729 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, itmp) < 0) |
| 5164 | 730 { |
| 731 H5Sclose (space_hid); | |
| 732 H5Dclose (data_hid); | |
| 733 H5Gclose (group_hid); | |
| 734 return false; | |
| 735 } | |
| 736 | |
| 737 H5Sclose (space_hid); | |
| 738 H5Dclose (data_hid); | |
| 739 | |
| 740 data_hid = H5Dopen (group_hid, "data"); | |
| 741 hid_t type_hid = H5Dget_type (data_hid); | |
| 742 | |
| 743 hid_t complex_type = hdf5_make_complex_type (H5T_NATIVE_DOUBLE); | |
| 744 | |
| 745 if (! hdf5_types_compatible (type_hid, complex_type)) | |
| 746 { | |
| 747 H5Tclose (complex_type); | |
| 748 H5Dclose (data_hid); | |
| 749 H5Gclose (group_hid); | |
| 750 return false; | |
| 751 } | |
| 752 | |
| 753 space_hid = H5Dget_space (data_hid); | |
| 754 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 755 | |
| 756 if (rank != 2) | |
| 757 { | |
| 758 H5Sclose (space_hid); | |
| 759 H5Dclose (data_hid); | |
| 760 H5Gclose (group_hid); | |
| 761 return false; | |
| 762 } | |
| 763 | |
| 764 H5Sget_simple_extent_dims (space_hid, hdims, maxdims); | |
| 765 | |
| 5351 | 766 if (static_cast<int> (hdims[0]) != nz || |
| 767 static_cast<int> (hdims[1]) != 1) | |
| 5164 | 768 { |
| 769 H5Sclose (space_hid); | |
| 770 H5Dclose (data_hid); | |
| 771 H5Gclose (group_hid); | |
| 772 return false; | |
| 773 } | |
| 774 | |
| 775 Complex *ctmp = m.xdata (); | |
| 776 bool retval = false; | |
| 5760 | 777 if (H5Dread (data_hid, complex_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, ctmp) >= 0) |
| 5164 | 778 { |
| 779 retval = true; | |
| 780 matrix = m; | |
| 781 } | |
| 782 | |
| 783 H5Tclose (complex_type); | |
| 784 H5Sclose (space_hid); | |
| 785 H5Dclose (data_hid); | |
| 786 H5Gclose (group_hid); | |
| 787 | |
| 788 return retval; | |
| 789 } | |
| 790 | |
| 791 #endif | |
| 792 | |
| 5900 | 793 mxArray * |
| 794 octave_sparse_complex_matrix::as_mxArray (void) const | |
| 795 { | |
| 6686 | 796 mwSize nz = nzmax (); |
| 5903 | 797 mxArray *retval = new mxArray (mxDOUBLE_CLASS, rows (), columns (), |
| 798 nz, mxCOMPLEX); | |
| 799 double *pr = static_cast<double *> (retval->get_data ()); | |
| 800 double *pi = static_cast<double *> (retval->get_imag_data ()); | |
| 6686 | 801 mwIndex *ir = retval->get_ir (); |
| 802 mwIndex *jc = retval->get_jc (); | |
| 5903 | 803 |
| 6686 | 804 for (mwIndex i = 0; i < nz; i++) |
| 5903 | 805 { |
| 806 Complex val = matrix.data(i); | |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
807 pr[i] = std::real (val); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
808 pi[i] = std::imag (val); |
| 5903 | 809 ir[i] = matrix.ridx(i); |
| 810 } | |
| 811 | |
| 6686 | 812 for (mwIndex i = 0; i < columns() + 1; i++) |
| 5903 | 813 jc[i] = matrix.cidx(i); |
| 814 | |
| 815 return retval; | |
| 5900 | 816 } |
| 817 | |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
818 static double |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
819 xabs (const Complex& x) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
820 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
821 return (xisinf (x.real ()) || xisinf (x.imag ())) ? octave_Inf : abs (x); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
822 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
823 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
824 static double |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
825 ximag (const Complex& x) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
826 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
827 return x.imag (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
828 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
829 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
830 static double |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
831 xreal (const Complex& x) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
832 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
833 return x.real (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
834 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
835 |
|
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
|
836 static bool |
|
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
|
837 any_element_less_than (const SparseMatrix& a, double val) |
|
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 { |
|
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
|
839 octave_idx_type len = a.nnz (); |
|
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 |
|
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
|
841 if (val > 0. && len != a.numel ()) |
|
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
|
842 return true; |
|
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
|
843 |
|
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
|
844 for (octave_idx_type i = 0; i < len; i++) |
|
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
|
845 { |
|
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
|
846 OCTAVE_QUIT; |
|
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
|
847 |
|
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
|
848 if (a.data(i) < val) |
|
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
|
849 return true; |
|
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
|
850 } |
|
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
|
851 |
|
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
|
852 return false; |
|
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
|
853 } |
|
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
|
854 |
|
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
|
855 static bool |
|
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
|
856 any_element_greater_than (const SparseMatrix& a, double val) |
|
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
|
857 { |
|
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
|
858 octave_idx_type len = a.nnz (); |
|
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
|
859 |
|
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
|
860 if (val < 0. && len != a.numel ()) |
|
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
|
861 return true; |
|
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
|
862 |
|
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
|
863 for (octave_idx_type i = 0; i < len; i++) |
|
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
|
864 { |
|
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
|
865 OCTAVE_QUIT; |
|
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
|
866 |
|
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
|
867 if (a.data(i) > val) |
|
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
|
868 return true; |
|
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
|
869 } |
|
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
|
870 |
|
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
|
871 return false; |
|
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
|
872 } |
|
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
|
873 |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
874 #define SPARSE_MAPPER(MAP, AMAP, FCN) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
875 octave_value \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
876 octave_sparse_complex_matrix::MAP (void) const \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
877 { \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
878 static AMAP cmap = FCN; \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
879 return matrix.map (cmap); \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
880 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
881 |
|
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
|
882 #define DSPARSE_MAPPER(MAP, AMAP, FCN) \ |
|
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
|
883 octave_value \ |
|
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
|
884 octave_sparse_complex_matrix::MAP (void) const \ |
|
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
|
885 { \ |
|
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
|
886 static SparseComplexMatrix::dmapper dmap = ximag; \ |
|
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
|
887 SparseMatrix m = matrix.map (dmap); \ |
|
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
|
888 if (m.all_elements_are_zero ()) \ |
|
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
|
889 { \ |
|
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
|
890 dmap = xreal; \ |
|
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
|
891 m = matrix.map (dmap); \ |
|
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
|
892 static AMAP cmap = FCN; \ |
|
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
|
893 return m.map (cmap); \ |
|
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
|
894 } \ |
|
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
|
895 else \ |
|
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
|
896 { \ |
|
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
|
897 error ("%s: not defined for complex arguments", #MAP); \ |
|
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
|
898 return octave_value (); \ |
|
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
|
899 } \ |
|
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
|
900 } |
|
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
|
901 |
|
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
|
902 #define CD_SPARSE_MAPPER(MAP, RFCN, CFCN, L1, L2) \ |
|
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
|
903 octave_value \ |
|
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
|
904 octave_sparse_complex_matrix::MAP (void) const \ |
|
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
|
905 { \ |
|
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
|
906 static SparseComplexMatrix::dmapper idmap = ximag; \ |
|
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
|
907 SparseMatrix m = matrix.map (idmap); \ |
|
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
|
908 if (m.all_elements_are_zero ()) \ |
|
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
|
909 { \ |
|
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
|
910 static SparseComplexMatrix::dmapper rdmap = xreal; \ |
|
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
|
911 m = matrix.map (rdmap); \ |
|
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
|
912 static SparseMatrix::dmapper dmap = RFCN; \ |
|
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
|
913 static SparseMatrix::cmapper cmap = CFCN; \ |
|
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
|
914 return (any_element_less_than (m, L1) \ |
|
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
|
915 ? octave_value (m.map (cmap)) \ |
|
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
|
916 : (any_element_greater_than (m, L2) \ |
|
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
|
917 ? octave_value (m.map (cmap)) \ |
|
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
|
918 : octave_value (m.map (dmap)))); \ |
|
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
|
919 } \ |
|
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
|
920 else \ |
|
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
|
921 { \ |
|
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
|
922 error ("%s: not defined for complex arguments", #MAP); \ |
|
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
|
923 return octave_value (); \ |
|
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
|
924 } \ |
|
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
|
925 } |
|
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
|
926 |
|
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
|
927 DSPARSE_MAPPER (erf, SparseMatrix::dmapper, ::erf) |
|
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
|
928 DSPARSE_MAPPER (erfc, SparseMatrix::dmapper, ::erfc) |
|
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
|
929 DSPARSE_MAPPER (gamma, SparseMatrix::dmapper, xgamma) |
|
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
|
930 CD_SPARSE_MAPPER (lgamma, xlgamma, xlgamma, 0.0, octave_Inf) |
|
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
|
931 |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
932 SPARSE_MAPPER (abs, SparseComplexMatrix::dmapper, xabs) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
933 SPARSE_MAPPER (acos, SparseComplexMatrix::cmapper, ::acos) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
934 SPARSE_MAPPER (acosh, SparseComplexMatrix::cmapper, ::acosh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
935 SPARSE_MAPPER (angle, SparseComplexMatrix::dmapper, std::arg) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
936 SPARSE_MAPPER (arg, SparseComplexMatrix::dmapper, std::arg) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
937 SPARSE_MAPPER (asin, SparseComplexMatrix::cmapper, ::asin) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
938 SPARSE_MAPPER (asinh, SparseComplexMatrix::cmapper, ::asinh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
939 SPARSE_MAPPER (atan, SparseComplexMatrix::cmapper, ::atan) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
940 SPARSE_MAPPER (atanh, SparseComplexMatrix::cmapper, ::atanh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
941 SPARSE_MAPPER (ceil, SparseComplexMatrix::cmapper, ::ceil) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
942 SPARSE_MAPPER (conj, SparseComplexMatrix::cmapper, std::conj) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
943 SPARSE_MAPPER (cos, SparseComplexMatrix::cmapper, std::cos) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
944 SPARSE_MAPPER (cosh, SparseComplexMatrix::cmapper, std::cosh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
945 SPARSE_MAPPER (exp, SparseComplexMatrix::cmapper, std::exp) |
|
7638
2df457529cfa
implement expm1 and log1p functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7636
diff
changeset
|
946 SPARSE_MAPPER (expm1, SparseComplexMatrix::cmapper, ::expm1) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
947 SPARSE_MAPPER (fix, SparseComplexMatrix::cmapper, ::fix) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
948 SPARSE_MAPPER (floor, SparseComplexMatrix::cmapper, ::floor) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
949 SPARSE_MAPPER (imag, SparseComplexMatrix::dmapper, ximag) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
950 SPARSE_MAPPER (log, SparseComplexMatrix::cmapper, std::log) |
| 7740 | 951 SPARSE_MAPPER (log2, SparseComplexMatrix::cmapper, xlog2) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
952 SPARSE_MAPPER (log10, SparseComplexMatrix::cmapper, std::log10) |
|
7638
2df457529cfa
implement expm1 and log1p functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7636
diff
changeset
|
953 SPARSE_MAPPER (log1p, SparseComplexMatrix::cmapper, ::log1p) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
954 SPARSE_MAPPER (real, SparseComplexMatrix::dmapper, xreal) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
955 SPARSE_MAPPER (round, SparseComplexMatrix::cmapper, xround) |
|
7636
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7503
diff
changeset
|
956 SPARSE_MAPPER (roundb, SparseComplexMatrix::cmapper, xroundb) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
957 SPARSE_MAPPER (signum, SparseComplexMatrix::cmapper, ::signum) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
958 SPARSE_MAPPER (sin, SparseComplexMatrix::cmapper, std::sin) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
959 SPARSE_MAPPER (sinh, SparseComplexMatrix::cmapper, std::sinh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
960 SPARSE_MAPPER (sqrt, SparseComplexMatrix::cmapper, std::sqrt) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
961 SPARSE_MAPPER (tan, SparseComplexMatrix::cmapper, std::tan) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
962 SPARSE_MAPPER (tanh, SparseComplexMatrix::cmapper, std::tanh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
963 SPARSE_MAPPER (finite, SparseComplexMatrix::bmapper, xfinite) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
964 SPARSE_MAPPER (isinf, SparseComplexMatrix::bmapper, xisinf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
965 SPARSE_MAPPER (isna, SparseComplexMatrix::bmapper, octave_is_NA) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
966 SPARSE_MAPPER (isnan, SparseComplexMatrix::bmapper, xisnan) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
967 |
| 5164 | 968 /* |
| 969 ;;; Local Variables: *** | |
| 970 ;;; mode: C++ *** | |
| 971 ;;; End: *** | |
| 972 */ |