jwe/octave: libinterp/octave-value/ov-re-mat.cc annotate

annotate libinterp/octave-value/ov-re-mat.cc @ 20939:b17fda023ca6

maint: Use new C++ archetype in more files. Place input validation first in files. Move declaration of retval down in function to be closer to point of usage. Eliminate else clause after if () error. Use "return ovl()" where it makes sense. * find.cc, gammainc.cc, gcd.cc, getgrent.cc, getpwent.cc, givens.cc, graphics.cc, help.cc, hess.cc, hex2num.cc, input.cc, kron.cc, load-path.cc, load-save.cc, lookup.cc, mappers.cc, matrix_type.cc, mgorth.cc, nproc.cc, ordschur.cc, pager.cc, pinv.cc, pr-output.cc, profiler.cc, psi.cc, quad.cc, rcond.cc, regexp.cc, schur.cc, sighandlers.cc, sparse.cc, str2double.cc, strfind.cc, strfns.cc, sub2ind.cc, svd.cc, sylvester.cc, symtab.cc, syscalls.cc, sysdep.cc, time.cc, toplev.cc, tril.cc, tsearch.cc, typecast.cc, urlwrite.cc, utils.cc, variables.cc, __delaunayn__.cc, __eigs__.cc, __glpk__.cc, __magick_read__.cc, __osmesa_print__.cc, __voronoi__.cc, amd.cc, audiodevinfo.cc, audioread.cc, chol.cc, colamd.cc, dmperm.cc, fftw.cc, qr.cc, symbfact.cc, symrcm.cc, ov-bool-mat.cc, ov-cell.cc, ov-class.cc, ov-classdef.cc, ov-fcn-handle.cc, ov-fcn-inline.cc, ov-flt-re-mat.cc, ov-java.cc, ov-null-mat.cc, ov-oncleanup.cc, ov-re-mat.cc, ov-struct.cc, ov-typeinfo.cc, ov-usr-fcn.cc, ov.cc, octave.cc: Use new C++ archetype in more files.

author	Rik <rik@octave.org>
date	Fri, 18 Dec 2015 15:37:22 -0800
parents	1142cf6abc0d
children	48b2ad5ee801

