Mercurial > octave-nkf
annotate src/ov-re-sparse.cc @ 7961:a5d1e27ee1f4 ss-3-1-51
3.1.51 snapshot
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Tue, 22 Jul 2008 11:40:48 -0400 |
| parents | 935be827eaf8 |
| 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 "gripes.h" | |
| 39 | |
| 40 #include "ls-hdf5.h" | |
| 41 | |
| 42 #include "ov-re-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<SparseMatrix>; |
| 5164 | 50 |
| 51 DEFINE_OCTAVE_ALLOCATOR (octave_sparse_matrix); | |
| 52 | |
| 6823 | 53 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_sparse_matrix, "sparse matrix", "double"); |
| 5164 | 54 |
| 5282 | 55 idx_vector |
| 56 octave_sparse_matrix::index_vector (void) const | |
| 57 { | |
| 5604 | 58 if (matrix.numel () == matrix.nnz ()) |
| 5282 | 59 return idx_vector (array_value ()); |
| 60 else | |
| 61 { | |
| 62 std::string nm = type_name (); | |
| 63 error ("%s type invalid as index value", nm.c_str ()); | |
| 64 return idx_vector (); | |
| 65 } | |
| 66 } | |
| 67 | |
| 5759 | 68 octave_base_value * |
| 5164 | 69 octave_sparse_matrix::try_narrowing_conversion (void) |
| 70 { | |
| 5759 | 71 octave_base_value *retval = 0; |
| 5164 | 72 |
| 7193 | 73 if (Vsparse_auto_mutate) |
| 5164 | 74 { |
| 7193 | 75 // Don't use numel, since it can overflow for very large matrices |
| 76 // Note that for the second test, this means it becomes approximative | |
| 77 // since it involves a cast to double to avoid issues of overflow | |
| 78 if (matrix.rows () == 1 && matrix.cols () == 1) | |
| 79 { | |
| 80 // Const copy of the matrix, so the right version of () operator used | |
| 81 const SparseMatrix tmp (matrix); | |
| 5164 | 82 |
| 7193 | 83 retval = new octave_scalar (tmp (0)); |
| 84 } | |
| 85 else if (matrix.cols () > 0 && matrix.rows () > 0 && | |
| 86 double (matrix.byte_size ()) > double (matrix.rows ()) * | |
| 87 double (matrix.cols ()) * sizeof (double)) | |
| 88 retval = new octave_matrix (matrix.matrix_value ()); | |
| 5164 | 89 } |
| 90 | |
| 91 return retval; | |
| 92 } | |
| 93 | |
| 94 bool | |
| 95 octave_sparse_matrix::valid_as_scalar_index (void) const | |
| 96 { | |
| 5775 | 97 // FIXME |
| 5164 | 98 return false; |
| 99 } | |
| 100 | |
| 101 double | |
| 102 octave_sparse_matrix::double_value (bool) const | |
| 103 { | |
| 104 double retval = lo_ieee_nan_value (); | |
| 105 | |
| 106 if (numel () > 0) | |
| 107 { | |
| 6221 | 108 if (numel () > 1) |
| 109 gripe_implicit_conversion ("Octave:array-as-scalar", | |
| 110 "real sparse matrix", "real scalar"); | |
| 5164 | 111 |
| 112 retval = matrix (0, 0); | |
| 113 } | |
| 114 else | |
| 115 gripe_invalid_conversion ("real sparse matrix", "real scalar"); | |
| 116 | |
| 117 return retval; | |
| 118 } | |
| 119 | |
| 120 Complex | |
| 121 octave_sparse_matrix::complex_value (bool) const | |
| 122 { | |
| 123 double tmp = lo_ieee_nan_value (); | |
| 124 | |
| 125 Complex retval (tmp, tmp); | |
| 126 | |
| 5775 | 127 // FIXME -- maybe this should be a function, valid_as_scalar() |
| 5164 | 128 if (rows () > 0 && columns () > 0) |
| 129 { | |
| 6221 | 130 if (numel () > 1) |
| 131 gripe_implicit_conversion ("Octave:array-as-scalar", | |
| 132 "real sparse matrix", "complex scalar"); | |
| 5164 | 133 |
| 134 retval = matrix (0, 0); | |
| 135 } | |
| 136 else | |
| 137 gripe_invalid_conversion ("real sparse matrix", "complex scalar"); | |
| 138 | |
| 139 return retval; | |
| 140 } | |
| 141 | |
| 142 Matrix | |
| 143 octave_sparse_matrix::matrix_value (bool) const | |
| 144 { | |
| 145 return matrix.matrix_value (); | |
| 146 } | |
| 147 | |
| 5898 | 148 boolNDArray |
| 5943 | 149 octave_sparse_matrix::bool_array_value (bool warn) const |
| 5898 | 150 { |
| 5943 | 151 NDArray m = matrix.matrix_value (); |
| 152 | |
|
7922
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7885
diff
changeset
|
153 if (m.any_element_is_nan ()) |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7885
diff
changeset
|
154 error ("invalid conversion from NaN to logical"); |
|
935be827eaf8
error for NaN values in & and | expressions
John W. Eaton <jwe@octave.org>
parents:
7885
diff
changeset
|
155 else if (warn && m.any_element_not_one_or_zero ()) |
| 5943 | 156 gripe_logical_conversion (); |
| 157 | |
| 158 return boolNDArray (m); | |
| 5898 | 159 } |
| 160 | |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
161 charNDArray |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
162 octave_sparse_matrix::char_array_value (bool) const |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
163 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
164 charNDArray retval (dims (), 0); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
165 octave_idx_type nc = matrix.cols (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
166 octave_idx_type nr = matrix.rows (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
167 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
168 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
|
169 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
|
170 retval(matrix.ridx(i) + nr * j) = static_cast<char>(matrix.data (i)); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
171 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
172 return retval; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
173 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
174 |
| 5164 | 175 ComplexMatrix |
| 176 octave_sparse_matrix::complex_matrix_value (bool) const | |
| 177 { | |
| 178 return ComplexMatrix (matrix.matrix_value ()); | |
| 179 } | |
| 180 | |
| 181 ComplexNDArray | |
| 182 octave_sparse_matrix::complex_array_value (bool) const | |
| 183 { | |
| 184 return ComplexNDArray (ComplexMatrix (matrix.matrix_value ())); | |
| 185 } | |
| 186 | |
| 187 NDArray | |
| 188 octave_sparse_matrix::array_value (bool) const | |
| 189 { | |
| 190 return NDArray (matrix.matrix_value ()); | |
| 191 } | |
| 192 | |
| 5282 | 193 octave_value |
| 5322 | 194 octave_sparse_matrix::convert_to_str_internal (bool, bool, char type) const |
| 5282 | 195 { |
| 196 octave_value retval; | |
| 197 dim_vector dv = dims (); | |
| 198 octave_idx_type nel = dv.numel (); | |
| 199 | |
| 200 if (nel == 0) | |
| 201 { | |
| 202 char s = '\0'; | |
| 5322 | 203 retval = octave_value (&s, type); |
| 5282 | 204 } |
| 205 else | |
| 206 { | |
| 207 octave_idx_type nr = matrix.rows (); | |
| 208 octave_idx_type nc = matrix.cols (); | |
| 209 charNDArray chm (dv, static_cast<char> (0)); | |
| 210 | |
| 211 bool warned = false; | |
| 212 | |
| 213 for (octave_idx_type j = 0; j < nc; j++) | |
| 214 for (octave_idx_type i = matrix.cidx(j); | |
| 215 i < matrix.cidx(j+1); i++) | |
| 216 { | |
| 217 OCTAVE_QUIT; | |
| 218 | |
| 219 double d = matrix.data (i); | |
| 220 | |
| 221 if (xisnan (d)) | |
| 222 { | |
| 223 ::error ("invalid conversion from NaN to character"); | |
| 224 return retval; | |
| 225 } | |
| 226 else | |
| 227 { | |
| 228 int ival = NINT (d); | |
| 229 | |
| 230 if (ival < 0 || ival > UCHAR_MAX) | |
| 231 { | |
| 5775 | 232 // FIXME -- is there something |
| 5282 | 233 // better we could do? |
| 234 | |
| 235 ival = 0; | |
| 236 | |
| 237 if (! warned) | |
| 238 { | |
| 239 ::warning ("range error for conversion to character value"); | |
| 240 warned = true; | |
| 241 } | |
| 242 } | |
| 243 | |
| 244 chm (matrix.ridx(i) + j * nr) = | |
| 245 static_cast<char> (ival); | |
| 246 } | |
| 247 } | |
| 5322 | 248 retval = octave_value (chm, true, type); |
| 5282 | 249 } |
| 250 | |
| 251 return retval; | |
| 252 } | |
| 253 | |
| 5164 | 254 bool |
| 255 octave_sparse_matrix::save_binary (std::ostream& os, bool&save_as_floats) | |
| 256 { | |
| 257 dim_vector d = this->dims (); | |
| 258 if (d.length() < 1) | |
| 259 return false; | |
| 260 | |
| 261 // Ensure that additional memory is deallocated | |
| 262 matrix.maybe_compress (); | |
| 263 | |
| 264 int nr = d(0); | |
| 265 int nc = d(1); | |
| 5604 | 266 int nz = nzmax (); |
| 5164 | 267 |
| 5828 | 268 int32_t itmp; |
| 5164 | 269 // Use negative value for ndims to be consistent with other formats |
| 270 itmp= -2; | |
| 5760 | 271 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 272 |
| 273 itmp= nr; | |
| 5760 | 274 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 275 |
| 276 itmp= nc; | |
| 5760 | 277 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 278 |
| 279 itmp= nz; | |
| 5760 | 280 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 281 |
| 282 save_type st = LS_DOUBLE; | |
| 283 if (save_as_floats) | |
| 284 { | |
| 285 if (matrix.too_large_for_float ()) | |
| 286 { | |
| 287 warning ("save: some values too large to save as floats --"); | |
| 288 warning ("save: saving as doubles instead"); | |
| 289 } | |
| 290 else | |
| 291 st = LS_FLOAT; | |
| 292 } | |
| 5775 | 293 else if (matrix.nzmax () > 8192) // FIXME -- make this configurable. |
| 5164 | 294 { |
| 295 double max_val, min_val; | |
| 296 if (matrix.all_integers (max_val, min_val)) | |
| 297 st = get_save_type (max_val, min_val); | |
| 298 } | |
| 299 | |
| 300 // add one to the printed indices to go from | |
| 301 // zero-based to one-based arrays | |
| 302 for (int i = 0; i < nc+1; i++) | |
| 303 { | |
| 304 OCTAVE_QUIT; | |
| 305 itmp = matrix.cidx(i); | |
| 5760 | 306 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 307 } |
| 308 | |
| 309 for (int i = 0; i < nz; i++) | |
| 310 { | |
| 311 OCTAVE_QUIT; | |
| 312 itmp = matrix.ridx(i); | |
| 5760 | 313 os.write (reinterpret_cast<char *> (&itmp), 4); |
| 5164 | 314 } |
| 315 | |
| 316 write_doubles (os, matrix.data(), st, nz); | |
| 317 | |
| 318 return true; | |
| 319 } | |
| 320 | |
| 321 bool | |
| 322 octave_sparse_matrix::load_binary (std::istream& is, bool swap, | |
| 323 oct_mach_info::float_format fmt) | |
| 324 { | |
| 5828 | 325 int32_t nz, nc, nr, tmp; |
| 5327 | 326 char ctmp; |
| 327 | |
| 5760 | 328 if (! is.read (reinterpret_cast<char *> (&tmp), 4)) |
| 5164 | 329 return false; |
| 330 | |
| 331 if (swap) | |
| 332 swap_bytes<4> (&tmp); | |
| 333 | |
| 334 if (tmp != -2) { | |
| 335 error("load: only 2D sparse matrices are supported"); | |
| 336 return false; | |
| 337 } | |
| 338 | |
| 5760 | 339 if (! is.read (reinterpret_cast<char *> (&nr), 4)) |
| 5164 | 340 return false; |
| 5760 | 341 if (! is.read (reinterpret_cast<char *> (&nc), 4)) |
| 5164 | 342 return false; |
| 5760 | 343 if (! is.read (reinterpret_cast<char *> (&nz), 4)) |
| 5164 | 344 return false; |
| 345 | |
| 346 if (swap) | |
| 347 { | |
| 348 swap_bytes<4> (&nr); | |
| 349 swap_bytes<4> (&nc); | |
| 350 swap_bytes<4> (&nz); | |
| 351 } | |
| 352 | |
| 5275 | 353 SparseMatrix m (static_cast<octave_idx_type> (nr), |
| 354 static_cast<octave_idx_type> (nc), | |
| 355 static_cast<octave_idx_type> (nz)); | |
| 5164 | 356 |
| 357 for (int i = 0; i < nc+1; i++) | |
| 358 { | |
| 359 OCTAVE_QUIT; | |
| 5760 | 360 if (! is.read (reinterpret_cast<char *> (&tmp), 4)) |
| 5164 | 361 return false; |
| 362 if (swap) | |
| 363 swap_bytes<4> (&tmp); | |
| 364 m.xcidx(i) = tmp; | |
| 365 } | |
| 366 | |
| 367 for (int i = 0; i < nz; i++) | |
| 368 { | |
| 369 OCTAVE_QUIT; | |
| 5760 | 370 if (! is.read (reinterpret_cast<char *> (&tmp), 4)) |
| 5164 | 371 return false; |
| 372 if (swap) | |
| 373 swap_bytes<4> (&tmp); | |
| 374 m.xridx(i) = tmp; | |
| 375 } | |
| 376 | |
| 5760 | 377 if (! is.read (reinterpret_cast<char *> (&ctmp), 1)) |
| 5164 | 378 return false; |
| 379 | |
| 5760 | 380 read_doubles (is, m.xdata (), static_cast<save_type> (ctmp), nz, swap, fmt); |
| 5164 | 381 |
| 382 if (error_state || ! is) | |
| 383 return false; | |
| 384 matrix = m; | |
| 385 | |
| 386 return true; | |
| 387 } | |
| 388 | |
| 389 #if defined (HAVE_HDF5) | |
| 5900 | 390 |
| 5164 | 391 bool |
| 392 octave_sparse_matrix::save_hdf5 (hid_t loc_id, const char *name, | |
| 393 bool save_as_floats) | |
| 394 { | |
| 395 dim_vector dv = dims (); | |
| 396 int empty = save_hdf5_empty (loc_id, name, dv); | |
| 397 if (empty) | |
| 398 return (empty > 0); | |
| 399 | |
| 400 // Ensure that additional memory is deallocated | |
| 401 matrix.maybe_compress (); | |
| 402 | |
| 403 hid_t group_hid = H5Gcreate (loc_id, name, 0); | |
| 404 if (group_hid < 0) | |
| 405 return false; | |
| 406 | |
| 407 hid_t space_hid = -1, data_hid = -1; | |
| 408 bool retval = true; | |
| 409 SparseMatrix m = sparse_matrix_value (); | |
| 5351 | 410 octave_idx_type tmp; |
| 5164 | 411 hsize_t hdims[2]; |
| 412 | |
| 5760 | 413 space_hid = H5Screate_simple (0, hdims, 0); |
| 5164 | 414 if (space_hid < 0) |
| 415 { | |
| 416 H5Gclose (group_hid); | |
| 417 return false; | |
| 418 } | |
| 419 | |
| 5351 | 420 data_hid = H5Dcreate (group_hid, "nr", H5T_NATIVE_IDX, space_hid, |
| 5164 | 421 H5P_DEFAULT); |
| 422 if (data_hid < 0) | |
| 423 { | |
| 424 H5Sclose (space_hid); | |
| 425 H5Gclose (group_hid); | |
| 426 return false; | |
| 427 } | |
| 428 | |
| 429 tmp = m.rows (); | |
| 5351 | 430 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, |
| 5760 | 431 &tmp) >= 0; |
| 5164 | 432 H5Dclose (data_hid); |
| 433 if (!retval) | |
| 434 { | |
| 435 H5Sclose (space_hid); | |
| 436 H5Gclose (group_hid); | |
| 437 return false; | |
| 438 } | |
| 439 | |
| 5351 | 440 data_hid = H5Dcreate (group_hid, "nc", H5T_NATIVE_IDX, space_hid, |
| 5164 | 441 H5P_DEFAULT); |
| 442 if (data_hid < 0) | |
| 443 { | |
| 444 H5Sclose (space_hid); | |
| 445 H5Gclose (group_hid); | |
| 446 return false; | |
| 447 } | |
| 448 | |
| 449 tmp = m.cols (); | |
| 5351 | 450 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, |
| 5760 | 451 &tmp) >= 0; |
| 5164 | 452 H5Dclose (data_hid); |
| 453 if (!retval) | |
| 454 { | |
| 455 H5Sclose (space_hid); | |
| 456 H5Gclose (group_hid); | |
| 457 return false; | |
| 458 } | |
| 459 | |
| 5351 | 460 data_hid = H5Dcreate (group_hid, "nz", H5T_NATIVE_IDX, space_hid, |
| 5164 | 461 H5P_DEFAULT); |
| 462 if (data_hid < 0) | |
| 463 { | |
| 464 H5Sclose (space_hid); | |
| 465 H5Gclose (group_hid); | |
| 466 return false; | |
| 467 } | |
| 468 | |
| 5604 | 469 tmp = m.nzmax (); |
| 5351 | 470 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, |
| 5760 | 471 &tmp) >= 0; |
| 5164 | 472 H5Dclose (data_hid); |
| 473 if (!retval) | |
| 474 { | |
| 475 H5Sclose (space_hid); | |
| 476 H5Gclose (group_hid); | |
| 477 return false; | |
| 478 } | |
| 479 | |
| 480 H5Sclose (space_hid); | |
| 481 | |
| 482 hdims[0] = m.cols() + 1; | |
| 483 hdims[1] = 1; | |
| 484 | |
| 485 space_hid = H5Screate_simple (2, hdims, 0); | |
| 486 | |
| 487 if (space_hid < 0) | |
| 488 { | |
| 489 H5Gclose (group_hid); | |
| 490 return false; | |
| 491 } | |
| 492 | |
| 5351 | 493 data_hid = H5Dcreate (group_hid, "cidx", H5T_NATIVE_IDX, space_hid, |
| 5164 | 494 H5P_DEFAULT); |
| 495 if (data_hid < 0) | |
| 496 { | |
| 497 H5Sclose (space_hid); | |
| 498 H5Gclose (group_hid); | |
| 499 return false; | |
| 500 } | |
| 501 | |
| 5351 | 502 octave_idx_type * itmp = m.xcidx (); |
| 503 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, | |
| 5760 | 504 itmp) >= 0; |
| 5164 | 505 H5Dclose (data_hid); |
| 506 if (!retval) | |
| 507 { | |
| 508 H5Sclose (space_hid); | |
| 509 H5Gclose (group_hid); | |
| 510 return false; | |
| 511 } | |
| 512 | |
| 513 H5Sclose (space_hid); | |
| 514 | |
| 5604 | 515 hdims[0] = m.nzmax (); |
| 5164 | 516 hdims[1] = 1; |
| 517 | |
| 518 space_hid = H5Screate_simple (2, hdims, 0); | |
| 519 | |
| 520 if (space_hid < 0) | |
| 521 { | |
| 522 H5Gclose (group_hid); | |
| 523 return false; | |
| 524 } | |
| 525 | |
| 5351 | 526 data_hid = H5Dcreate (group_hid, "ridx", H5T_NATIVE_IDX, space_hid, |
| 5164 | 527 H5P_DEFAULT); |
| 528 if (data_hid < 0) | |
| 529 { | |
| 530 H5Sclose (space_hid); | |
| 531 H5Gclose (group_hid); | |
| 532 return false; | |
| 533 } | |
| 534 | |
| 535 itmp = m.xridx (); | |
| 5351 | 536 retval = H5Dwrite (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, H5P_DEFAULT, |
| 5760 | 537 itmp) >= 0; |
| 5164 | 538 H5Dclose (data_hid); |
| 539 if (!retval) | |
| 540 { | |
| 541 H5Sclose (space_hid); | |
| 542 H5Gclose (group_hid); | |
| 543 return false; | |
| 544 } | |
| 545 | |
| 546 hid_t save_type_hid = H5T_NATIVE_DOUBLE; | |
| 547 | |
| 548 if (save_as_floats) | |
| 549 { | |
| 550 if (m.too_large_for_float ()) | |
| 551 { | |
| 552 warning ("save: some values too large to save as floats --"); | |
| 553 warning ("save: saving as doubles instead"); | |
| 554 } | |
| 555 else | |
| 556 save_type_hid = H5T_NATIVE_FLOAT; | |
| 557 } | |
| 558 #if HAVE_HDF5_INT2FLOAT_CONVERSIONS | |
| 559 // hdf5 currently doesn't support float/integer conversions | |
| 560 else | |
| 561 { | |
| 562 double max_val, min_val; | |
| 563 | |
| 564 if (m.all_integers (max_val, min_val)) | |
| 565 save_type_hid | |
| 566 = save_type_to_hdf5 (get_save_type (max_val, min_val)); | |
| 567 } | |
| 568 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */ | |
| 569 | |
| 570 data_hid = H5Dcreate (group_hid, "data", save_type_hid, space_hid, | |
| 571 H5P_DEFAULT); | |
| 572 if (data_hid < 0) | |
| 573 { | |
| 574 H5Sclose (space_hid); | |
| 575 H5Gclose (group_hid); | |
| 576 return false; | |
| 577 } | |
| 578 | |
| 579 double * dtmp = m.xdata (); | |
| 580 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, | |
| 5760 | 581 H5P_DEFAULT, dtmp) >= 0; |
| 5164 | 582 H5Dclose (data_hid); |
| 583 H5Sclose (space_hid); | |
| 584 H5Gclose (group_hid); | |
| 585 | |
| 586 return retval; | |
| 587 } | |
| 588 | |
| 589 bool | |
| 590 octave_sparse_matrix::load_hdf5 (hid_t loc_id, const char *name, | |
| 5760 | 591 bool /* have_h5giterate_bug */) |
| 5164 | 592 { |
| 5351 | 593 octave_idx_type nr, nc, nz; |
| 5164 | 594 hid_t group_hid, data_hid, space_hid; |
| 595 hsize_t rank; | |
| 596 | |
| 597 dim_vector dv; | |
| 598 int empty = load_hdf5_empty (loc_id, name, dv); | |
| 599 if (empty > 0) | |
| 600 matrix.resize(dv); | |
| 601 if (empty) | |
| 602 return (empty > 0); | |
| 603 | |
| 604 group_hid = H5Gopen (loc_id, name); | |
| 5760 | 605 if (group_hid < 0) return false; |
| 5164 | 606 |
| 607 data_hid = H5Dopen (group_hid, "nr"); | |
| 608 space_hid = H5Dget_space (data_hid); | |
| 609 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 610 | |
| 611 if (rank != 0) | |
| 612 { | |
| 613 H5Dclose (data_hid); | |
| 614 H5Gclose (group_hid); | |
| 615 return false; | |
| 616 } | |
| 617 | |
| 5351 | 618 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 619 H5P_DEFAULT, &nr) < 0) |
| 5164 | 620 { |
| 621 H5Dclose (data_hid); | |
| 622 H5Gclose (group_hid); | |
| 623 return false; | |
| 624 } | |
| 625 | |
| 626 H5Dclose (data_hid); | |
| 627 | |
| 628 data_hid = H5Dopen (group_hid, "nc"); | |
| 629 space_hid = H5Dget_space (data_hid); | |
| 630 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 631 | |
| 632 if (rank != 0) | |
| 633 { | |
| 634 H5Dclose (data_hid); | |
| 635 H5Gclose (group_hid); | |
| 636 return false; | |
| 637 } | |
| 638 | |
| 5351 | 639 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 640 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 | |
| 5351 | 660 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 661 H5P_DEFAULT, &nz) < 0) |
| 5164 | 662 { |
| 663 H5Dclose (data_hid); | |
| 664 H5Gclose (group_hid); | |
| 665 return false; | |
| 666 } | |
| 667 | |
| 668 H5Dclose (data_hid); | |
| 669 | |
| 5275 | 670 SparseMatrix m (static_cast<octave_idx_type> (nr), |
| 671 static_cast<octave_idx_type> (nc), | |
| 672 static_cast<octave_idx_type> (nz)); | |
| 5164 | 673 |
| 674 data_hid = H5Dopen (group_hid, "cidx"); | |
| 675 space_hid = H5Dget_space (data_hid); | |
| 676 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 677 | |
| 678 if (rank != 2) | |
| 679 { | |
| 680 H5Sclose (space_hid); | |
| 681 H5Dclose (data_hid); | |
| 682 H5Gclose (group_hid); | |
| 683 return false; | |
| 684 } | |
| 685 | |
| 686 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank); | |
| 687 OCTAVE_LOCAL_BUFFER (hsize_t, maxdims, rank); | |
| 688 | |
| 689 H5Sget_simple_extent_dims (space_hid, hdims, maxdims); | |
| 690 | |
| 5322 | 691 if (static_cast<int> (hdims[0]) != nc + 1 || |
| 692 static_cast<int> (hdims[1]) != 1) | |
| 5164 | 693 { |
| 694 H5Sclose (space_hid); | |
| 695 H5Dclose (data_hid); | |
| 696 H5Gclose (group_hid); | |
| 697 return false; | |
| 698 } | |
| 699 | |
| 5351 | 700 octave_idx_type *itmp = m.xcidx (); |
| 701 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, | |
| 5760 | 702 H5P_DEFAULT, itmp) < 0) |
| 5164 | 703 { |
| 704 H5Sclose (space_hid); | |
| 705 H5Dclose (data_hid); | |
| 706 H5Gclose (group_hid); | |
| 707 return false; | |
| 708 } | |
| 709 | |
| 710 H5Sclose (space_hid); | |
| 711 H5Dclose (data_hid); | |
| 712 | |
| 713 data_hid = H5Dopen (group_hid, "ridx"); | |
| 714 space_hid = H5Dget_space (data_hid); | |
| 715 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 716 | |
| 717 if (rank != 2) | |
| 718 { | |
| 719 H5Sclose (space_hid); | |
| 720 H5Dclose (data_hid); | |
| 721 H5Gclose (group_hid); | |
| 722 return false; | |
| 723 } | |
| 724 | |
| 725 H5Sget_simple_extent_dims (space_hid, hdims, maxdims); | |
| 726 | |
| 5322 | 727 if (static_cast<int> (hdims[0]) != nz || static_cast<int> (hdims[1]) != 1) |
| 5164 | 728 { |
| 729 H5Sclose (space_hid); | |
| 730 H5Dclose (data_hid); | |
| 731 H5Gclose (group_hid); | |
| 732 return false; | |
| 733 } | |
| 734 | |
| 735 itmp = m.xridx (); | |
| 5351 | 736 if (H5Dread (data_hid, H5T_NATIVE_IDX, H5S_ALL, H5S_ALL, |
| 5760 | 737 H5P_DEFAULT, itmp) < 0) |
| 5164 | 738 { |
| 739 H5Sclose (space_hid); | |
| 740 H5Dclose (data_hid); | |
| 741 H5Gclose (group_hid); | |
| 742 return false; | |
| 743 } | |
| 744 | |
| 745 H5Sclose (space_hid); | |
| 746 H5Dclose (data_hid); | |
| 747 | |
| 748 data_hid = H5Dopen (group_hid, "data"); | |
| 749 space_hid = H5Dget_space (data_hid); | |
| 750 rank = H5Sget_simple_extent_ndims (space_hid); | |
| 751 | |
| 752 if (rank != 2) | |
| 753 { | |
| 754 H5Sclose (space_hid); | |
| 755 H5Dclose (data_hid); | |
| 756 H5Gclose (group_hid); | |
| 757 return false; | |
| 758 } | |
| 759 | |
| 760 H5Sget_simple_extent_dims (space_hid, hdims, maxdims); | |
| 761 | |
| 5322 | 762 if (static_cast<int> (hdims[0]) != nz || static_cast<int> (hdims[1]) != 1) |
| 5164 | 763 { |
| 764 H5Sclose (space_hid); | |
| 765 H5Dclose (data_hid); | |
| 766 H5Gclose (group_hid); | |
| 767 return false; | |
| 768 } | |
| 769 | |
| 770 double *dtmp = m.xdata (); | |
| 771 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, | |
| 5760 | 772 H5P_DEFAULT, dtmp) < 0) |
| 5164 | 773 { |
| 774 H5Sclose (space_hid); | |
| 775 H5Dclose (data_hid); | |
| 776 H5Gclose (group_hid); | |
| 777 return false; | |
| 778 } | |
| 779 | |
| 780 H5Sclose (space_hid); | |
| 781 H5Dclose (data_hid); | |
| 782 H5Gclose (group_hid); | |
| 783 | |
| 784 matrix = m; | |
| 785 | |
| 786 return true; | |
| 787 } | |
| 5900 | 788 |
| 5164 | 789 #endif |
| 790 | |
| 5900 | 791 mxArray * |
| 792 octave_sparse_matrix::as_mxArray (void) const | |
| 793 { | |
| 6686 | 794 mwSize nz = nzmax(); |
| 795 mwSize nr = rows(); | |
| 796 mwSize nc = columns(); | |
| 5903 | 797 mxArray *retval = new mxArray (mxDOUBLE_CLASS, nr, nc, nz, mxREAL); |
| 798 double *pr = static_cast<double *> (retval->get_data ()); | |
| 6686 | 799 mwIndex *ir = retval->get_ir(); |
| 800 mwIndex *jc = retval->get_jc(); | |
| 5903 | 801 |
| 6686 | 802 for (mwIndex i = 0; i < nz; i++) |
| 5903 | 803 { |
| 804 pr[i] = matrix.data(i); | |
| 805 ir[i] = matrix.ridx(i); | |
| 806 } | |
| 807 | |
| 6686 | 808 for (mwIndex i = 0; i < nc + 1; i++) |
| 5903 | 809 jc[i] = matrix.cidx(i); |
| 810 | |
| 811 return retval; | |
| 5900 | 812 } |
| 813 | |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
814 static bool |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
815 any_element_less_than (const SparseMatrix& a, double val) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
816 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
817 octave_idx_type len = a.nnz (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
818 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
819 if (val > 0. && len != a.numel ()) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
820 return true; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
821 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
822 for (octave_idx_type i = 0; i < len; i++) |
|
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 OCTAVE_QUIT; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
825 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
826 if (a.data(i) < val) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
827 return true; |
|
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 return false; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
831 } |
|
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 static bool |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
834 any_element_greater_than (const SparseMatrix& a, double val) |
|
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 octave_idx_type len = a.nnz (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
837 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
838 if (val < 0. && len != a.numel ()) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
839 return true; |
|
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 for (octave_idx_type i = 0; i < len; i++) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
842 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
843 OCTAVE_QUIT; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
844 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
845 if (a.data(i) > val) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
846 return true; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
847 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
848 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
849 return false; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
850 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
851 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
852 #define SPARSE_MAPPER(MAP, AMAP, FCN) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
853 octave_value \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
854 octave_sparse_matrix::MAP (void) const \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
855 { \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
856 static AMAP dmap = FCN; \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
857 return matrix.map (dmap); \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
858 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
859 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
860 #define CD_SPARSE_MAPPER(MAP, RFCN, CFCN, L1, L2) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
861 octave_value \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
862 octave_sparse_matrix::MAP (void) const \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
863 { \ |
|
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
|
864 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
|
865 static SparseMatrix::cmapper cmap = CFCN; \ |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
866 \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
867 return (any_element_less_than (matrix, L1) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
868 ? octave_value (matrix.map (cmap)) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
869 : (any_element_greater_than (matrix, L2) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
870 ? octave_value (matrix.map (cmap)) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
871 : octave_value (matrix.map (dmap)))); \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
872 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
873 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
874 static double |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
875 xconj (double x) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
876 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
877 return x; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
878 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
879 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
880 SPARSE_MAPPER (erf, SparseMatrix::dmapper, ::erf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
881 SPARSE_MAPPER (erfc, SparseMatrix::dmapper, ::erfc) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
882 SPARSE_MAPPER (gamma, SparseMatrix::dmapper, xgamma) |
|
7601
8a939b217863
Treat negative values to lgamma and beta correctly
David Bateman <dbateman@free.fr>
parents:
7503
diff
changeset
|
883 CD_SPARSE_MAPPER (lgamma, xlgamma, xlgamma, 0.0, octave_Inf) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
884 SPARSE_MAPPER (abs, SparseMatrix::dmapper, ::fabs) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
885 SPARSE_MAPPER (acos, SparseMatrix::dmapper, ::acos) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
886 CD_SPARSE_MAPPER (acosh, ::acosh, ::acosh, 1.0, octave_Inf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
887 SPARSE_MAPPER (angle, SparseMatrix::dmapper, ::arg) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
888 SPARSE_MAPPER (arg, SparseMatrix::dmapper, ::arg) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
889 CD_SPARSE_MAPPER (asin, ::asin, ::asin, -1.0, 1.0) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
890 SPARSE_MAPPER (asinh, SparseMatrix::dmapper, ::asinh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
891 SPARSE_MAPPER (atan, SparseMatrix::dmapper, ::atan) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
892 CD_SPARSE_MAPPER (atanh, ::atanh, ::atanh, -1.0, 1.0) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
893 SPARSE_MAPPER (ceil, SparseMatrix::dmapper, ::ceil) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
894 SPARSE_MAPPER (conj, SparseMatrix::dmapper, xconj) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
895 SPARSE_MAPPER (cos, SparseMatrix::dmapper, ::cos) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
896 SPARSE_MAPPER (cosh, SparseMatrix::dmapper, ::cosh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
897 SPARSE_MAPPER (exp, SparseMatrix::dmapper, ::exp) |
|
7638
2df457529cfa
implement expm1 and log1p functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7636
diff
changeset
|
898 SPARSE_MAPPER (expm1, SparseMatrix::dmapper, ::expm1) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
899 SPARSE_MAPPER (fix, SparseMatrix::dmapper, ::fix) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
900 SPARSE_MAPPER (floor, SparseMatrix::dmapper, ::floor) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
901 SPARSE_MAPPER (imag, SparseMatrix::dmapper, ::imag) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
902 CD_SPARSE_MAPPER (log, ::log, std::log, 0.0, octave_Inf) |
| 7740 | 903 CD_SPARSE_MAPPER (log2, xlog2, xlog2, 0.0, octave_Inf) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
904 CD_SPARSE_MAPPER (log10, ::log10, std::log10, 0.0, octave_Inf) |
|
7638
2df457529cfa
implement expm1 and log1p functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7636
diff
changeset
|
905 CD_SPARSE_MAPPER (log1p, ::log1p, ::log1p, 0.0, octave_Inf) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
906 SPARSE_MAPPER (real, SparseMatrix::dmapper, ::real) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
907 SPARSE_MAPPER (round, SparseMatrix::dmapper, xround) |
|
7636
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7601
diff
changeset
|
908 SPARSE_MAPPER (roundb, SparseMatrix::dmapper, xroundb) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
909 SPARSE_MAPPER (signum, SparseMatrix::dmapper, ::signum) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
910 SPARSE_MAPPER (sin, SparseMatrix::dmapper, ::sin) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
911 SPARSE_MAPPER (sinh, SparseMatrix::dmapper, ::sinh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
912 CD_SPARSE_MAPPER (sqrt, ::sqrt, std::sqrt, 0.0, octave_Inf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
913 SPARSE_MAPPER (tan, SparseMatrix::dmapper, ::tan) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
914 SPARSE_MAPPER (tanh, SparseMatrix::dmapper, ::tanh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
915 SPARSE_MAPPER (finite, SparseMatrix::bmapper, xfinite) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
916 SPARSE_MAPPER (isinf, SparseMatrix::bmapper, xisinf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
917 SPARSE_MAPPER (isna, SparseMatrix::bmapper, octave_is_NA) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
918 SPARSE_MAPPER (isnan, SparseMatrix::bmapper, xisnan) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7193
diff
changeset
|
919 |
| 5164 | 920 /* |
| 921 ;;; Local Variables: *** | |
| 922 ;;; mode: C++ *** | |
| 923 ;;; End: *** | |
| 924 */ |