Mercurial > hg > octave-lyh
annotate src/ov-re-mat.cc @ 7638:2df457529cfa
implement expm1 and log1p functions
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Tue, 25 Mar 2008 19:47:21 -0400 |
| parents | 99c410f7f0b0 |
| children | 39930366b709 |
| rev | line source |
|---|---|
| 2376 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, |
| 4 2006, 2007 John W. Eaton | |
| 2376 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 2376 | 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/>. | |
| 2376 | 21 |
| 22 */ | |
| 23 | |
| 24 #ifdef HAVE_CONFIG_H | |
| 25 #include <config.h> | |
| 26 #endif | |
| 27 | |
| 4100 | 28 #include <climits> |
| 29 | |
| 3503 | 30 #include <iostream> |
| 4726 | 31 #include <vector> |
| 2901 | 32 |
| 4944 | 33 #include "data-conv.h" |
| 2376 | 34 #include "lo-ieee.h" |
| 35 #include "lo-utils.h" | |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
36 #include "lo-specfun.h" |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
37 #include "lo-mappers.h" |
| 4944 | 38 #include "mach-info.h" |
| 2376 | 39 #include "mx-base.h" |
| 4153 | 40 #include "quit.h" |
| 2376 | 41 |
| 4901 | 42 #include "defun.h" |
| 2376 | 43 #include "gripes.h" |
| 44 #include "oct-obj.h" | |
| 2979 | 45 #include "oct-lvalue.h" |
| 4944 | 46 #include "oct-stream.h" |
| 2410 | 47 #include "ops.h" |
| 3219 | 48 #include "ov-base.h" |
| 49 #include "ov-base-mat.h" | |
| 50 #include "ov-base-mat.cc" | |
| 2410 | 51 #include "ov-scalar.h" |
| 2376 | 52 #include "ov-re-mat.h" |
| 7004 | 53 #include "ov-re-sparse.h" |
| 4901 | 54 #include "ov-type-conv.h" |
| 2376 | 55 #include "pr-output.h" |
| 2948 | 56 #include "variables.h" |
| 2376 | 57 |
| 4687 | 58 #include "byte-swap.h" |
| 59 #include "ls-oct-ascii.h" | |
| 60 #include "ls-utils.h" | |
| 4805 | 61 #include "ls-hdf5.h" |
| 4687 | 62 |
| 4100 | 63 #if ! defined (UCHAR_MAX) |
| 64 #define UCHAR_MAX 255 | |
| 65 #endif | |
| 66 | |
| 4513 | 67 template class octave_base_matrix<NDArray>; |
| 2376 | 68 |
| 3219 | 69 DEFINE_OCTAVE_ALLOCATOR (octave_matrix); |
| 2477 | 70 |
| 4612 | 71 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_matrix, "matrix", "double"); |
| 2376 | 72 |
| 5759 | 73 octave_base_value * |
| 2410 | 74 octave_matrix::try_narrowing_conversion (void) |
| 75 { | |
| 5759 | 76 octave_base_value *retval = 0; |
| 2410 | 77 |
| 4513 | 78 if (matrix.nelem () == 1) |
| 79 retval = new octave_scalar (matrix (0)); | |
| 2410 | 80 |
| 81 return retval; | |
| 82 } | |
| 83 | |
| 2376 | 84 bool |
| 85 octave_matrix::valid_as_scalar_index (void) const | |
| 86 { | |
| 5775 | 87 // FIXME |
| 2376 | 88 return false; |
| 89 } | |
| 90 | |
| 91 double | |
| 92 octave_matrix::double_value (bool) const | |
| 93 { | |
| 4102 | 94 double retval = lo_ieee_nan_value (); |
| 2376 | 95 |
| 4645 | 96 if (numel () > 0) |
| 4455 | 97 { |
| 5781 | 98 gripe_implicit_conversion ("Octave:array-as-scalar", |
| 99 "real matrix", "real scalar"); | |
| 4455 | 100 |
| 101 retval = matrix (0, 0); | |
| 102 } | |
| 2376 | 103 else |
| 104 gripe_invalid_conversion ("real matrix", "real scalar"); | |
| 105 | |
| 106 return retval; | |
| 107 } | |
| 108 | |
| 5775 | 109 // FIXME |
| 4513 | 110 |
| 111 Matrix | |
| 112 octave_matrix::matrix_value (bool) const | |
| 113 { | |
| 114 return matrix.matrix_value (); | |
| 115 } | |
| 116 | |
| 2376 | 117 Complex |
| 118 octave_matrix::complex_value (bool) const | |
| 119 { | |
| 4102 | 120 double tmp = lo_ieee_nan_value (); |
| 121 | |
| 122 Complex retval (tmp, tmp); | |
| 2376 | 123 |
| 4455 | 124 if (rows () > 0 && columns () > 0) |
| 125 { | |
| 5781 | 126 gripe_implicit_conversion ("Octave:array-as-scalar", |
| 127 "real matrix", "complex scalar"); | |
| 4455 | 128 |
| 129 retval = matrix (0, 0); | |
| 130 } | |
| 2376 | 131 else |
| 132 gripe_invalid_conversion ("real matrix", "complex scalar"); | |
| 133 | |
| 134 return retval; | |
| 135 } | |
| 136 | |
| 5775 | 137 // FIXME |
| 4513 | 138 |
| 139 ComplexMatrix | |
| 140 octave_matrix::complex_matrix_value (bool) const | |
| 141 { | |
| 142 return ComplexMatrix (matrix.matrix_value ()); | |
| 143 } | |
| 144 | |
| 4699 | 145 ComplexNDArray |
| 146 octave_matrix::complex_array_value (bool) const | |
| 147 { | |
| 148 return ComplexNDArray (matrix); | |
| 149 } | |
| 150 | |
| 5898 | 151 boolNDArray |
| 5943 | 152 octave_matrix::bool_array_value (bool warn) const |
| 5898 | 153 { |
| 5943 | 154 if (warn && matrix.any_element_not_one_or_zero ()) |
| 155 gripe_logical_conversion (); | |
| 156 | |
| 5898 | 157 return boolNDArray (matrix); |
| 158 } | |
| 159 | |
| 4758 | 160 charNDArray |
| 161 octave_matrix::char_array_value (bool) const | |
| 162 { | |
| 163 charNDArray retval (dims ()); | |
| 164 | |
| 5275 | 165 octave_idx_type nel = numel (); |
| 4758 | 166 |
| 5275 | 167 for (octave_idx_type i = 0; i < nel; i++) |
| 4758 | 168 retval.elem (i) = static_cast<char>(matrix.elem (i)); |
| 169 | |
| 170 return retval; | |
| 171 } | |
| 172 | |
| 5164 | 173 SparseMatrix |
| 174 octave_matrix::sparse_matrix_value (bool) const | |
| 175 { | |
| 176 return SparseMatrix (matrix.matrix_value ()); | |
| 177 } | |
| 178 | |
| 179 SparseComplexMatrix | |
| 180 octave_matrix::sparse_complex_matrix_value (bool) const | |
| 181 { | |
| 5775 | 182 // FIXME Need a SparseComplexMatrix (Matrix) constructor to make |
| 5164 | 183 // this function more efficient. Then this should become |
| 184 // return SparseComplexMatrix (matrix.matrix_value ()); | |
| 185 return SparseComplexMatrix (sparse_matrix_value ()); | |
| 186 } | |
| 187 | |
| 4645 | 188 streamoff_array |
| 189 octave_matrix::streamoff_array_value (void) const | |
| 190 { | |
| 191 streamoff_array retval (dims ()); | |
| 192 | |
| 5275 | 193 octave_idx_type nel = numel (); |
| 4645 | 194 |
| 5275 | 195 for (octave_idx_type i = 0; i < nel; i++) |
| 4645 | 196 { |
| 197 double d = matrix(i); | |
| 198 | |
| 199 if (D_NINT (d) == d) | |
| 200 retval(i) = std::streamoff (static_cast<long> (d)); | |
| 201 else | |
| 202 { | |
| 203 error ("conversion to streamoff_array value failed"); | |
| 204 break; | |
| 205 } | |
| 206 } | |
| 207 | |
| 208 return retval; | |
| 209 } | |
| 210 | |
| 2376 | 211 octave_value |
| 5279 | 212 octave_matrix::convert_to_str_internal (bool, bool, char type) const |
| 2376 | 213 { |
| 214 octave_value retval; | |
| 4844 | 215 dim_vector dv = dims (); |
| 5862 | 216 octave_idx_type nel = dv.numel (); |
| 217 | |
| 218 charNDArray chm (dv); | |
| 2376 | 219 |
| 5862 | 220 bool warned = false; |
| 221 | |
| 222 for (octave_idx_type i = 0; i < nel; i++) | |
| 2376 | 223 { |
| 5862 | 224 OCTAVE_QUIT; |
| 225 | |
| 226 double d = matrix (i); | |
| 4844 | 227 |
| 5862 | 228 if (xisnan (d)) |
| 229 { | |
| 230 ::error ("invalid conversion from NaN to character"); | |
| 231 return retval; | |
| 232 } | |
| 233 else | |
| 4844 | 234 { |
| 5862 | 235 int ival = NINT (d); |
| 4844 | 236 |
| 5862 | 237 if (ival < 0 || ival > UCHAR_MAX) |
| 238 { | |
| 239 // FIXME -- is there something | |
| 240 // better we could do? | |
| 2376 | 241 |
| 5862 | 242 ival = 0; |
| 243 | |
| 244 if (! warned) | |
| 245 { | |
| 246 ::warning ("range error for conversion to character value"); | |
| 247 warned = true; | |
| 248 } | |
| 4844 | 249 } |
| 2376 | 250 |
| 5862 | 251 chm (i) = static_cast<char> (ival); |
| 252 } | |
| 253 } | |
| 2376 | 254 |
| 5862 | 255 retval = octave_value (chm, true, type); |
| 2376 | 256 |
| 257 return retval; | |
| 258 } | |
| 259 | |
| 4687 | 260 bool |
| 6974 | 261 octave_matrix::save_ascii (std::ostream& os) |
| 4687 | 262 { |
| 263 dim_vector d = dims (); | |
| 5958 | 264 |
| 4687 | 265 if (d.length () > 2) |
| 266 { | |
| 267 NDArray tmp = array_value (); | |
| 268 | |
| 269 os << "# ndims: " << d.length () << "\n"; | |
| 270 | |
| 271 for (int i=0; i < d.length (); i++) | |
| 272 os << " " << d (i); | |
| 273 | |
| 274 os << "\n" << tmp; | |
| 275 } | |
| 276 else | |
| 277 { | |
| 278 // Keep this case, rather than use generic code above for backward | |
| 279 // compatiability. Makes load_ascii much more complex!! | |
| 280 os << "# rows: " << rows () << "\n" | |
| 281 << "# columns: " << columns () << "\n"; | |
| 282 | |
| 5958 | 283 os << matrix_value (); |
| 4687 | 284 } |
| 285 | |
| 286 return true; | |
| 287 } | |
| 288 | |
| 289 bool | |
| 290 octave_matrix::load_ascii (std::istream& is) | |
| 291 { | |
| 292 bool success = true; | |
| 5099 | 293 |
| 294 string_vector keywords(2); | |
| 295 | |
| 296 keywords[0] = "ndims"; | |
| 297 keywords[1] = "rows"; | |
| 4687 | 298 |
| 5099 | 299 std::string kw; |
| 5275 | 300 octave_idx_type val = 0; |
| 5099 | 301 |
| 302 if (extract_keyword (is, keywords, kw, val, true)) | |
| 4687 | 303 { |
| 5099 | 304 if (kw == "ndims") |
| 4687 | 305 { |
| 5275 | 306 int mdims = static_cast<int> (val); |
| 4687 | 307 |
| 5099 | 308 if (mdims >= 0) |
| 4687 | 309 { |
| 5099 | 310 dim_vector dv; |
| 311 dv.resize (mdims); | |
| 4687 | 312 |
| 5099 | 313 for (int i = 0; i < mdims; i++) |
| 314 is >> dv(i); | |
| 4687 | 315 |
| 6717 | 316 if (is) |
| 317 { | |
| 318 NDArray tmp(dv); | |
| 319 | |
| 320 if (tmp.is_empty ()) | |
| 321 matrix = tmp; | |
| 322 else | |
| 323 { | |
| 324 is >> tmp; | |
| 5099 | 325 |
| 6717 | 326 if (is) |
| 327 matrix = tmp; | |
| 328 else | |
| 329 { | |
| 330 error ("load: failed to load matrix constant"); | |
| 331 success = false; | |
| 332 } | |
| 333 } | |
| 334 } | |
| 335 else | |
| 4687 | 336 { |
| 6717 | 337 error ("load: failed to read dimensions"); |
| 4687 | 338 success = false; |
| 339 } | |
| 340 } | |
| 341 else | |
| 5099 | 342 { |
| 6717 | 343 error ("load: failed to extract number of dimensions"); |
| 5099 | 344 success = false; |
| 345 } | |
| 4687 | 346 } |
| 5099 | 347 else if (kw == "rows") |
| 4687 | 348 { |
| 5275 | 349 octave_idx_type nr = val; |
| 350 octave_idx_type nc = 0; | |
| 5099 | 351 |
| 352 if (nr >= 0 && extract_keyword (is, "columns", nc) && nc >= 0) | |
| 353 { | |
| 354 if (nr > 0 && nc > 0) | |
| 355 { | |
| 356 Matrix tmp (nr, nc); | |
| 357 is >> tmp; | |
| 358 if (is) | |
| 359 matrix = tmp; | |
| 360 else | |
| 361 { | |
| 362 error ("load: failed to load matrix constant"); | |
| 363 success = false; | |
| 364 } | |
| 365 } | |
| 366 else if (nr == 0 || nc == 0) | |
| 367 matrix = Matrix (nr, nc); | |
| 368 else | |
| 369 panic_impossible (); | |
| 370 } | |
| 371 else | |
| 372 { | |
| 373 error ("load: failed to extract number of rows and columns"); | |
| 374 success = false; | |
| 375 } | |
| 4687 | 376 } |
| 5099 | 377 else |
| 378 panic_impossible (); | |
| 379 } | |
| 380 else | |
| 381 { | |
| 382 error ("load: failed to extract number of rows and columns"); | |
| 383 success = false; | |
| 4687 | 384 } |
| 385 | |
| 386 return success; | |
| 387 } | |
| 388 | |
| 389 bool | |
| 390 octave_matrix::save_binary (std::ostream& os, bool& save_as_floats) | |
| 391 { | |
| 392 | |
| 393 dim_vector d = dims (); | |
| 394 if (d.length() < 1) | |
| 395 return false; | |
| 396 | |
| 397 // Use negative value for ndims to differentiate with old format!! | |
| 5828 | 398 int32_t tmp = - d.length(); |
| 5760 | 399 os.write (reinterpret_cast<char *> (&tmp), 4); |
| 5275 | 400 for (int i = 0; i < d.length (); i++) |
| 4687 | 401 { |
| 402 tmp = d(i); | |
| 5760 | 403 os.write (reinterpret_cast<char *> (&tmp), 4); |
| 4687 | 404 } |
| 405 | |
| 406 NDArray m = array_value (); | |
| 407 save_type st = LS_DOUBLE; | |
| 408 if (save_as_floats) | |
| 409 { | |
| 410 if (m.too_large_for_float ()) | |
| 411 { | |
| 412 warning ("save: some values too large to save as floats --"); | |
| 413 warning ("save: saving as doubles instead"); | |
| 414 } | |
| 415 else | |
| 416 st = LS_FLOAT; | |
| 417 } | |
| 5775 | 418 else if (d.numel () > 8192) // FIXME -- make this configurable. |
| 4687 | 419 { |
| 420 double max_val, min_val; | |
| 421 if (m.all_integers (max_val, min_val)) | |
| 422 st = get_save_type (max_val, min_val); | |
| 423 } | |
| 424 | |
| 425 const double *mtmp = m.data (); | |
| 426 write_doubles (os, mtmp, st, d.numel ()); | |
| 427 | |
| 428 return true; | |
| 429 } | |
| 430 | |
| 431 bool | |
| 432 octave_matrix::load_binary (std::istream& is, bool swap, | |
| 433 oct_mach_info::float_format fmt) | |
| 434 { | |
| 435 char tmp; | |
| 5828 | 436 int32_t mdims; |
| 5760 | 437 if (! is.read (reinterpret_cast<char *> (&mdims), 4)) |
| 4687 | 438 return false; |
| 439 if (swap) | |
| 4944 | 440 swap_bytes<4> (&mdims); |
| 4687 | 441 if (mdims < 0) |
| 442 { | |
| 443 mdims = - mdims; | |
| 5828 | 444 int32_t di; |
| 4687 | 445 dim_vector dv; |
| 446 dv.resize (mdims); | |
| 447 | |
| 448 for (int i = 0; i < mdims; i++) | |
| 449 { | |
| 5760 | 450 if (! is.read (reinterpret_cast<char *> (&di), 4)) |
| 4687 | 451 return false; |
| 452 if (swap) | |
| 4944 | 453 swap_bytes<4> (&di); |
| 4687 | 454 dv(i) = di; |
| 455 } | |
| 456 | |
| 5157 | 457 // Convert an array with a single dimension to be a row vector. |
| 458 // Octave should never write files like this, other software | |
| 459 // might. | |
| 460 | |
| 461 if (mdims == 1) | |
| 462 { | |
| 463 mdims = 2; | |
| 464 dv.resize (mdims); | |
| 465 dv(1) = dv(0); | |
| 466 dv(0) = 1; | |
| 467 } | |
| 468 | |
| 5760 | 469 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) |
| 4687 | 470 return false; |
| 471 | |
| 472 NDArray m(dv); | |
| 473 double *re = m.fortran_vec (); | |
| 5760 | 474 read_doubles (is, re, static_cast<save_type> (tmp), dv.numel (), swap, fmt); |
| 4687 | 475 if (error_state || ! is) |
| 476 return false; | |
| 477 matrix = m; | |
| 478 } | |
| 479 else | |
| 480 { | |
| 5828 | 481 int32_t nr, nc; |
| 4687 | 482 nr = mdims; |
| 5760 | 483 if (! is.read (reinterpret_cast<char *> (&nc), 4)) |
| 4687 | 484 return false; |
| 485 if (swap) | |
| 4944 | 486 swap_bytes<4> (&nc); |
| 5760 | 487 if (! is.read (reinterpret_cast<char *> (&tmp), 1)) |
| 4687 | 488 return false; |
| 489 Matrix m (nr, nc); | |
| 490 double *re = m.fortran_vec (); | |
| 5275 | 491 octave_idx_type len = nr * nc; |
| 5760 | 492 read_doubles (is, re, static_cast<save_type> (tmp), len, swap, fmt); |
| 4687 | 493 if (error_state || ! is) |
| 494 return false; | |
| 495 matrix = m; | |
| 496 } | |
| 497 return true; | |
| 498 } | |
| 499 | |
| 500 #if defined (HAVE_HDF5) | |
| 4944 | 501 |
| 4687 | 502 bool |
| 503 octave_matrix::save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) | |
| 504 { | |
| 4837 | 505 dim_vector dv = dims (); |
| 506 int empty = save_hdf5_empty (loc_id, name, dv); | |
| 507 if (empty) | |
| 4805 | 508 return (empty > 0); |
| 509 | |
| 4837 | 510 int rank = dv.length (); |
| 4687 | 511 hid_t space_hid = -1, data_hid = -1; |
| 512 bool retval = true; | |
| 513 NDArray m = array_value (); | |
| 514 | |
| 4805 | 515 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank); |
| 516 | |
| 4687 | 517 // Octave uses column-major, while HDF5 uses row-major ordering |
| 4805 | 518 for (int i = 0; i < rank; i++) |
| 4837 | 519 hdims[i] = dv (rank-i-1); |
| 4805 | 520 |
| 4815 | 521 space_hid = H5Screate_simple (rank, hdims, 0); |
| 4687 | 522 |
| 523 if (space_hid < 0) return false; | |
| 524 | |
| 525 hid_t save_type_hid = H5T_NATIVE_DOUBLE; | |
| 526 | |
| 527 if (save_as_floats) | |
| 528 { | |
| 529 if (m.too_large_for_float ()) | |
| 530 { | |
| 531 warning ("save: some values too large to save as floats --"); | |
| 532 warning ("save: saving as doubles instead"); | |
| 533 } | |
| 534 else | |
| 535 save_type_hid = H5T_NATIVE_FLOAT; | |
| 536 } | |
| 537 #if HAVE_HDF5_INT2FLOAT_CONVERSIONS | |
| 538 // hdf5 currently doesn't support float/integer conversions | |
| 539 else | |
| 540 { | |
| 541 double max_val, min_val; | |
| 542 | |
| 543 if (m.all_integers (max_val, min_val)) | |
| 544 save_type_hid | |
| 545 = save_type_to_hdf5 (get_save_type (max_val, min_val)); | |
| 546 } | |
| 547 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */ | |
| 548 | |
| 549 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid, | |
| 550 H5P_DEFAULT); | |
| 551 if (data_hid < 0) | |
| 552 { | |
| 553 H5Sclose (space_hid); | |
| 554 return false; | |
| 555 } | |
| 556 | |
| 557 double *mtmp = m.fortran_vec (); | |
| 558 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, | |
| 4815 | 559 H5P_DEFAULT, mtmp) >= 0; |
| 4687 | 560 |
| 561 H5Dclose (data_hid); | |
| 562 H5Sclose (space_hid); | |
| 4837 | 563 |
| 4687 | 564 return retval; |
| 565 } | |
| 566 | |
| 567 bool | |
| 568 octave_matrix::load_hdf5 (hid_t loc_id, const char *name, | |
| 569 bool /* have_h5giterate_bug */) | |
| 570 { | |
| 4837 | 571 bool retval = false; |
| 572 | |
| 4805 | 573 dim_vector dv; |
| 574 int empty = load_hdf5_empty (loc_id, name, dv); | |
| 575 if (empty > 0) | |
| 576 matrix.resize(dv); | |
| 4837 | 577 if (empty) |
| 4805 | 578 return (empty > 0); |
| 579 | |
| 4687 | 580 hid_t data_hid = H5Dopen (loc_id, name); |
| 581 hid_t space_id = H5Dget_space (data_hid); | |
| 582 | |
| 583 hsize_t rank = H5Sget_simple_extent_ndims (space_id); | |
| 584 | |
| 585 if (rank < 1) | |
| 586 { | |
| 587 H5Sclose (space_id); | |
| 588 H5Dclose (data_hid); | |
| 589 return false; | |
| 590 } | |
| 591 | |
| 592 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank); | |
| 593 OCTAVE_LOCAL_BUFFER (hsize_t, maxdims, rank); | |
| 594 | |
| 595 H5Sget_simple_extent_dims (space_id, hdims, maxdims); | |
| 596 | |
| 597 // Octave uses column-major, while HDF5 uses row-major ordering | |
| 598 if (rank == 1) | |
| 599 { | |
| 600 dv.resize (2); | |
| 601 dv(0) = 1; | |
| 602 dv(1) = hdims[0]; | |
| 603 } | |
| 604 else | |
| 605 { | |
| 606 dv.resize (rank); | |
| 4815 | 607 for (hsize_t i = 0, j = rank - 1; i < rank; i++, j--) |
| 4687 | 608 dv(j) = hdims[i]; |
| 609 } | |
| 610 | |
| 611 NDArray m (dv); | |
| 612 double *re = m.fortran_vec (); | |
| 613 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, | |
| 4815 | 614 H5P_DEFAULT, re) >= 0) |
| 4687 | 615 { |
| 616 retval = true; | |
| 617 matrix = m; | |
| 618 } | |
| 619 | |
| 620 H5Sclose (space_id); | |
| 621 H5Dclose (data_hid); | |
| 4837 | 622 |
| 4687 | 623 return retval; |
| 624 } | |
| 4944 | 625 |
| 4687 | 626 #endif |
| 627 | |
| 4643 | 628 void |
| 629 octave_matrix::print_raw (std::ostream& os, | |
| 630 bool pr_as_read_syntax) const | |
| 631 { | |
| 632 octave_print_internal (os, matrix, pr_as_read_syntax, | |
| 633 current_print_indent_level ()); | |
| 634 } | |
| 635 | |
| 5900 | 636 mxArray * |
| 637 octave_matrix::as_mxArray (void) const | |
| 638 { | |
| 639 mxArray *retval = new mxArray (mxDOUBLE_CLASS, dims (), mxREAL); | |
| 640 | |
| 641 double *pr = static_cast<double *> (retval->get_data ()); | |
| 642 | |
| 6686 | 643 mwSize nel = numel (); |
| 5900 | 644 |
| 645 const double *p = matrix.data (); | |
| 646 | |
| 6686 | 647 for (mwIndex i = 0; i < nel; i++) |
| 5900 | 648 pr[i] = p[i]; |
| 649 | |
| 650 return retval; | |
| 651 } | |
| 652 | |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
653 static bool |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
654 any_element_less_than (const NDArray& a, double val) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
655 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
656 octave_idx_type len = a.length (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
657 const double *m = a.fortran_vec (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
658 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
659 for (octave_idx_type i = 0; i < len; i++) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
660 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
661 OCTAVE_QUIT; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
662 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
663 if (m[i] < val) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
664 return true; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
665 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
666 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
667 return false; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
668 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
669 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
670 static bool |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
671 any_element_greater_than (const NDArray& a, double val) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
672 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
673 octave_idx_type len = a.length (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
674 const double *m = a.fortran_vec (); |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
675 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
676 for (octave_idx_type i = 0; i < len; i++) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
677 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
678 OCTAVE_QUIT; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
679 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
680 if (m[i] > val) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
681 return true; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
682 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
683 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
684 return false; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
685 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
686 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
687 #define ARRAY_MAPPER(MAP, AMAP, FCN) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
688 octave_value \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
689 octave_matrix::MAP (void) const \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
690 { \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
691 static AMAP dmap = FCN; \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
692 return matrix.map (dmap); \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
693 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
694 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
695 #define CD_ARRAY_MAPPER(MAP, RFCN, CFCN, L1, L2) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
696 octave_value \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
697 octave_matrix::MAP (void) const \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
698 { \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
699 static NDArray::dmapper dmap = RFCN; \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
700 static NDArray::cmapper cmap = CFCN; \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
701 \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
702 return (any_element_less_than (matrix, L1) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
703 ? octave_value (matrix.map (cmap)) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
704 : (any_element_greater_than (matrix, L2) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
705 ? octave_value (matrix.map (cmap)) \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
706 : octave_value (matrix.map (dmap)))); \ |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
707 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
708 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
709 static double |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
710 xconj (double x) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
711 { |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
712 return x; |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
713 } |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
714 |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
715 ARRAY_MAPPER (erf, NDArray::dmapper, ::erf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
716 ARRAY_MAPPER (erfc, NDArray::dmapper, ::erfc) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
717 ARRAY_MAPPER (gamma, NDArray::dmapper, xgamma) |
|
7601
8a939b217863
Treat negative values to lgamma and beta correctly
David Bateman <dbateman@free.fr>
parents:
7503
diff
changeset
|
718 CD_ARRAY_MAPPER (lgamma, xlgamma, xlgamma, 0.0, octave_Inf) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
719 ARRAY_MAPPER (abs, NDArray::dmapper, ::fabs) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
720 ARRAY_MAPPER (acos, NDArray::dmapper, ::acos) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
721 CD_ARRAY_MAPPER (acosh, ::acosh, ::acosh, 1.0, octave_Inf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
722 ARRAY_MAPPER (angle, NDArray::dmapper, ::arg) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
723 ARRAY_MAPPER (arg, NDArray::dmapper, ::arg) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
724 CD_ARRAY_MAPPER (asin, ::asin, ::asin, -1.0, 1.0) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
725 ARRAY_MAPPER (asinh, NDArray::dmapper,::asinh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
726 ARRAY_MAPPER (atan, NDArray::dmapper, ::atan) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
727 CD_ARRAY_MAPPER (atanh, ::atanh, ::atanh, -1.0, 1.0) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
728 ARRAY_MAPPER (ceil, NDArray::dmapper, ::ceil) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
729 ARRAY_MAPPER (conj, NDArray::dmapper, xconj) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
730 ARRAY_MAPPER (cos, NDArray::dmapper, ::cos) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
731 ARRAY_MAPPER (cosh, NDArray::dmapper, ::cosh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
732 ARRAY_MAPPER (exp, NDArray::dmapper, ::exp) |
|
7638
2df457529cfa
implement expm1 and log1p functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7636
diff
changeset
|
733 ARRAY_MAPPER (expm1, NDArray::dmapper, ::expm1) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
734 ARRAY_MAPPER (fix, NDArray::dmapper, ::fix) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
735 ARRAY_MAPPER (floor, NDArray::dmapper, ::floor) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
736 ARRAY_MAPPER (imag, NDArray::dmapper, ::imag) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
737 CD_ARRAY_MAPPER (log, ::log, std::log, 0.0, octave_Inf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
738 CD_ARRAY_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
|
739 CD_ARRAY_MAPPER (log1p, ::log1p, ::log1p, -1.0, octave_Inf) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
740 ARRAY_MAPPER (real, NDArray::dmapper, ::real) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
741 ARRAY_MAPPER (round, NDArray::dmapper, xround) |
|
7636
99c410f7f0b0
implement mapper function for banker's rounding
Jaroslav Hajek <highegg@gmail.com>
parents:
7601
diff
changeset
|
742 ARRAY_MAPPER (roundb, NDArray::dmapper, xroundb) |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
743 ARRAY_MAPPER (signum, NDArray::dmapper, ::signum) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
744 ARRAY_MAPPER (sin, NDArray::dmapper, ::sin) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
745 ARRAY_MAPPER (sinh, NDArray::dmapper, ::sinh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
746 CD_ARRAY_MAPPER (sqrt, ::sqrt, std::sqrt, 0.0, octave_Inf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
747 ARRAY_MAPPER (tan, NDArray::dmapper, ::tan) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
748 ARRAY_MAPPER (tanh, NDArray::dmapper, ::tanh) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
749 ARRAY_MAPPER (finite, NDArray::bmapper, xfinite) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
750 ARRAY_MAPPER (isinf, NDArray::bmapper, xisinf) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
751 ARRAY_MAPPER (isna, NDArray::bmapper, octave_is_NA) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
752 ARRAY_MAPPER (isnan, NDArray::bmapper, xisnan) |
|
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7017
diff
changeset
|
753 |
| 4901 | 754 DEFUN (double, args, , |
| 755 "-*- texinfo -*-\n\ | |
| 756 @deftypefn {Built-in Function} {} double (@var{x})\n\ | |
| 757 Convert @var{x} to double precision type.\n\ | |
| 758 @end deftypefn") | |
| 759 { | |
| 7004 | 760 // The OCTAVE_TYPE_CONV_BODY3 macro declares retval, so they go |
| 761 // inside their own scopes, and we don't declare retval here to | |
| 762 // avoid a shadowed declaration warning. | |
| 763 | |
| 764 if (args.length () == 1) | |
| 765 { | |
| 766 if (args(0).is_sparse_type ()) | |
| 767 { | |
| 768 OCTAVE_TYPE_CONV_BODY3 (double, octave_sparse_matrix, octave_scalar); | |
| 769 } | |
| 770 else | |
| 771 { | |
| 772 OCTAVE_TYPE_CONV_BODY3 (double, octave_matrix, octave_scalar); | |
| 773 } | |
| 774 } | |
| 775 else | |
| 776 print_usage (); | |
| 777 | |
| 778 return octave_value (); | |
| 4901 | 779 } |
| 780 | |
| 2376 | 781 /* |
| 782 ;;; Local Variables: *** | |
| 783 ;;; mode: C++ *** | |
| 784 ;;; End: *** | |
| 785 */ |