rev	line source
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1 /*
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	2
19697 4197fc428c7d maint: Update copyright notices for 2015. John W. Eaton <jwe@octave.org> parents: 19598 diff changeset	3 Copyright (C) 1996-2015 John W. Eaton
11523 fd0a3ac60b0e update copyright notices John W. Eaton <jwe@octave.org> parents: 11129 diff changeset	4 Copyright (C) 2009-2010 VZLU Prague
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	5
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	6 This file is part of Octave.
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	7
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	8 Octave is free software; you can redistribute it and/or modify it
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	9 under the terms of the GNU General Public License as published by the
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7004 diff changeset	10 Free Software Foundation; either version 3 of the License, or (at your
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7004 diff changeset	11 option) any later version.
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	12
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	13 Octave is distributed in the hope that it will be useful, but WITHOUT
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	16 for more details.
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	17
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	18 You should have received a copy of the GNU General Public License
7016 93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7004 diff changeset	19 along with Octave; see the file COPYING. If not, see
93c65f2a5668 [project @ 2007-10-12 06:40:56 by jwe] jwe parents: 7004 diff changeset	20 <http://www.gnu.org/licenses/>.
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	21
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	22 */
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	23
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	24 #ifdef HAVE_CONFIG_H
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	25 #include <config.h>
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	26 #endif
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	27
3503 d14c483b3c12 [project @ 2000-02-01 04:06:07 by jwe] jwe parents: 3418 diff changeset	28 #include <iostream>
15215 9020dddc925a use std::numeric_limits for integer max and min values John W. Eaton <jwe@octave.org> parents: 15195 diff changeset	29 #include <limits>
4726 14dc2267c343 [project @ 2004-01-23 20:04:35 by jwe] jwe parents: 4699 diff changeset	30 #include <vector>
2901 e6d25bc478dd [project @ 1997-04-30 03:41:26 by jwe] jwe parents: 2847 diff changeset	31
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4901 diff changeset	32 #include "data-conv.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	33 #include "lo-ieee.h"
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	34 #include "lo-utils.h"
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7017 diff changeset	35 #include "lo-specfun.h"
8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7017 diff changeset	36 #include "lo-mappers.h"
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4901 diff changeset	37 #include "mach-info.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	38 #include "mx-base.h"
4153 6b96ce9f5743 [project @ 2002-11-06 20:38:49 by jwe] jwe parents: 4102 diff changeset	39 #include "quit.h"
8377 25bc2d31e1bf improve OCTAVE_LOCAL_BUFFER Jaroslav Hajek <highegg@gmail.com> parents: 8366 diff changeset	40 #include "oct-locbuf.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	41
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4844 diff changeset	42 #include "defun.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	43 #include "gripes.h"
15149 62a35ae7d6a2 use forward decls for mxArray in ov.h and ov-base.h John W. Eaton <jwe@octave.org> parents: 15057 diff changeset	44 #include "mxarray.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	45 #include "oct-obj.h"
2979 a3556d2adec9 [project @ 1997-05-15 22:35:37 by jwe] jwe parents: 2974 diff changeset	46 #include "oct-lvalue.h"
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	47 #include "oct-hdf5.h"
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4901 diff changeset	48 #include "oct-stream.h"
2410 367485171742 [project @ 1996-10-15 16:50:27 by jwe] jwe parents: 2407 diff changeset	49 #include "ops.h"
3219 30770ba4457a [project @ 1998-11-13 03:44:31 by jwe] jwe parents: 3109 diff changeset	50 #include "ov-base.h"
30770ba4457a [project @ 1998-11-13 03:44:31 by jwe] jwe parents: 3109 diff changeset	51 #include "ov-base-mat.h"
30770ba4457a [project @ 1998-11-13 03:44:31 by jwe] jwe parents: 3109 diff changeset	52 #include "ov-base-mat.cc"
2410 367485171742 [project @ 1996-10-15 16:50:27 by jwe] jwe parents: 2407 diff changeset	53 #include "ov-scalar.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	54 #include "ov-re-mat.h"
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	55 #include "ov-flt-re-mat.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	56 #include "ov-complex.h"
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	57 #include "ov-cx-mat.h"
7004 45d6cc5a0359 [project @ 2007-10-10 18:51:45 by jwe] jwe parents: 6974 diff changeset	58 #include "ov-re-sparse.h"
8399 c1bada868690 alow single/double conversion of diag & perm matrices Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	59 #include "ov-re-diag.h"
c1bada868690 alow single/double conversion of diag & perm matrices Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	60 #include "ov-cx-diag.h"
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	61 #include "ov-lazy-idx.h"
8399 c1bada868690 alow single/double conversion of diag & perm matrices Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	62 #include "ov-perm.h"
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4844 diff changeset	63 #include "ov-type-conv.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	64 #include "pr-output.h"
2948 56be458e237f [project @ 1997-05-09 13:37:35 by jwe] jwe parents: 2916 diff changeset	65 #include "variables.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	66
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	67 #include "byte-swap.h"
20447 c6224b4e7774 maint: Rename instances of LS_ASCII to LS_TEXT for clarity. Rik <rik@octave.org> parents: 20228 diff changeset	68 #include "ls-oct-text.h"
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	69 #include "ls-utils.h"
4805 b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	70 #include "ls-hdf5.h"
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	71
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	72 template class octave_base_matrix<NDArray>;
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	73
2477 3d905d3820a4 [project @ 1996-11-07 16:46:11 by jwe] jwe parents: 2466 diff changeset	74
4612 d44675070f1a [project @ 2003-11-14 19:49:56 by jwe] jwe parents: 4513 diff changeset	75 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_matrix, "matrix", "double");
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	76
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	77 static octave_base_value *
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	78 default_numeric_demotion_function (const octave_base_value& a)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	79 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	80 CAST_CONV_ARG (const octave_matrix&);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	81
8754 900a5bf52309 Fix invalid conversion error on implicit demotion of n-d arrays Jaroslav Hajek <highegg@gmail.com> parents: 8650 diff changeset	82 return new octave_float_matrix (v.float_array_value ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	83 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	84
8345 c777f3ce02d8 smarter conversion lookup Jaroslav Hajek <highegg@gmail.com> parents: 7922 diff changeset	85 octave_base_value::type_conv_info
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	86 octave_matrix::numeric_demotion_function (void) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	87 {
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	88 return octave_base_value::type_conv_info
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	89 (default_numeric_demotion_function,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	90 octave_float_matrix::static_type_id ());
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	91 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	92
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5307 diff changeset	93 octave_base_value *
2410 367485171742 [project @ 1996-10-15 16:50:27 by jwe] jwe parents: 2407 diff changeset	94 octave_matrix::try_narrowing_conversion (void)
367485171742 [project @ 1996-10-15 16:50:27 by jwe] jwe parents: 2407 diff changeset	95 {
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5307 diff changeset	96 octave_base_value *retval = 0;
2410 367485171742 [project @ 1996-10-15 16:50:27 by jwe] jwe parents: 2407 diff changeset	97
20228 00cf2847355d Deprecate Array::nelem() and Range::nelem() in favour of ::numel(). Carnë Draug <carandraug@octave.org> parents: 20218 diff changeset	98 if (matrix.numel () == 1)
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	99 retval = new octave_scalar (matrix (0));
2410 367485171742 [project @ 1996-10-15 16:50:27 by jwe] jwe parents: 2407 diff changeset	100
367485171742 [project @ 1996-10-15 16:50:27 by jwe] jwe parents: 2407 diff changeset	101 return retval;
367485171742 [project @ 1996-10-15 16:50:27 by jwe] jwe parents: 2407 diff changeset	102 }
367485171742 [project @ 1996-10-15 16:50:27 by jwe] jwe parents: 2407 diff changeset	103
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	104 double
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	105 octave_matrix::double_value (bool) const
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	106 {
4102 cbac6756967e [project @ 2002-10-14 20:16:44 by jwe] jwe parents: 4100 diff changeset	107 double retval = lo_ieee_nan_value ();
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	108
4645 bd2067547b40 [project @ 2003-11-23 08:07:52 by jwe] jwe parents: 4643 diff changeset	109 if (numel () > 0)
4455 abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4452 diff changeset	110 {
14469 29aabe9b37a2 Rename array-as-vector, array-as-scalar warning IDs to match documentation (bug #35838) Rik <octave@nomad.inbox5.com> parents: 14429 diff changeset	111 gripe_implicit_conversion ("Octave:array-to-scalar",
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	112 "real matrix", "real scalar");
4455 abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4452 diff changeset	113
abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4452 diff changeset	114 retval = matrix (0, 0);
abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4452 diff changeset	115 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	116 else
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	117 gripe_invalid_conversion ("real matrix", "real scalar");
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	118
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	119 return retval;
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	120 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	121
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	122 float
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	123 octave_matrix::float_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	124 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	125 float retval = lo_ieee_float_nan_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	126
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	127 if (numel () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	128 {
14469 29aabe9b37a2 Rename array-as-vector, array-as-scalar warning IDs to match documentation (bug #35838) Rik <octave@nomad.inbox5.com> parents: 14429 diff changeset	129 gripe_implicit_conversion ("Octave:array-to-scalar",
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	130 "real matrix", "real scalar");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	131
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	132 retval = matrix (0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	133 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	134 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	135 gripe_invalid_conversion ("real matrix", "real scalar");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	136
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	137 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	138 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	139
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5760 diff changeset	140 // FIXME
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	141
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	142 Matrix
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	143 octave_matrix::matrix_value (bool) const
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	144 {
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 18200 diff changeset	145 return Matrix (matrix);
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	146 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	147
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	148 FloatMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	149 octave_matrix::float_matrix_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	150 {
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 18200 diff changeset	151 return FloatMatrix (Matrix (matrix));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	152 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	153
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	154 Complex
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	155 octave_matrix::complex_value (bool) const
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	156 {
4102 cbac6756967e [project @ 2002-10-14 20:16:44 by jwe] jwe parents: 4100 diff changeset	157 double tmp = lo_ieee_nan_value ();
cbac6756967e [project @ 2002-10-14 20:16:44 by jwe] jwe parents: 4100 diff changeset	158
cbac6756967e [project @ 2002-10-14 20:16:44 by jwe] jwe parents: 4100 diff changeset	159 Complex retval (tmp, tmp);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	160
4455 abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4452 diff changeset	161 if (rows () > 0 && columns () > 0)
abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4452 diff changeset	162 {
14469 29aabe9b37a2 Rename array-as-vector, array-as-scalar warning IDs to match documentation (bug #35838) Rik <octave@nomad.inbox5.com> parents: 14429 diff changeset	163 gripe_implicit_conversion ("Octave:array-to-scalar",
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	164 "real matrix", "complex scalar");
4455 abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4452 diff changeset	165
abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4452 diff changeset	166 retval = matrix (0, 0);
abbf63293766 [project @ 2003-07-11 01:01:16 by jwe] jwe parents: 4452 diff changeset	167 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	168 else
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	169 gripe_invalid_conversion ("real matrix", "complex scalar");
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	170
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	171 return retval;
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	172 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	173
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	174 FloatComplex
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	175 octave_matrix::float_complex_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	176 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	177 float tmp = lo_ieee_float_nan_value ();
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	178
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	179 FloatComplex retval (tmp, tmp);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	180
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	181 if (rows () > 0 && columns () > 0)
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	182 {
14469 29aabe9b37a2 Rename array-as-vector, array-as-scalar warning IDs to match documentation (bug #35838) Rik <octave@nomad.inbox5.com> parents: 14429 diff changeset	183 gripe_implicit_conversion ("Octave:array-to-scalar",
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	184 "real matrix", "complex scalar");
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	185
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	186 retval = matrix (0, 0);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	187 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	188 else
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	189 gripe_invalid_conversion ("real matrix", "complex scalar");
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	190
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	191 return retval;
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	192 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	193
5775 ace8d8d26933 [project @ 2006-04-24 19:13:06 by jwe] jwe parents: 5760 diff changeset	194 // FIXME
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	195
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	196 ComplexMatrix
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	197 octave_matrix::complex_matrix_value (bool) const
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	198 {
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 18200 diff changeset	199 return ComplexMatrix (Matrix (matrix));
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	200 }
508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4457 diff changeset	201
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	202 FloatComplexMatrix
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	203 octave_matrix::float_complex_matrix_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	204 {
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 18200 diff changeset	205 return FloatComplexMatrix (Matrix (matrix));
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	206 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	207
4699 5e2c68946f30 [project @ 2004-01-20 23:04:46 by jwe] jwe parents: 4687 diff changeset	208 ComplexNDArray
5e2c68946f30 [project @ 2004-01-20 23:04:46 by jwe] jwe parents: 4687 diff changeset	209 octave_matrix::complex_array_value (bool) const
5e2c68946f30 [project @ 2004-01-20 23:04:46 by jwe] jwe parents: 4687 diff changeset	210 {
5e2c68946f30 [project @ 2004-01-20 23:04:46 by jwe] jwe parents: 4687 diff changeset	211 return ComplexNDArray (matrix);
5e2c68946f30 [project @ 2004-01-20 23:04:46 by jwe] jwe parents: 4687 diff changeset	212 }
5e2c68946f30 [project @ 2004-01-20 23:04:46 by jwe] jwe parents: 4687 diff changeset	213
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	214 FloatComplexNDArray
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	215 octave_matrix::float_complex_array_value (bool) const
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	216 {
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	217 return FloatComplexNDArray (matrix);
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	218 }
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7740 diff changeset	219
5898 da843f35775c [project @ 2006-07-19 18:18:08 by jwe] jwe parents: 5862 diff changeset	220 boolNDArray
5943 c038c2947ee1 [project @ 2006-08-18 21:27:03 by jwe] jwe parents: 5900 diff changeset	221 octave_matrix::bool_array_value (bool warn) const
5898 da843f35775c [project @ 2006-07-19 18:18:08 by jwe] jwe parents: 5862 diff changeset	222 {
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7885 diff changeset	223 if (matrix.any_element_is_nan ())
11129 0de5cc44e690 use gripe functions for NaN to logical and NaN to character conversions more consistently John W. Eaton <jwe@octave.org> parents: 10521 diff changeset	224 gripe_nan_to_logical_conversion ();
7922 935be827eaf8 error for NaN values in & and \| expressions John W. Eaton <jwe@octave.org> parents: 7885 diff changeset	225 else if (warn && matrix.any_element_not_one_or_zero ())
5943 c038c2947ee1 [project @ 2006-08-18 21:27:03 by jwe] jwe parents: 5900 diff changeset	226 gripe_logical_conversion ();
c038c2947ee1 [project @ 2006-08-18 21:27:03 by jwe] jwe parents: 5900 diff changeset	227
5898 da843f35775c [project @ 2006-07-19 18:18:08 by jwe] jwe parents: 5862 diff changeset	228 return boolNDArray (matrix);
da843f35775c [project @ 2006-07-19 18:18:08 by jwe] jwe parents: 5862 diff changeset	229 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	230
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4726 diff changeset	231 charNDArray
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4726 diff changeset	232 octave_matrix::char_array_value (bool) const
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4726 diff changeset	233 {
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4726 diff changeset	234 charNDArray retval (dims ());
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4726 diff changeset	235
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	236 octave_idx_type nel = numel ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	237
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	238 for (octave_idx_type i = 0; i < nel; i++)
4758 a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4726 diff changeset	239 retval.elem (i) = static_cast<char>(matrix.elem (i));
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4726 diff changeset	240
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4726 diff changeset	241 return retval;
a308566c8b42 [project @ 2004-02-13 23:01:34 by jwe] jwe parents: 4726 diff changeset	242 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	243
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	244 SparseMatrix
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	245 octave_matrix::sparse_matrix_value (bool) const
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	246 {
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 18200 diff changeset	247 return SparseMatrix (Matrix (matrix));
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	248 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	249
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	250 SparseComplexMatrix
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	251 octave_matrix::sparse_complex_matrix_value (bool) const
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	252 {
17861 870f3e12e163 maint: Use phrase "FIXME:" for problem areas in code. Rik <rik@octave.org> parents: 17787 diff changeset	253 // FIXME: Need a SparseComplexMatrix (Matrix) constructor to make
870f3e12e163 maint: Use phrase "FIXME:" for problem areas in code. Rik <rik@octave.org> parents: 17787 diff changeset	254 // this function more efficient. Then this should become
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	255 // return SparseComplexMatrix (matrix.matrix_value ());
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	256 return SparseComplexMatrix (sparse_matrix_value ());
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	257 }
57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5157 diff changeset	258
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	259 octave_value
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	260 octave_matrix::diag (octave_idx_type k) const
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	261 {
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	262 octave_value retval;
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	263 if (k == 0 && matrix.ndims () == 2
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	264 && (matrix.rows () == 1 \|\| matrix.columns () == 1))
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	265 retval = DiagMatrix (DiagArray2<double> (matrix));
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	266 else
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	267 retval = octave_base_matrix<NDArray>::diag (k);
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	268
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	269 return retval;
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	270 }
8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	271
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	272 octave_value
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	273 octave_matrix::diag (octave_idx_type m, octave_idx_type n) const
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	274 {
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	275 octave_value retval;
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	276
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	277 if (matrix.ndims () == 2
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	278 && (matrix.rows () == 1 \|\| matrix.columns () == 1))
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	279 {
19320 d0c73e23a505 Change inheritance tree so that <T>Matrix inherit from <T>NDArray. Carnë Draug <carandraug@octave.org> parents: 18200 diff changeset	280 Matrix mat (matrix);
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	281
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	282 retval = mat.diag (m, n);
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	283 }
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	284 else
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	285 error ("diag: expecting vector argument");
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	286
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	287 return retval;
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	288 }
e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14469 diff changeset	289
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	290 // We override these two functions to allow reshaping both
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	291 // the matrix and the index cache.
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	292 octave_value
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	293 octave_matrix::reshape (const dim_vector& new_dims) const
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	294 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	295 if (idx_cache)
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	296 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	297 return new octave_matrix (matrix.reshape (new_dims),
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	298 idx_vector (idx_cache->as_array ().reshape (new_dims),
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	299 idx_cache->extent (0)));
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	300 }
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	301 else
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	302 return octave_base_matrix<NDArray>::reshape (new_dims);
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	303 }
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	304
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	305 octave_value
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	306 octave_matrix::squeeze (void) const
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	307 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	308 if (idx_cache)
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	309 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	310 return new octave_matrix (matrix.squeeze (),
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	311 idx_vector (idx_cache->as_array ().squeeze (),
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	312 idx_cache->extent (0)));
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	313 }
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	314 else
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	315 return octave_base_matrix<NDArray>::squeeze ();
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	316 }
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	317
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	318 octave_value
10273 3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	319 octave_matrix::sort (octave_idx_type dim, sortmode mode) const
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	320 {
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	321 if (idx_cache)
10273 3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	322 {
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	323 // This is a valid index matrix, so sort via integers because it's
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	324 // generally more efficient.
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	325 return octave_lazy_index (*idx_cache).sort (dim, mode);
10273 3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	326 }
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	327 else
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	328 return octave_base_matrix<NDArray>::sort (dim, mode);
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	329 }
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	330
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	331 octave_value
10273 3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	332 octave_matrix::sort (Array<octave_idx_type> &sidx, octave_idx_type dim,
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	333 sortmode mode) const
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	334 {
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	335 if (idx_cache)
10273 3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	336 {
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	337 // This is a valid index matrix, so sort via integers because it's
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	338 // generally more efficient.
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	339 return octave_lazy_index (*idx_cache).sort (sidx, dim, mode);
10273 3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	340 }
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	341 else
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	342 return octave_base_matrix<NDArray>::sort (sidx, dim, mode);
3a8c13b71612 implement special-case optimization for sort of index vectors Jaroslav Hajek <highegg@gmail.com> parents: 10160 diff changeset	343 }
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	344
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	345 sortmode
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	346 octave_matrix::is_sorted (sortmode mode) const
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	347 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	348 if (idx_cache)
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	349 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	350 // This is a valid index matrix, so check via integers because it's
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	351 // generally more efficient.
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	352 return idx_cache->as_array ().is_sorted (mode);
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	353 }
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	354 else
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	355 return octave_base_matrix<NDArray>::is_sorted (mode);
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	356 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	357 Array<octave_idx_type>
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	358 octave_matrix::sort_rows_idx (sortmode mode) const
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	359 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	360 if (idx_cache)
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	361 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	362 // This is a valid index matrix, so sort via integers because it's
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	363 // generally more efficient.
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	364 return octave_lazy_index (*idx_cache).sort_rows_idx (mode);
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	365 }
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	366 else
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	367 return octave_base_matrix<NDArray>::sort_rows_idx (mode);
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	368 }
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	369
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	370 sortmode
10339 de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	371 octave_matrix::is_sorted_rows (sortmode mode) const
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	372 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	373 if (idx_cache)
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	374 {
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	375 // This is a valid index matrix, so check via integers because it's
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	376 // generally more efficient.
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	377 return idx_cache->as_array ().is_sorted_rows (mode);
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	378 }
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	379 else
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	380 return octave_base_matrix<NDArray>::is_sorted_rows (mode);
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	381 }
de2d43bcb083 optimize some lazy index operations Jaroslav Hajek <highegg@gmail.com> parents: 10315 diff changeset	382
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	383 octave_value
5279 bd32f770c09a [project @ 2005-04-12 21:55:31 by jwe] jwe parents: 5275 diff changeset	384 octave_matrix::convert_to_str_internal (bool, bool, char type) const
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	385 {
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	386 octave_value retval;
4844 9f7ef92b50b0 [project @ 2004-04-02 17:26:53 by jwe] jwe parents: 4837 diff changeset	387 dim_vector dv = dims ();
5862 2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	388 octave_idx_type nel = dv.numel ();
2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	389
2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	390 charNDArray chm (dv);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	391
5862 2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	392 bool warned = false;
2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	393
2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	394 for (octave_idx_type i = 0; i < nel; i++)
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	395 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9892 diff changeset	396 octave_quit ();
5862 2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	397
2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	398 double d = matrix (i);
4844 9f7ef92b50b0 [project @ 2004-04-02 17:26:53 by jwe] jwe parents: 4837 diff changeset	399
5862 2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	400 if (xisnan (d))
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	401 {
11129 0de5cc44e690 use gripe functions for NaN to logical and NaN to character conversions more consistently John W. Eaton <jwe@octave.org> parents: 10521 diff changeset	402 gripe_nan_to_character_conversion ();
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	403 return retval;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	404 }
5862 2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	405 else
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	406 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	407 int ival = NINT (d);
4844 9f7ef92b50b0 [project @ 2004-04-02 17:26:53 by jwe] jwe parents: 4837 diff changeset	408
15215 9020dddc925a use std::numeric_limits for integer max and min values John W. Eaton <jwe@octave.org> parents: 15195 diff changeset	409 if (ival < 0 \|\| ival > std::numeric_limits<unsigned char>::max ())
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	410 {
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	411 // FIXME: is there something better we could do?
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	412
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	413 ival = 0;
5862 2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	414
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	415 if (! warned)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	416 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	417 ::warning ("range error for conversion to character value");
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	418 warned = true;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	419 }
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	420 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	421
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	422 chm (i) = static_cast<char> (ival);
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	423 }
5862 2b35a7fe9302 [project @ 2006-06-20 04:31:56 by jwe] jwe parents: 5828 diff changeset	424 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	425
9689 34d6f005db4b eliminate is_string argument from octave_value character array constructors John W. Eaton <jwe@octave.org> parents: 9470 diff changeset	426 retval = octave_value (chm, type);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	427
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	428 return retval;
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	429 }
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	430
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	431 bool
6974 9e32bb109980 [project @ 2007-10-08 11:06:47 by jwe] jwe parents: 6717 diff changeset	432 octave_matrix::save_ascii (std::ostream& os)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	433 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	434 dim_vector d = dims ();
5958 85c7dc4afe6b [project @ 2006-08-23 18:35:38 by jwe] jwe parents: 5956 diff changeset	435
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	436 if (d.length () > 2)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	437 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	438 NDArray tmp = array_value ();
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	439
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	440 os << "# ndims: " << d.length () << "\n";
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	441
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	442 for (int i=0; i < d.length (); i++)
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19863 diff changeset	443 os << " " << d(i);
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	444
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	445 os << "\n" << tmp;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	446 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	447 else
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	448 {
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	449 // Keep this case, rather than use generic code above for backward
20449 df4165dfc676 maint: Fix misspelled word compatibility in code comments. Rik <rik@octave.org> parents: 20447 diff changeset	450 // compatibility. Makes load_ascii much more complex!!
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	451 os << "# rows: " << rows () << "\n"
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	452 << "# columns: " << columns () << "\n";
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	453
5958 85c7dc4afe6b [project @ 2006-08-23 18:35:38 by jwe] jwe parents: 5956 diff changeset	454 os << matrix_value ();
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	455 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	456
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	457 return true;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	458 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	459
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	460 bool
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	461 octave_matrix::load_ascii (std::istream& is)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	462 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	463 bool success = true;
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	464
f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	465 string_vector keywords(2);
f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	466
f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	467 keywords[0] = "ndims";
f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	468 keywords[1] = "rows";
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	469
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	470 std::string kw;
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	471 octave_idx_type val = 0;
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	472
f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	473 if (extract_keyword (is, keywords, kw, val, true))
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	474 {
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	475 if (kw == "ndims")
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	476 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	477 int mdims = static_cast<int> (val);
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	478
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	479 if (mdims >= 0)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	480 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	481 dim_vector dv;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	482 dv.resize (mdims);
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	483
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	484 for (int i = 0; i < mdims; i++)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	485 is >> dv(i);
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	486
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	487 if (is)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	488 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	489 NDArray tmp(dv);
6717 b319df52ba87 [project @ 2007-06-13 20:25:53 by jwe] jwe parents: 6686 diff changeset	490
8999 dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	491 is >> tmp;
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	492
8999 dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	493 if (is)
dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	494 matrix = tmp;
dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	495 else
dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	496 {
dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	497 error ("load: failed to load matrix constant");
dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	498 success = false;
dc07bc4157b8 allow empty matrices in stream input operators Jaroslav Hajek <highegg@gmail.com> parents: 8998 diff changeset	499 }
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	500 }
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	501 else
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	502 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	503 error ("load: failed to read dimensions");
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	504 success = false;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	505 }
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	506 }
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	507 else
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	508 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	509 error ("load: failed to extract number of dimensions");
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	510 success = false;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	511 }
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	512 }
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	513 else if (kw == "rows")
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	514 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	515 octave_idx_type nr = val;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	516 octave_idx_type nc = 0;
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	517
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	518 if (nr >= 0 && extract_keyword (is, "columns", nc) && nc >= 0)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	519 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	520 if (nr > 0 && nc > 0)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	521 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	522 Matrix tmp (nr, nc);
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	523 is >> tmp;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	524 if (is)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	525 matrix = tmp;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	526 else
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	527 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	528 error ("load: failed to load matrix constant");
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	529 success = false;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	530 }
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	531 }
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	532 else if (nr == 0 \|\| nc == 0)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	533 matrix = Matrix (nr, nc);
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	534 else
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	535 panic_impossible ();
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	536 }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	537 else
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	538 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	539 error ("load: failed to extract number of rows and columns");
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	540 success = false;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	541 }
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	542 }
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	543 else
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	544 panic_impossible ();
5099 f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	545 }
f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	546 else
f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	547 {
f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	548 error ("load: failed to extract number of rows and columns");
f7e39f977fe8 [project @ 2004-12-24 19:06:01 by jwe] jwe parents: 4944 diff changeset	549 success = false;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	550 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	551
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	552 return success;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	553 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	554
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	555 bool
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	556 octave_matrix::save_binary (std::ostream& os, bool& save_as_floats)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	557 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	558
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	559 dim_vector d = dims ();
14846 460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists. Rik <octave@nomad.inbox5.com> parents: 14770 diff changeset	560 if (d.length () < 1)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	561 return false;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	562
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	563 // Use negative value for ndims to differentiate with old format!!
14846 460a3c6d8bf1 maint: Use Octave coding convention for cuddled parenthis in function calls with empty argument lists. Rik <octave@nomad.inbox5.com> parents: 14770 diff changeset	564 int32_t tmp = - d.length ();
5760 8d7162924bd3 [project @ 2006-04-14 04:01:37 by jwe] jwe parents: 5759 diff changeset	565 os.write (reinterpret_cast<char *> (&tmp), 4);
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	566 for (int i = 0; i < d.length (); i++)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	567 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	568 tmp = d(i);
5760 8d7162924bd3 [project @ 2006-04-14 04:01:37 by jwe] jwe parents: 5759 diff changeset	569 os.write (reinterpret_cast<char *> (&tmp), 4);
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	570 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	571
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	572 NDArray m = array_value ();
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	573 save_type st = LS_DOUBLE;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	574 if (save_as_floats)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	575 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	576 if (m.too_large_for_float ())
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	577 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	578 warning ("save: some values too large to save as floats --");
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	579 warning ("save: saving as doubles instead");
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	580 }
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	581 else
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	582 st = LS_FLOAT;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	583 }
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	584 else if (d.numel () > 8192) // FIXME: make this configurable.
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	585 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	586 double max_val, min_val;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	587 if (m.all_integers (max_val, min_val))
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	588 st = get_save_type (max_val, min_val);
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	589 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	590
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	591 const double *mtmp = m.data ();
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	592 write_doubles (os, mtmp, st, d.numel ());
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	593
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	594 return true;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	595 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	596
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	597 bool
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	598 octave_matrix::load_binary (std::istream& is, bool swap,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	599 oct_mach_info::float_format fmt)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	600 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	601 char tmp;
5828 22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe] jwe parents: 5781 diff changeset	602 int32_t mdims;
5760 8d7162924bd3 [project @ 2006-04-14 04:01:37 by jwe] jwe parents: 5759 diff changeset	603 if (! is.read (reinterpret_cast<char *> (&mdims), 4))
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	604 return false;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	605 if (swap)
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4901 diff changeset	606 swap_bytes<4> (&mdims);
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	607 if (mdims < 0)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	608 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	609 mdims = - mdims;
5828 22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe] jwe parents: 5781 diff changeset	610 int32_t di;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	611 dim_vector dv;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	612 dv.resize (mdims);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	613
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	614 for (int i = 0; i < mdims; i++)
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	615 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	616 if (! is.read (reinterpret_cast<char *> (&di), 4))
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	617 return false;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	618 if (swap)
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	619 swap_bytes<4> (&di);
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	620 dv(i) = di;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	621 }
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	622
5157 8ca032643f55 [project @ 2005-02-23 00:18:58 by jwe] jwe parents: 5105 diff changeset	623 // Convert an array with a single dimension to be a row vector.
8ca032643f55 [project @ 2005-02-23 00:18:58 by jwe] jwe parents: 5105 diff changeset	624 // Octave should never write files like this, other software
8ca032643f55 [project @ 2005-02-23 00:18:58 by jwe] jwe parents: 5105 diff changeset	625 // might.
8ca032643f55 [project @ 2005-02-23 00:18:58 by jwe] jwe parents: 5105 diff changeset	626
8ca032643f55 [project @ 2005-02-23 00:18:58 by jwe] jwe parents: 5105 diff changeset	627 if (mdims == 1)
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	628 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	629 mdims = 2;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	630 dv.resize (mdims);
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	631 dv(1) = dv(0);
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	632 dv(0) = 1;
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	633 }
5157 8ca032643f55 [project @ 2005-02-23 00:18:58 by jwe] jwe parents: 5105 diff changeset	634
5760 8d7162924bd3 [project @ 2006-04-14 04:01:37 by jwe] jwe parents: 5759 diff changeset	635 if (! is.read (reinterpret_cast<char *> (&tmp), 1))
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	636 return false;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	637
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	638 NDArray m(dv);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	639 double *re = m.fortran_vec ();
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	640 read_doubles (is, re, static_cast<save_type> (tmp), dv.numel (),
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	641 swap, fmt);
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20449 diff changeset	642
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20449 diff changeset	643 if (! is)
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	644 return false;
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20449 diff changeset	645
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	646 matrix = m;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	647 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	648 else
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	649 {
5828 22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe] jwe parents: 5781 diff changeset	650 int32_t nr, nc;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	651 nr = mdims;
5760 8d7162924bd3 [project @ 2006-04-14 04:01:37 by jwe] jwe parents: 5759 diff changeset	652 if (! is.read (reinterpret_cast<char *> (&nc), 4))
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	653 return false;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	654 if (swap)
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	655 swap_bytes<4> (&nc);
5760 8d7162924bd3 [project @ 2006-04-14 04:01:37 by jwe] jwe parents: 5759 diff changeset	656 if (! is.read (reinterpret_cast<char *> (&tmp), 1))
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	657 return false;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	658 Matrix m (nr, nc);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	659 double *re = m.fortran_vec ();
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	660 octave_idx_type len = nr * nc;
5760 8d7162924bd3 [project @ 2006-04-14 04:01:37 by jwe] jwe parents: 5759 diff changeset	661 read_doubles (is, re, static_cast<save_type> (tmp), len, swap, fmt);
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20449 diff changeset	662
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20449 diff changeset	663 if (! is)
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	664 return false;
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20449 diff changeset	665
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	666 matrix = m;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	667 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	668 return true;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	669 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	670
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	671 bool
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	672 octave_matrix::save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	673 {
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	674 bool retval = false;
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	675
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	676 #if defined (HAVE_HDF5)
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4901 diff changeset	677
4837 81f78a2ff8a6 [project @ 2004-03-12 19:13:01 by jwe] jwe parents: 4815 diff changeset	678 dim_vector dv = dims ();
81f78a2ff8a6 [project @ 2004-03-12 19:13:01 by jwe] jwe parents: 4815 diff changeset	679 int empty = save_hdf5_empty (loc_id, name, dv);
81f78a2ff8a6 [project @ 2004-03-12 19:13:01 by jwe] jwe parents: 4815 diff changeset	680 if (empty)
4805 b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	681 return (empty > 0);
b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	682
4837 81f78a2ff8a6 [project @ 2004-03-12 19:13:01 by jwe] jwe parents: 4815 diff changeset	683 int rank = dv.length ();
18100 6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17861 diff changeset	684 hid_t space_hid, data_hid;
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17861 diff changeset	685 space_hid = data_hid = -1;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	686 NDArray m = array_value ();
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	687
4805 b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	688 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank);
b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	689
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	690 // Octave uses column-major, while HDF5 uses row-major ordering
4805 b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	691 for (int i = 0; i < rank; i++)
20218 b2100e1659ac maint: Use cuddled parentheses when indexing dimension_vectors. Rik <rik@octave.org> parents: 19863 diff changeset	692 hdims[i] = dv(rank-i-1);
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	693
4815 2eb844b27953 [project @ 2004-03-04 00:14:44 by jwe] jwe parents: 4805 diff changeset	694 space_hid = H5Screate_simple (rank, hdims, 0);
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	695
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	696 if (space_hid < 0) return false;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	697
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	698 hid_t save_type_hid = H5T_NATIVE_DOUBLE;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	699
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	700 if (save_as_floats)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	701 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	702 if (m.too_large_for_float ())
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	703 {
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	704 warning ("save: some values too large to save as floats --");
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	705 warning ("save: saving as doubles instead");
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	706 }
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	707 else
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	708 save_type_hid = H5T_NATIVE_FLOAT;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	709 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	710 #if HAVE_HDF5_INT2FLOAT_CONVERSIONS
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	711 // hdf5 currently doesn't support float/integer conversions
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	712 else
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	713 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	714 double max_val, min_val;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	715
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	716 if (m.all_integers (max_val, min_val))
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	717 save_type_hid
57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	718 = save_type_to_hdf5 (get_save_type (max_val, min_val));
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	719 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	720 #endif /* HAVE_HDF5_INT2FLOAT_CONVERSIONS */
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	721
9892 ac69e6f4b33d Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions Kacper Kowalik <xarthisius.kk@gmail.com> parents: 9881 diff changeset	722 #if HAVE_HDF5_18
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	723 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	724 H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
9892 ac69e6f4b33d Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions Kacper Kowalik <xarthisius.kk@gmail.com> parents: 9881 diff changeset	725 #else
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	726 data_hid = H5Dcreate (loc_id, name, save_type_hid, space_hid,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	727 H5P_DEFAULT);
9892 ac69e6f4b33d Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions Kacper Kowalik <xarthisius.kk@gmail.com> parents: 9881 diff changeset	728 #endif
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	729 if (data_hid < 0)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	730 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	731 H5Sclose (space_hid);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	732 return false;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	733 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	734
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	735 double *mtmp = m.fortran_vec ();
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	736 retval = H5Dwrite (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	737 H5P_DEFAULT, mtmp) >= 0;
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	738
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	739 H5Dclose (data_hid);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	740 H5Sclose (space_hid);
4837 81f78a2ff8a6 [project @ 2004-03-12 19:13:01 by jwe] jwe parents: 4815 diff changeset	741
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	742 #else
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	743 gripe_save ("hdf5");
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	744 #endif
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	745
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	746 return retval;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	747 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	748
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	749 bool
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	750 octave_matrix::load_hdf5 (octave_hdf5_id loc_id, const char *name)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	751 {
4837 81f78a2ff8a6 [project @ 2004-03-12 19:13:01 by jwe] jwe parents: 4815 diff changeset	752 bool retval = false;
81f78a2ff8a6 [project @ 2004-03-12 19:13:01 by jwe] jwe parents: 4815 diff changeset	753
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	754 #if defined (HAVE_HDF5)
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	755
4805 b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	756 dim_vector dv;
b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	757 int empty = load_hdf5_empty (loc_id, name, dv);
b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	758 if (empty > 0)
14861 f7afecdd87ef maint: Use Octave coding conventions for cuddling parentheses in src/ directory Rik <octave@nomad.inbox5.com> parents: 14846 diff changeset	759 matrix.resize (dv);
4837 81f78a2ff8a6 [project @ 2004-03-12 19:13:01 by jwe] jwe parents: 4815 diff changeset	760 if (empty)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	761 return (empty > 0);
4805 b0d6da24caeb [project @ 2004-03-02 03:43:15 by jwe] jwe parents: 4758 diff changeset	762
9892 ac69e6f4b33d Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions Kacper Kowalik <xarthisius.kk@gmail.com> parents: 9881 diff changeset	763 #if HAVE_HDF5_18
ac69e6f4b33d Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions Kacper Kowalik <xarthisius.kk@gmail.com> parents: 9881 diff changeset	764 hid_t data_hid = H5Dopen (loc_id, name, H5P_DEFAULT);
ac69e6f4b33d Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions Kacper Kowalik <xarthisius.kk@gmail.com> parents: 9881 diff changeset	765 #else
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	766 hid_t data_hid = H5Dopen (loc_id, name);
9892 ac69e6f4b33d Add HDF5-1.8 compatibility while maintaining compatibility with HDF5-1.6 versions Kacper Kowalik <xarthisius.kk@gmail.com> parents: 9881 diff changeset	767 #endif
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	768 hid_t space_id = H5Dget_space (data_hid);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	769
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	770 hsize_t rank = H5Sget_simple_extent_ndims (space_id);
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	771
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	772 if (rank < 1)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	773 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	774 H5Sclose (space_id);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	775 H5Dclose (data_hid);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	776 return false;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	777 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	778
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	779 OCTAVE_LOCAL_BUFFER (hsize_t, hdims, rank);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	780 OCTAVE_LOCAL_BUFFER (hsize_t, maxdims, rank);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	781
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	782 H5Sget_simple_extent_dims (space_id, hdims, maxdims);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	783
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	784 // Octave uses column-major, while HDF5 uses row-major ordering
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	785 if (rank == 1)
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	786 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	787 dv.resize (2);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	788 dv(0) = 1;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	789 dv(1) = hdims[0];
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	790 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	791 else
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	792 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	793 dv.resize (rank);
4815 2eb844b27953 [project @ 2004-03-04 00:14:44 by jwe] jwe parents: 4805 diff changeset	794 for (hsize_t i = 0, j = rank - 1; i < rank; i++, j--)
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	795 dv(j) = hdims[i];
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	796 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	797
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	798 NDArray m (dv);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	799 double *re = m.fortran_vec ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	800 if (H5Dread (data_hid, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL,
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	801 H5P_DEFAULT, re) >= 0)
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	802 {
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	803 retval = true;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	804 matrix = m;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	805 }
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	806
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	807 H5Sclose (space_id);
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	808 H5Dclose (data_hid);
4837 81f78a2ff8a6 [project @ 2004-03-12 19:13:01 by jwe] jwe parents: 4815 diff changeset	809
19863 09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	810 #else
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	811 gripe_load ("hdf5");
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	812 #endif
09ed6f7538dd avoid needing to include hdf5 in public header files (bug #44370, #43180) John W. Eaton <jwe@octave.org> and Mike Miller <mtmiller@ieee.org> parents: 19861 diff changeset	813
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	814 return retval;
e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4645 diff changeset	815 }
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4901 diff changeset	816
4643 ef3a14fb6847 [project @ 2003-11-22 12:25:44 by jwe] jwe parents: 4612 diff changeset	817 void
ef3a14fb6847 [project @ 2003-11-22 12:25:44 by jwe] jwe parents: 4612 diff changeset	818 octave_matrix::print_raw (std::ostream& os,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	819 bool pr_as_read_syntax) const
4643 ef3a14fb6847 [project @ 2003-11-22 12:25:44 by jwe] jwe parents: 4612 diff changeset	820 {
ef3a14fb6847 [project @ 2003-11-22 12:25:44 by jwe] jwe parents: 4612 diff changeset	821 octave_print_internal (os, matrix, pr_as_read_syntax,
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	822 current_print_indent_level ());
4643 ef3a14fb6847 [project @ 2003-11-22 12:25:44 by jwe] jwe parents: 4612 diff changeset	823 }
ef3a14fb6847 [project @ 2003-11-22 12:25:44 by jwe] jwe parents: 4612 diff changeset	824
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	825 mxArray *
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	826 octave_matrix::as_mxArray (void) const
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	827 {
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	828 mxArray *retval = new mxArray (mxDOUBLE_CLASS, dims (), mxREAL);
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	829
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	830 double pr = static_cast<double > (retval->get_data ());
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	831
6686 2aad75fcc93a [project @ 2007-06-03 20:58:28 by dbateman] dbateman parents: 5958 diff changeset	832 mwSize nel = numel ();
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	833
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	834 const double *p = matrix.data ();
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	835
6686 2aad75fcc93a [project @ 2007-06-03 20:58:28 by dbateman] dbateman parents: 5958 diff changeset	836 for (mwIndex i = 0; i < nel; i++)
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	837 pr[i] = p[i];
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	838
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	839 return retval;
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	840 }
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5898 diff changeset	841
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	842 // This uses a smarter strategy for doing the complex->real mappers. We
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	843 // allocate an array for a real result and keep filling it until a complex
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	844 // result is produced.
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	845 static octave_value
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	846 do_rc_map (const NDArray& a, Complex (&fcn) (double))
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	847 {
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	848 octave_idx_type n = a.numel ();
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	849 NoAlias<NDArray> rr (a.dims ());
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	850
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	851 for (octave_idx_type i = 0; i < n; i++)
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	852 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9892 diff changeset	853 octave_quit ();
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	854
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	855 Complex tmp = fcn (a(i));
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	856 if (tmp.imag () == 0.0)
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	857 rr(i) = tmp.real ();
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	858 else
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	859 {
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	860 NoAlias<ComplexNDArray> rc (a.dims ());
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	861
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	862 for (octave_idx_type j = 0; j < i; j++)
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	863 rc(j) = rr(j);
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	864
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	865 rc(i) = tmp;
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	866
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	867 for (octave_idx_type j = i+1; j < n; j++)
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	868 {
10142 829e69ec3110 make OCTAVE_QUIT a function Jaroslav Hajek <highegg@gmail.com> parents: 9892 diff changeset	869 octave_quit ();
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	870
9824 6631c61a4a4e fix typos in previous change Jaroslav Hajek <highegg@gmail.com> parents: 9823 diff changeset	871 rc(j) = fcn (a(j));
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	872 }
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	873
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	874 return new octave_complex_matrix (rc);
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	875 }
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	876 }
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	877
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	878 return rr;
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	879 }
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	880
8650 a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8437 diff changeset	881 octave_value
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	882 octave_matrix::map (unary_mapper_t umap) const
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7017 diff changeset	883 {
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	884 switch (umap)
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	885 {
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	886 case umap_imag:
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	887 return NDArray (matrix.dims (), 0.0);
8650 a1ae2aae903e abs,real,imag,conj: use code from mx-inlines rather than the generic map Jaroslav Hajek <highegg@gmail.com> parents: 8437 diff changeset	888
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	889 case umap_real:
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	890 case umap_conj:
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	891 return matrix;
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7017 diff changeset	892
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	893 // Mappers handled specially.
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	894 #define ARRAY_METHOD_MAPPER(UMAP, FCN) \
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	895 case umap_ ## UMAP: \
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	896 return octave_value (matrix.FCN ())
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	897
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	898 ARRAY_METHOD_MAPPER (abs, abs);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	899 ARRAY_METHOD_MAPPER (isnan, isnan);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	900 ARRAY_METHOD_MAPPER (isinf, isinf);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	901 ARRAY_METHOD_MAPPER (finite, isfinite);
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	902
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	903 #define ARRAY_MAPPER(UMAP, TYPE, FCN) \
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	904 case umap_ ## UMAP: \
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	905 return octave_value (matrix.map<TYPE> (FCN))
8998 a48fba01e4ac optimize isnan/isinf/isfinite mappers Jaroslav Hajek <highegg@gmail.com> parents: 8920 diff changeset	906
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	907 #define RC_ARRAY_MAPPER(UMAP, TYPE, FCN) \
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	908 case umap_ ## UMAP: \
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	909 return do_rc_map (matrix, FCN)
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	910
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	911 RC_ARRAY_MAPPER (acos, Complex, rc_acos);
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	912 RC_ARRAY_MAPPER (acosh, Complex, rc_acosh);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	913 ARRAY_MAPPER (angle, double, ::arg);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	914 ARRAY_MAPPER (arg, double, ::arg);
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	915 RC_ARRAY_MAPPER (asin, Complex, rc_asin);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	916 ARRAY_MAPPER (asinh, double, ::asinh);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	917 ARRAY_MAPPER (atan, double, ::atan);
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	918 RC_ARRAY_MAPPER (atanh, Complex, rc_atanh);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	919 ARRAY_MAPPER (erf, double, ::erf);
9835 1bb1ed717d2f implement built-in erfinv Jaroslav Hajek <highegg@gmail.com> parents: 9824 diff changeset	920 ARRAY_MAPPER (erfinv, double, ::erfinv);
14770 cb85e836d035 New function: erfcinv (bug #36607) Axel Mathéi <axel.mathei@gmail.com> parents: 14557 diff changeset	921 ARRAY_MAPPER (erfcinv, double, ::erfcinv);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	922 ARRAY_MAPPER (erfc, double, ::erfc);
10391 59e34bcdff13 implement built-in erfcx Jaroslav Hajek <highegg@gmail.com> parents: 10339 diff changeset	923 ARRAY_MAPPER (erfcx, double, ::erfcx);
15696 2fac72a256ce Add complex erf,erfc,erfcx,erfi,dawson routines from Faddeeva package. Steven G. Johnson <stevenj@alum.mit.edu> parents: 15487 diff changeset	924 ARRAY_MAPPER (erfi, double, ::erfi);
2fac72a256ce Add complex erf,erfc,erfcx,erfi,dawson routines from Faddeeva package. Steven G. Johnson <stevenj@alum.mit.edu> parents: 15487 diff changeset	925 ARRAY_MAPPER (dawson, double, ::dawson);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	926 ARRAY_MAPPER (gamma, double, xgamma);
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	927 RC_ARRAY_MAPPER (lgamma, Complex, rc_lgamma);
10414 2a8b1db1e2ca implement built-in cbrt Jaroslav Hajek <highegg@gmail.com> parents: 10391 diff changeset	928 ARRAY_MAPPER (cbrt, double, ::cbrt);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	929 ARRAY_MAPPER (ceil, double, ::ceil);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	930 ARRAY_MAPPER (cos, double, ::cos);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	931 ARRAY_MAPPER (cosh, double, ::cosh);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	932 ARRAY_MAPPER (exp, double, ::exp);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	933 ARRAY_MAPPER (expm1, double, ::expm1);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	934 ARRAY_MAPPER (fix, double, ::fix);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	935 ARRAY_MAPPER (floor, double, ::floor);
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	936 RC_ARRAY_MAPPER (log, Complex, rc_log);
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	937 RC_ARRAY_MAPPER (log2, Complex, rc_log2);
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	938 RC_ARRAY_MAPPER (log10, Complex, rc_log10);
9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	939 RC_ARRAY_MAPPER (log1p, Complex, rc_log1p);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	940 ARRAY_MAPPER (round, double, xround);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	941 ARRAY_MAPPER (roundb, double, xroundb);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	942 ARRAY_MAPPER (signum, double, ::signum);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	943 ARRAY_MAPPER (sin, double, ::sin);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	944 ARRAY_MAPPER (sinh, double, ::sinh);
9823 9b62f2d8de6d improve r->c mapper strategy Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	945 RC_ARRAY_MAPPER (sqrt, Complex, rc_sqrt);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	946 ARRAY_MAPPER (tan, double, ::tan);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	947 ARRAY_MAPPER (tanh, double, ::tanh);
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	948 ARRAY_MAPPER (isna, bool, octave_is_NA);
15487 ecf5be238b4a provide signbit mapper for real values John W. Eaton <jwe@octave.org> parents: 15215 diff changeset	949 ARRAY_MAPPER (xsignbit, double, xsignbit);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	950
18196 1b6db9303933 allow toupper and tolower to handle numeric values (bug #33537) John W. Eaton <jwe@octave.org> parents: 18100 diff changeset	951 // Special cases for Matlab compatibility.
1b6db9303933 allow toupper and tolower to handle numeric values (bug #33537) John W. Eaton <jwe@octave.org> parents: 18100 diff changeset	952 case umap_xtolower:
1b6db9303933 allow toupper and tolower to handle numeric values (bug #33537) John W. Eaton <jwe@octave.org> parents: 18100 diff changeset	953 case umap_xtoupper:
1b6db9303933 allow toupper and tolower to handle numeric values (bug #33537) John W. Eaton <jwe@octave.org> parents: 18100 diff changeset	954 return matrix;
1b6db9303933 allow toupper and tolower to handle numeric values (bug #33537) John W. Eaton <jwe@octave.org> parents: 18100 diff changeset	955
18197 0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	956 case umap_xisalnum:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	957 case umap_xisalpha:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	958 case umap_xisascii:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	959 case umap_xiscntrl:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	960 case umap_xisdigit:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	961 case umap_xisgraph:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	962 case umap_xislower:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	963 case umap_xisprint:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	964 case umap_xispunct:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	965 case umap_xisspace:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	966 case umap_xisupper:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	967 case umap_xisxdigit:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	968 case umap_xtoascii:
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	969 {
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	970 octave_value str_conv = convert_to_str (true, true);
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20449 diff changeset	971 return str_conv.map (umap);
18197 0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	972 }
0d5721873d6b avoid some tests that rely on ordering of enum values John W. Eaton <jwe@octave.org> parents: 18196 diff changeset	973
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	974 default:
19861 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19697 diff changeset	975 return octave_base_value::map (umap);
9812 f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	976 }
f80c566bc751 improve unary mapper system Jaroslav Hajek <highegg@gmail.com> parents: 9689 diff changeset	977 }
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7017 diff changeset	978
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4844 diff changeset	979 DEFUN (double, args, ,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	980 "-- texinfo --\n\
20853 1142cf6abc0d 2015 Code Sprint: remove class of function from docstring for all C++ files. Rik <rik@octave.org> parents: 20797 diff changeset	981 @deftypefn {} {} double (@var{x})\n\
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4844 diff changeset	982 Convert @var{x} to double precision type.\n\
9309 fb8b8589dd46 Expand documentation for 'complex' function Rik <rdrider0-list@yahoo.com> parents: 9184 diff changeset	983 @seealso{single}\n\
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4844 diff changeset	984 @end deftypefn")
35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4844 diff changeset	985 {
7004 45d6cc5a0359 [project @ 2007-10-10 18:51:45 by jwe] jwe parents: 6974 diff changeset	986 // The OCTAVE_TYPE_CONV_BODY3 macro declares retval, so they go
45d6cc5a0359 [project @ 2007-10-10 18:51:45 by jwe] jwe parents: 6974 diff changeset	987 // inside their own scopes, and we don't declare retval here to
45d6cc5a0359 [project @ 2007-10-10 18:51:45 by jwe] jwe parents: 6974 diff changeset	988 // avoid a shadowed declaration warning.
45d6cc5a0359 [project @ 2007-10-10 18:51:45 by jwe] jwe parents: 6974 diff changeset	989
20797 492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	990 if (args.length () != 1)
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	991 print_usage ();
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	992
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	993 if (args(0).is_perm_matrix ())
8399 c1bada868690 alow single/double conversion of diag & perm matrices Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	994 {
20797 492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	995 OCTAVE_TYPE_CONV_BODY3 (double, octave_perm_matrix, octave_scalar);
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	996 }
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	997 else if (args(0).is_diag_matrix ())
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	998 {
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	999 if (args(0).is_complex_type ())
8399 c1bada868690 alow single/double conversion of diag & perm matrices Jaroslav Hajek <highegg@gmail.com> parents: 8377 diff changeset	1000 {
20797 492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1001 OCTAVE_TYPE_CONV_BODY3 (double, octave_complex_diag_matrix,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1002 octave_complex);
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	1003 }
7004 45d6cc5a0359 [project @ 2007-10-10 18:51:45 by jwe] jwe parents: 6974 diff changeset	1004 else
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	1005 {
20797 492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1006 OCTAVE_TYPE_CONV_BODY3 (double, octave_diag_matrix,
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1007 octave_scalar);
10315 57a59eae83cc untabify src C++ source files John W. Eaton <jwe@octave.org> parents: 10273 diff changeset	1008 }
7004 45d6cc5a0359 [project @ 2007-10-10 18:51:45 by jwe] jwe parents: 6974 diff changeset	1009 }
20797 492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1010 else if (args(0).is_sparse_type ())
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1011 {
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1012 if (args(0).is_complex_type ())
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1013 {
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1014 OCTAVE_TYPE_CONV_BODY3 (double, octave_sparse_complex_matrix,
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1015 octave_complex);
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1016 }
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1017 else
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1018 {
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1019 OCTAVE_TYPE_CONV_BODY3 (double, octave_sparse_matrix,
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1020 octave_scalar);
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1021 }
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1022 }
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1023 else if (args(0).is_complex_type ())
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1024 {
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1025 OCTAVE_TYPE_CONV_BODY3 (double, octave_complex_matrix,
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1026 octave_complex);
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1027 }
7004 45d6cc5a0359 [project @ 2007-10-10 18:51:45 by jwe] jwe parents: 6974 diff changeset	1028 else
20797 492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1029 {
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1030 OCTAVE_TYPE_CONV_BODY3 (double, octave_matrix, octave_scalar);
492738d32c60 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20555 diff changeset	1031 }
7004 45d6cc5a0359 [project @ 2007-10-10 18:51:45 by jwe] jwe parents: 6974 diff changeset	1032
20939 b17fda023ca6 maint: Use new C++ archetype in more files. Rik <rik@octave.org> parents: 20853 diff changeset	1033 return octave_value_list ();
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4844 diff changeset	1034 }
12818 ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1035
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1036 /*
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1037 %!assert (class (double (single (1))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1038 %!assert (class (double (single (1 + i))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1039 %!assert (class (double (int8 (1))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1040 %!assert (class (double (uint8 (1))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1041 %!assert (class (double (int16 (1))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1042 %!assert (class (double (uint16 (1))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1043 %!assert (class (double (int32 (1))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1044 %!assert (class (double (uint32 (1))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1045 %!assert (class (double (int64 (1))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1046 %!assert (class (double (uint64 (1))), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1047 %!assert (class (double (true)), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1048 %!assert (class (double ("A")), "double")
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1049 %!test
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1050 %! x = sparse (logical ([1 0; 0 1]));
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1051 %! y = double (x);
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1052 %! assert (class (x), "logical");
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1053 %! assert (class (y), "double");
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1054 %! assert (issparse (y));
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1055 %!test
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1056 %! x = diag (single ([1 3 2]));
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1057 %! y = double (x);
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1058 %! assert (class (x), "single");
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1059 %! assert (class (y), "double");
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1060 %!test
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1061 %! x = diag (single ([i 3 2]));
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1062 %! y = double (x);
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1063 %! assert (class (x), "single");
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1064 %! assert (class (y), "double");
ce07cb58ff61 codesprint: Add tests for double() Rik <octave@nomad.inbox5.com> parents: 11586 diff changeset	1065 */

Mercurial > jwe > octave

annotate libinterp/octave-value/ov-re-mat.cc @ 20939:b17fda023ca6