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