octave: libinterp/octave-value/ov.h annotate

annotate libinterp/octave-value/ov.h @ 28126:4c21f99b4ad5

handle interleaved complex data and new typed data access functions for mex * mexproto.h, mex.cc, mxarray.h (mxMakeArrayReal, mxMakeArrayComplex, mxGetDoubles, mxGetSingles, mxGetInt8s, mxGetInt16s, mxGetInt32s, mxGetInt64s, mxGetUint8s, mxGetUint16s, mxGetUint32s, mxGetUint64s, mxGetComplexDoubles, mxGetComplexSingles, mxSetDoubles, mxSetSingles, mxSetInt8s, mxSetInt16s, mxSetInt32s, mxSetInt64s, mxSetUint8s, mxSetUint16s, mxSetUint32s, mxSetUint64s, mxSetComplexDoubles, mxSetComplexSingles): New functions. Provide corresponding member functions in mxArray class hierarchy to handle the actual operations. (mxGetComplexInt8s, mxGetComplexInt16s, mxGetComplexInt32s, mxGetComplexInt64s, mxGetComplexUint8s, mxGetComplexUint16s, mxGetComplexUint32s, mxGetComplexUint64s, mxSetComplexInt8s, mxSetComplexInt16s, mxSetComplexInt32s, mxSetComplexInt64s, mxSetComplexUint8s, mxSetComplexUint16s, mxSetComplexUint32s, mxSetComplexUint64s): Add prototypes and functions, but leave commented out since we don't have complex integer data. (class mxArray_number, class mxArray_sparse): Handle interleaved complex data. In mxArray_octave_value and mxArray_matlab constructors, handle interleaved flag in constructor to determine data layout to use when creating mxArray_number or mxArray_sparse objects. (mex::make_value): Check flag in mex function to determine whether to create arrays with interleaved complex. * ov.h, ov.cc, ov-base.h, ov-base.cc, ov-base-diag.h, ov-base-diag.cc, ov-bool-mat.h, ov-bool-mat.cc, ov-bool-sparse.h, ov-bool-sparse.cc, ov-bool.h, ov-bool.cc, ov-cell.h, ov-cell.cc, ov-ch-mat.h, ov-ch-mat.cc, ov-class.h, ov-class.cc, ov-complex.h, ov-complex.cc, ov-cx-mat.h, ov-cx-mat.cc, ov-cx-sparse.h, ov-cx-sparse.cc, ov-float.h, ov-float.cc, ov-flt-complex.h, ov-flt-complex.cc, ov-flt-cx-mat.h, ov-flt-cx-mat.cc, ov-flt-re-mat.h, ov-flt-re-mat.cc, ov-intx.h, ov-lazy-idx.h, ov-perm.h, ov-perm.cc, ov-range.h, ov-range.cc, ov-re-mat.h, ov-re-mat.cc, ov-re-sparse.h, ov-re-sparse.cc, ov-scalar.h, ov-scalar.cc, ov-struct.h, ov-struct.cc: In all as_mxArray methods, handle new interleaved input to optionally create objects that will use interleaved complex data.

author	John W. Eaton <jwe@octave.org>
date	Tue, 18 Feb 2020 13:16:41 -0500
parents	4963f23b145c
children	b743a63e2dab

rev	line source
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	1 ////////////////////////////////////////////////////////////////////////
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	2 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	3 // Copyright (C) 1996-2020 The Octave Project Developers
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	4 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	7 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	9 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	14 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	19 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	23 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	24 ////////////////////////////////////////////////////////////////////////
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	25
20791 f7084eae3318 maint: Use Octave coding conventions for #if statements. Rik <rik@octave.org> parents: 20768 diff changeset	26 #if ! defined (octave_ov_h)
17822 ebb3ef964372 maint: Use common #define syntax "octave_filename_h" in h_files. Rik <rik@octave.org> parents: 17787 diff changeset	27 #define octave_ov_h 1
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	28
21244 1473547f50f5 include octave-config.h in public header files John W. Eaton <jwe@octave.org> parents: 21139 diff changeset	29 #include "octave-config.h"
1473547f50f5 include octave-config.h in public header files John W. Eaton <jwe@octave.org> parents: 21139 diff changeset	30
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	31 #include <cstdlib>
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	32
8950 d865363208d6 include <iosfwd> instead of <iostream> in header files John W. Eaton <jwe@octave.org> parents: 8920 diff changeset	33 #include <iosfwd>
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	34 #include <string>
4219 23d06c9e1edd [project @ 2002-12-06 21:29:17 by jwe] jwe parents: 4192 diff changeset	35 #include <list>
23678 dcba41788495 new struct/map constructors John W. Eaton <jwe@octave.org> parents: 23615 diff changeset	36 #include <map>
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	37
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	38 #include "Range.h"
5828 22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe] jwe parents: 5785 diff changeset	39 #include "data-conv.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	40 #include "idx-vector.h"
5828 22e23bee74c8 [project @ 2006-05-23 06:05:14 by jwe] jwe parents: 5785 diff changeset	41 #include "mach-info.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	42 #include "mx-base.h"
23059 b98ebcd7f11c move some octave stream classes into octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	43 #include "oct-sort.h"
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	44 #include "oct-time.h"
2942 026f342c2019 [project @ 1997-05-08 02:20:57 by jwe] jwe parents: 2916 diff changeset	45 #include "str-vec.h"
026f342c2019 [project @ 1997-05-08 02:20:57 by jwe] jwe parents: 2916 diff changeset	46
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	47 namespace octave
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	48 {
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	49 class type_info;
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	50 }
46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	51
3351 8623649c967c [project @ 1999-11-15 16:17:01 by jwe] jwe parents: 3340 diff changeset	52 class Cell;
24668 d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24643 diff changeset	53 class float_format;
15149 62a35ae7d6a2 use forward decls for mxArray in ov.h and ov-base.h John W. Eaton <jwe@octave.org> parents: 15140 diff changeset	54 class mxArray;
10742 604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	55 class octave_map;
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	56 class octave_scalar_map;
2974 ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2963 diff changeset	57 class octave_function;
4700 ca3a1d687bba [project @ 2004-01-21 03:28:31 by jwe] jwe parents: 4687 diff changeset	58 class octave_user_function;
4342 813effe14ee1 [project @ 2003-02-20 08:35:55 by jwe] jwe parents: 4271 diff changeset	59 class octave_fcn_handle;
4933 cd58733c326b [project @ 2004-08-05 16:08:28 by jwe] jwe parents: 4930 diff changeset	60 class octave_fcn_inline;
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	61 class octave_value_list;
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	62
28123 4963f23b145c move mex type definitions to separate file John W. Eaton <jwe@octave.org> parents: 27923 diff changeset	63 #include "mxtypes.h"
4963f23b145c move mex type definitions to separate file John W. Eaton <jwe@octave.org> parents: 27923 diff changeset	64
23059 b98ebcd7f11c move some octave stream classes into octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	65 #include "oct-stream.h"
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	66 #include "ov-base.h"
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	67
20087 0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	68 // Forward declarations of friend functions that have default arguments.
0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	69
0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	70 OCTINTERP_API octave_value do_colon_op (const octave_value& base,
0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	71 const octave_value& limit,
0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	72 bool is_for_cmd_expr = false);
0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	73
0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	74 OCTINTERP_API octave_value do_colon_op (const octave_value& base,
0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	75 const octave_value& increment,
0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	76 const octave_value& limit,
0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	77 bool is_for_cmd_expr = false);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	78
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	79 class
6109 c68896f193e3 [project @ 2006-10-27 02:16:18 by jwe] jwe parents: 5958 diff changeset	80 OCTINTERP_API
2974 ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2963 diff changeset	81 octave_value
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	82 {
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	83 public:
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	84
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	85 enum unary_op
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	86 {
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	87 op_not, // not
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	88 op_uplus, // uplus
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	89 op_uminus, // uminus
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	90 op_transpose, // transpose
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	91 op_hermitian, // ctranspose
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	92 op_incr,
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	93 op_decr,
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	94 num_unary_ops,
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	95 unknown_unary_op
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	96 };
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	97
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	98 enum binary_op
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	99 {
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	100 op_add, // plus
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	101 op_sub, // minus
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	102 op_mul, // mtimes
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	103 op_div, // mrdivide
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	104 op_pow, // mpower
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	105 op_ldiv, // mldivide
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	106 op_lt, // lt
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	107 op_le, // le
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	108 op_eq, // eq
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	109 op_ge, // ge
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	110 op_gt, // gt
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	111 op_ne, // ne
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	112 op_el_mul, // times
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	113 op_el_div, // rdivide
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	114 op_el_pow, // power
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	115 op_el_ldiv, // ldivide
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	116 op_el_and, // and
952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	117 op_el_or, // or
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	118 op_struct_ref,
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	119 num_binary_ops,
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	120 unknown_binary_op
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	121 };
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	122
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	123 enum compound_binary_op
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	124 {
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	125 // compound operations
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	126 op_trans_mul,
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	127 op_mul_trans,
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	128 op_herm_mul,
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	129 op_mul_herm,
9661 afcf852256d2 optimize / and '\ for triangular matrices Jaroslav Hajek <highegg@gmail.com> parents: 9657 diff changeset	130 op_trans_ldiv,
afcf852256d2 optimize / and '\ for triangular matrices Jaroslav Hajek <highegg@gmail.com> parents: 9657 diff changeset	131 op_herm_ldiv,
8982 dc6bda6f9994 implement compound logical ops Jaroslav Hajek <highegg@gmail.com> parents: 8960 diff changeset	132 op_el_not_and,
dc6bda6f9994 implement compound logical ops Jaroslav Hajek <highegg@gmail.com> parents: 8960 diff changeset	133 op_el_not_or,
dc6bda6f9994 implement compound logical ops Jaroslav Hajek <highegg@gmail.com> parents: 8960 diff changeset	134 op_el_and_not,
dc6bda6f9994 implement compound logical ops Jaroslav Hajek <highegg@gmail.com> parents: 8960 diff changeset	135 op_el_or_not,
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	136 num_compound_binary_ops,
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	137 unknown_compound_binary_op
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	138 };
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	139
2880 0a076230ca87 [project @ 1997-04-24 09:47:41 by jwe] jwe parents: 2847 diff changeset	140 enum assign_op
0a076230ca87 [project @ 1997-04-24 09:47:41 by jwe] jwe parents: 2847 diff changeset	141 {
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	142 op_asn_eq,
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	143 op_add_eq,
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	144 op_sub_eq,
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	145 op_mul_eq,
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	146 op_div_eq,
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	147 op_ldiv_eq,
4018 a8621d87fbf5 [project @ 2002-08-05 03:17:25 by jwe] jwe parents: 4015 diff changeset	148 op_pow_eq,
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	149 op_el_mul_eq,
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	150 op_el_div_eq,
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	151 op_el_ldiv_eq,
4018 a8621d87fbf5 [project @ 2002-08-05 03:17:25 by jwe] jwe parents: 4015 diff changeset	152 op_el_pow_eq,
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	153 op_el_and_eq,
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	154 op_el_or_eq,
2880 0a076230ca87 [project @ 1997-04-24 09:47:41 by jwe] jwe parents: 2847 diff changeset	155 num_assign_ops,
0a076230ca87 [project @ 1997-04-24 09:47:41 by jwe] jwe parents: 2847 diff changeset	156 unknown_assign_op
0a076230ca87 [project @ 1997-04-24 09:47:41 by jwe] jwe parents: 2847 diff changeset	157 };
0a076230ca87 [project @ 1997-04-24 09:47:41 by jwe] jwe parents: 2847 diff changeset	158
15140 6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15057 diff changeset	159 static binary_op assign_op_to_binary_op (assign_op);
6ea86e1d0f5f Support +=, -=, =, ect. in JIT Max Brister <max@2bass.com>* parents: 15057 diff changeset	160
9607 1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9521 diff changeset	161 static assign_op binary_op_to_assign_op (binary_op);
1be3c73ed7b5 reuse temporary arrays in nested expressions Jaroslav Hajek <highegg@gmail.com> parents: 9521 diff changeset	162
3523 b80bbb43a1a9 [project @ 2000-02-02 10:25:52 by jwe] jwe parents: 3503 diff changeset	163 static std::string unary_op_as_string (unary_op);
7336 745a8299c2b5 [project @ 2007-12-28 20:56:55 by jwe] jwe parents: 7064 diff changeset	164 static std::string unary_op_fcn_name (unary_op);
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	165
3523 b80bbb43a1a9 [project @ 2000-02-02 10:25:52 by jwe] jwe parents: 3503 diff changeset	166 static std::string binary_op_as_string (binary_op);
7336 745a8299c2b5 [project @ 2007-12-28 20:56:55 by jwe] jwe parents: 7064 diff changeset	167 static std::string binary_op_fcn_name (binary_op);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	168
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	169 static std::string binary_op_fcn_name (compound_binary_op);
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	170
3523 b80bbb43a1a9 [project @ 2000-02-02 10:25:52 by jwe] jwe parents: 3503 diff changeset	171 static std::string assign_op_as_string (assign_op);
2880 0a076230ca87 [project @ 1997-04-24 09:47:41 by jwe] jwe parents: 2847 diff changeset	172
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	173 static octave_value empty_conv (const std::string& type,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	174 const octave_value& rhs = octave_value ());
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	175
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	176 enum magic_colon { magic_colon_t };
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	177
8992 d12f44a5dce3 implement fast octave_value constructor Jaroslav Hajek <highegg@gmail.com> parents: 8982 diff changeset	178 octave_value (void)
21573 f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372) John W. Eaton <jwe@octave.org> parents: 20087 diff changeset	179 : rep (nil_rep ())
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	180 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	181 rep->count++;
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	182 }
8992 d12f44a5dce3 implement fast octave_value constructor Jaroslav Hajek <highegg@gmail.com> parents: 8982 diff changeset	183
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	184 octave_value (short int i);
df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	185 octave_value (unsigned short int i);
4233 ccfdb55c8156 [project @ 2002-12-20 22:43:54 by jwe] jwe parents: 4219 diff changeset	186 octave_value (int i);
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	187 octave_value (unsigned int i);
df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	188 octave_value (long int i);
df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	189 octave_value (unsigned long int i);
4353 ea4b8c35ac9d [project @ 2003-02-21 21:04:41 by jwe] jwe parents: 4346 diff changeset	190
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	191 // FIXME: These are kluges. They turn into doubles internally, which will
7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	192 // break for very large values. We just use them to store things like
7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	193 // 64-bit ino_t, etc, and hope that those values are never actually larger
7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	194 // than can be represented exactly in a double.
4353 ea4b8c35ac9d [project @ 2003-02-21 21:04:41 by jwe] jwe parents: 4346 diff changeset	195
21354 06d15e4e611a move public data type macros to octave-config.h John W. Eaton <jwe@octave.org> parents: 21294 diff changeset	196 #if defined (OCTAVE_HAVE_LONG_LONG_INT)
4353 ea4b8c35ac9d [project @ 2003-02-21 21:04:41 by jwe] jwe parents: 4346 diff changeset	197 octave_value (long long int i);
ea4b8c35ac9d [project @ 2003-02-21 21:04:41 by jwe] jwe parents: 4346 diff changeset	198 #endif
21354 06d15e4e611a move public data type macros to octave-config.h John W. Eaton <jwe@octave.org> parents: 21294 diff changeset	199 #if defined (OCTAVE_HAVE_UNSIGNED_LONG_LONG_INT)
4353 ea4b8c35ac9d [project @ 2003-02-21 21:04:41 by jwe] jwe parents: 4346 diff changeset	200 octave_value (unsigned long long int i);
ea4b8c35ac9d [project @ 2003-02-21 21:04:41 by jwe] jwe parents: 4346 diff changeset	201 #endif
ea4b8c35ac9d [project @ 2003-02-21 21:04:41 by jwe] jwe parents: 4346 diff changeset	202
21730 30c53770f47e use namespace for system time classes John W. Eaton <jwe@octave.org> parents: 21574 diff changeset	203 octave_value (octave::sys::time t);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	204 octave_value (double d);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	205 octave_value (float d);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	206 octave_value (const Array<octave_value>& a, bool is_cs_list = false);
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4513 diff changeset	207 octave_value (const Cell& c, bool is_cs_list = false);
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	208 octave_value (const Matrix& m, const MatrixType& t = MatrixType ());
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	209 octave_value (const FloatMatrix& m, const MatrixType& t = MatrixType ());
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4507 diff changeset	210 octave_value (const NDArray& nda);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	211 octave_value (const FloatNDArray& nda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	212 octave_value (const Array<double>& m);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	213 octave_value (const Array<float>& m);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	214 octave_value (const DiagMatrix& d);
15428 fd5c0159b588 Fix diag handling of diagvectors (bug #37411) Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 14138 diff changeset	215 octave_value (const DiagArray2<double>& d);
fd5c0159b588 Fix diag handling of diagvectors (bug #37411) Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 14138 diff changeset	216 octave_value (const DiagArray2<float>& d);
fd5c0159b588 Fix diag handling of diagvectors (bug #37411) Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 14138 diff changeset	217 octave_value (const DiagArray2<Complex>& d);
fd5c0159b588 Fix diag handling of diagvectors (bug #37411) Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 14138 diff changeset	218 octave_value (const DiagArray2<FloatComplex>& d);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	219 octave_value (const FloatDiagMatrix& d);
3418 ca92c9d3f882 [project @ 2000-01-12 03:07:47 by jwe] jwe parents: 3351 diff changeset	220 octave_value (const RowVector& v);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	221 octave_value (const FloatRowVector& v);
3418 ca92c9d3f882 [project @ 2000-01-12 03:07:47 by jwe] jwe parents: 3351 diff changeset	222 octave_value (const ColumnVector& v);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	223 octave_value (const FloatColumnVector& v);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	224 octave_value (const Complex& C);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	225 octave_value (const FloatComplex& C);
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	226 octave_value (const ComplexMatrix& m, const MatrixType& t = MatrixType ());
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	227 octave_value (const FloatComplexMatrix& m,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	228 const MatrixType& t = MatrixType ());
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4507 diff changeset	229 octave_value (const ComplexNDArray& cnda);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	230 octave_value (const FloatComplexNDArray& cnda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	231 octave_value (const Array<Complex>& m);
b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	232 octave_value (const Array<FloatComplex>& m);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	233 octave_value (const ComplexDiagMatrix& d);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	234 octave_value (const FloatComplexDiagMatrix& d);
3418 ca92c9d3f882 [project @ 2000-01-12 03:07:47 by jwe] jwe parents: 3351 diff changeset	235 octave_value (const ComplexRowVector& v);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	236 octave_value (const FloatComplexRowVector& v);
3418 ca92c9d3f882 [project @ 2000-01-12 03:07:47 by jwe] jwe parents: 3351 diff changeset	237 octave_value (const ComplexColumnVector& v);
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	238 octave_value (const FloatComplexColumnVector& v);
8960 93f18f166aba remove float perm matrices Jaroslav Hajek <highegg@gmail.com> parents: 8950 diff changeset	239 octave_value (const PermMatrix& p);
2825 60ae49e1284f [project @ 1997-03-25 23:17:36 by jwe] jwe parents: 2804 diff changeset	240 octave_value (bool b);
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	241 octave_value (const boolMatrix& bm, const MatrixType& t = MatrixType ());
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4507 diff changeset	242 octave_value (const boolNDArray& bnda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	243 octave_value (const Array<bool>& bnda);
9689 34d6f005db4b eliminate is_string argument from octave_value character array constructors John W. Eaton <jwe@octave.org> parents: 9685 diff changeset	244 octave_value (char c, char type = '\'');
34d6f005db4b eliminate is_string argument from octave_value character array constructors John W. Eaton <jwe@octave.org> parents: 9685 diff changeset	245 octave_value (const char *s, char type = '\'');
34d6f005db4b eliminate is_string argument from octave_value character array constructors John W. Eaton <jwe@octave.org> parents: 9685 diff changeset	246 octave_value (const std::string& s, char type = '\'');
34d6f005db4b eliminate is_string argument from octave_value character array constructors John W. Eaton <jwe@octave.org> parents: 9685 diff changeset	247 octave_value (const string_vector& s, char type = '\'');
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	248 octave_value (const charMatrix& chm, char type = '\'');
9689 34d6f005db4b eliminate is_string argument from octave_value character array constructors John W. Eaton <jwe@octave.org> parents: 9685 diff changeset	249 octave_value (const charNDArray& chnda, char type = '\'');
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	250 octave_value (const Array<char>& chnda, char type = '\'');
21134 2e5c1f766ac9 provide replacement hints for deprecated C++ functions John W. Eaton <jwe@octave.org> parents: 21076 diff changeset	251
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	252 octave_value (const SparseMatrix& m, const MatrixType& t = MatrixType ());
6863 3c64128e621c [project @ 2007-09-05 07:52:48 by dbateman] dbateman parents: 6705 diff changeset	253 octave_value (const Sparse<double>& m, const MatrixType& t = MatrixType ());
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	254 octave_value (const SparseComplexMatrix& m,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	255 const MatrixType& t = MatrixType ());
6863 3c64128e621c [project @ 2007-09-05 07:52:48 by dbateman] dbateman parents: 6705 diff changeset	256 octave_value (const Sparse<Complex>& m, const MatrixType& t = MatrixType ());
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	257 octave_value (const SparseBoolMatrix& bm,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	258 const MatrixType& t = MatrixType ());
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	259 octave_value (const Sparse<bool>& m, const MatrixType& t = MatrixType ());
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	260 octave_value (const octave_int8& i);
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	261 octave_value (const octave_int16& i);
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	262 octave_value (const octave_int32& i);
1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	263 octave_value (const octave_int64& i);
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	264 octave_value (const octave_uint8& i);
35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	265 octave_value (const octave_uint16& i);
35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	266 octave_value (const octave_uint32& i);
35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	267 octave_value (const octave_uint64& i);
35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	268 octave_value (const int8NDArray& inda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	269 octave_value (const Array<octave_int8>& inda);
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	270 octave_value (const int16NDArray& inda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	271 octave_value (const Array<octave_int16>& inda);
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	272 octave_value (const int32NDArray& inda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	273 octave_value (const Array<octave_int32>& inda);
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	274 octave_value (const int64NDArray& inda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	275 octave_value (const Array<octave_int64>& inda);
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	276 octave_value (const uint8NDArray& inda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	277 octave_value (const Array<octave_uint8>& inda);
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	278 octave_value (const uint16NDArray& inda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	279 octave_value (const Array<octave_uint16>& inda);
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	280 octave_value (const uint32NDArray& inda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	281 octave_value (const Array<octave_uint32>& inda);
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	282 octave_value (const uint64NDArray& inda);
9732 b4fdfee405b5 remove ArrayN<T> + fix nonhom. diag-scalar ops Jaroslav Hajek <highegg@gmail.com> parents: 9728 diff changeset	283 octave_value (const Array<octave_uint64>& inda);
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	284 octave_value (const Array<octave_idx_type>& inda,
9351 e2344f4af0cb autocache indices returned from find et al. Jaroslav Hajek <highegg@gmail.com> parents: 9329 diff changeset	285 bool zero_based = false, bool cache_index = false);
9725 aea3a3a950e1 implement nth_element Jaroslav Hajek <highegg@gmail.com> parents: 9703 diff changeset	286 octave_value (const Array<std::string>& cellstr);
10325 8b3cfc1288e2 implement lazy index conversions Jaroslav Hajek <highegg@gmail.com> parents: 10313 diff changeset	287 octave_value (const idx_vector& idx, bool lazy = true);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	288 octave_value (double base, double limit, double inc);
19394 b39cbe9f3bb0 allow ranges to be disabled John W. Eaton <jwe@octave.org> parents: 19110 diff changeset	289 octave_value (const Range& r, bool force_range = false);
10742 604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	290 octave_value (const octave_map& m);
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	291 octave_value (const octave_scalar_map& m);
23678 dcba41788495 new struct/map constructors John W. Eaton <jwe@octave.org> parents: 23615 diff changeset	292 octave_value (const std::map<std::string, octave_value>&);
18402 4c064d3d2750 Remove Octave_map class deprecated in 3.8. Rik <rik@octave.org> parents: 18130 diff changeset	293 octave_value (const octave_map& m, const std::string& id,
4c064d3d2750 Remove Octave_map class deprecated in 3.8. Rik <rik@octave.org> parents: 18130 diff changeset	294 const std::list<std::string>& plist);
4c064d3d2750 Remove Octave_map class deprecated in 3.8. Rik <rik@octave.org> parents: 18130 diff changeset	295 octave_value (const octave_scalar_map& m, const std::string& id,
13874 c1b754d93572 copy parent class info when performing operations on class objects John W. Eaton <jwe@octave.org> parents: 13736 diff changeset	296 const std::list<std::string>& plist);
23352 778fdffc09df deprecate "octave_value (octave_value_list, bool)" constructor John W. Eaton <jwe@octave.org> parents: 23220 diff changeset	297
23913 062ce545b21e mark octave_value from octave_value_list constructor explicit John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	298 // This one is explicit because it can cause some trouble to
062ce545b21e mark octave_value from octave_value_list constructor explicit John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	299 // accidentally create a cs-list when one was not intended.
062ce545b21e mark octave_value from octave_value_list constructor explicit John W. Eaton <jwe@octave.org> parents: 23881 diff changeset	300 explicit octave_value (const octave_value_list& m);
23352 778fdffc09df deprecate "octave_value (octave_value_list, bool)" constructor John W. Eaton <jwe@octave.org> parents: 23220 diff changeset	301
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	302 octave_value (octave_value::magic_colon);
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	303
9728 70925b11ba46 again allow the obsolete syntax for cellfun Jaroslav Hajek <highegg@gmail.com> parents: 9725 diff changeset	304 octave_value (octave_base_value *new_rep, bool borrow = false);
21134 2e5c1f766ac9 provide replacement hints for deprecated C++ functions John W. Eaton <jwe@octave.org> parents: 21076 diff changeset	305
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	306 // Copy constructor.
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	307
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	308 octave_value (const octave_value& a)
27352 7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	309 : rep (a.rep)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	310 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	311 rep->count++;
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	312 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	313
27352 7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	314 octave_value (octave_value&& a)
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	315 : rep (a.rep)
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	316 {
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	317 a.rep = nullptr;
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	318 }
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	319
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	320 // This should only be called for derived types.
f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	321
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	322 octave_base_value * clone (void) const;
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	323
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	324 octave_base_value * empty_clone (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	325 { return rep->empty_clone (); }
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	326
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	327 // Delete the representation of this constant if the count drops to zero.
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	328
6338 ec88b4ab6d10 [project @ 2007-02-22 07:07:19 by jwe] jwe parents: 6223 diff changeset	329 ~octave_value (void)
ec88b4ab6d10 [project @ 2007-02-22 07:07:19 by jwe] jwe parents: 6223 diff changeset	330 {
27352 7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	331 // Because we define a move constructor and a move assignment
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	332 // operator, rep may be a nullptr here. We should only need to
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	333 // protect the move assignment operator in a similar way.
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	334
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	335 if (rep && --rep->count == 0)
6338 ec88b4ab6d10 [project @ 2007-02-22 07:07:19 by jwe] jwe parents: 6223 diff changeset	336 delete rep;
ec88b4ab6d10 [project @ 2007-02-22 07:07:19 by jwe] jwe parents: 6223 diff changeset	337 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	338
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	339 void make_unique (void)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	340 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	341 if (rep->count > 1)
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	342 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	343 octave_base_value *r = rep->unique_clone ();
13985 43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC). Michael Goffioul <michael.goffioul@gmail.com> parents: 13874 diff changeset	344
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	345 if (--rep->count == 0)
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	346 delete rep;
13985 43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC). Michael Goffioul <michael.goffioul@gmail.com> parents: 13874 diff changeset	347
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	348 rep = r;
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	349 }
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	350 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	351
8546 3d8a914c580e improve parser indexed assigment code Jaroslav Hajek <highegg@gmail.com> parents: 8531 diff changeset	352 // This uniquifies the value if it is referenced by more than a certain
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	353 // number of shallow copies. This is useful for optimizations where we
8546 3d8a914c580e improve parser indexed assigment code Jaroslav Hajek <highegg@gmail.com> parents: 8531 diff changeset	354 // know a certain copy, typically within a cell array, to be obsolete.
3d8a914c580e improve parser indexed assigment code Jaroslav Hajek <highegg@gmail.com> parents: 8531 diff changeset	355 void make_unique (int obsolete_copies)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	356 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	357 if (rep->count > obsolete_copies + 1)
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	358 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	359 octave_base_value *r = rep->unique_clone ();
13985 43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC). Michael Goffioul <michael.goffioul@gmail.com> parents: 13874 diff changeset	360
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	361 if (--rep->count == 0)
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	362 delete rep;
13985 43cc49c7abd1 Use thread-safe atomic reference counting (GCC and MSVC). Michael Goffioul <michael.goffioul@gmail.com> parents: 13874 diff changeset	363
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	364 rep = r;
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	365 }
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	366 }
8546 3d8a914c580e improve parser indexed assigment code Jaroslav Hajek <highegg@gmail.com> parents: 8531 diff changeset	367
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	368 // Simple assignment.
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	369
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	370 octave_value& operator = (const octave_value& a)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	371 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	372 if (rep != a.rep)
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	373 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	374 if (--rep->count == 0)
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	375 delete rep;
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	376
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	377 rep = a.rep;
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	378 rep->count++;
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	379 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	380
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	381 return *this;
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	382 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	383
27352 7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	384 octave_value& operator = (octave_value&& a)
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	385 {
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	386 // Because we define a move constructor and a move assignment
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	387 // operator, rep may be a nullptr here. We should only need to
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	388 // protect the destructor in a similar way.
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	389
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	390 if (this != &a)
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	391 {
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	392 if (rep && --rep->count == 0)
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	393 delete rep;
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	394
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	395 rep = a.rep;
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	396 a.rep = nullptr;
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	397 }
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	398
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	399 return *this;
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	400 }
7335ebd4c798 define some move constructors and assignment operators John W. Eaton <jwe@octave.org> parents: 27216 diff changeset	401
9703 9a5598cf899d octave_value::get_count: return octave_idx_type, not int John W. Eaton <jwe@octave.org> parents: 9689 diff changeset	402 octave_idx_type get_count (void) const { return rep->count; }
3239 d54ef0aa6e82 [project @ 1999-03-27 17:40:45 by jwe] jwe parents: 3219 diff changeset	403
8345 c777f3ce02d8 smarter conversion lookup Jaroslav Hajek <highegg@gmail.com> parents: 8150 diff changeset	404 octave_base_value::type_conv_info numeric_conversion_function (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	405 { return rep->numeric_conversion_function (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	406
8345 c777f3ce02d8 smarter conversion lookup Jaroslav Hajek <highegg@gmail.com> parents: 8150 diff changeset	407 octave_base_value::type_conv_info numeric_demotion_function (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	408 { return rep->numeric_demotion_function (); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	409
2409 47e5f57fb4bd [project @ 1996-10-15 16:44:26 by jwe] jwe parents: 2376 diff changeset	410 void maybe_mutate (void);
47e5f57fb4bd [project @ 1996-10-15 16:44:26 by jwe] jwe parents: 2376 diff changeset	411
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	412 octave_value squeeze (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	413 { return rep->squeeze (); }
4532 01ee68d18069 [project @ 2003-10-10 00:49:54 by jwe] jwe parents: 4513 diff changeset	414
8458 d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8456 diff changeset	415 // The result of full().
d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8456 diff changeset	416 octave_value full_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	417 { return rep->full_value (); }
8458 d254a21e0120 reimplement full as method of octave_base_value Jaroslav Hajek <highegg@gmail.com> parents: 8456 diff changeset	418
22283 564203123065 move single and double type conversion functions to ov.cc John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	419 // Type conversions.
564203123065 move single and double type conversion functions to ov.cc John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	420
22296 8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	421 octave_value as_double (void) const { return rep->as_double (); }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	422 octave_value as_single (void) const { return rep->as_single (); }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	423
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	424 octave_value as_int8 (void) const { return rep->as_int8 (); }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	425 octave_value as_int16 (void) const { return rep->as_int16 (); }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	426 octave_value as_int32 (void) const { return rep->as_int32 (); }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	427 octave_value as_int64 (void) const { return rep->as_int64 (); }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	428
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	429 octave_value as_uint8 (void) const { return rep->as_uint8 (); }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	430 octave_value as_uint16 (void) const { return rep->as_uint16 (); }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	431 octave_value as_uint32 (void) const { return rep->as_uint32 (); }
8b18f46f6427 revamp double, single, int type conversions John W. Eaton <jwe@octave.org> parents: 22283 diff changeset	432 octave_value as_uint64 (void) const { return rep->as_uint64 (); }
22283 564203123065 move single and double type conversion functions to ov.cc John W. Eaton <jwe@octave.org> parents: 22197 diff changeset	433
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	434 octave_base_value * try_narrowing_conversion (void)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	435 { return rep->try_narrowing_conversion (); }
2409 47e5f57fb4bd [project @ 1996-10-15 16:44:26 by jwe] jwe parents: 2376 diff changeset	436
9329 67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9151 diff changeset	437 // Close to dims (), but can be overloaded for classes.
67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9151 diff changeset	438 Matrix size (void)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	439 { return rep->size (); }
9329 67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9151 diff changeset	440
26922 072d0610cc56 avoid some overloaded virtual warnings (bug #55741) John W. Eaton <jwe@octave.org> parents: 26916 diff changeset	441 // FIXME: should this function be deprecated and removed? It supports
072d0610cc56 avoid some overloaded virtual warnings (bug #55741) John W. Eaton <jwe@octave.org> parents: 26916 diff changeset	442 // an undocumented feature of Matlab.
072d0610cc56 avoid some overloaded virtual warnings (bug #55741) John W. Eaton <jwe@octave.org> parents: 26916 diff changeset	443 octave_idx_type xnumel (const octave_value_list& idx)
072d0610cc56 avoid some overloaded virtual warnings (bug #55741) John W. Eaton <jwe@octave.org> parents: 26916 diff changeset	444 { return rep->xnumel (idx); }
9329 67fc970dad7d improve indexed assignment using indexed numel Jaroslav Hajek <highegg@gmail.com> parents: 9151 diff changeset	445
26916 9cd4b045fe3d avoid some overloaded virtual warnings (bug #55741) John W. Eaton <jwe@octave.org> parents: 26655 diff changeset	446 // FIXME: Do we really need all these different versions of subsref
9cd4b045fe3d avoid some overloaded virtual warnings (bug #55741) John W. Eaton <jwe@octave.org> parents: 26655 diff changeset	447 // and related functions?
9cd4b045fe3d avoid some overloaded virtual warnings (bug #55741) John W. Eaton <jwe@octave.org> parents: 26655 diff changeset	448
4271 be631c1720ea [project @ 2003-01-03 19:36:04 by jwe] jwe parents: 4257 diff changeset	449 octave_value single_subsref (const std::string& type,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	450 const octave_value_list& idx);
4271 be631c1720ea [project @ 2003-01-03 19:36:04 by jwe] jwe parents: 4257 diff changeset	451
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	452 octave_value subsref (const std::string& type,
8551 906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8546 diff changeset	453 const std::list<octave_value_list>& idx)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	454 { return rep->subsref (type, idx); }
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	455
8551 906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8546 diff changeset	456 octave_value subsref (const std::string& type,
906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8546 diff changeset	457 const std::list<octave_value_list>& idx,
906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8546 diff changeset	458 bool auto_add)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	459 { return rep->subsref (type, idx, auto_add); }
8551 906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8546 diff changeset	460
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	461 octave_value_list subsref (const std::string& type,
8551 906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8546 diff changeset	462 const std::list<octave_value_list>& idx,
906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8546 diff changeset	463 int nargout);
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	464
4247 fc9a075d10fb [project @ 2002-12-30 23:05:27 by jwe] jwe parents: 4233 diff changeset	465 octave_value next_subsref (const std::string& type, const
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	466 std::list<octave_value_list>& idx,
f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	467 size_t skip = 1);
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	468
4994 48d0defe9445 [project @ 2004-09-15 20:31:31 by jwe] jwe parents: 4970 diff changeset	469 octave_value_list next_subsref (int nargout,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	470 const std::string& type, const
f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	471 std::list<octave_value_list>& idx,
f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	472 size_t skip = 1);
4994 48d0defe9445 [project @ 2004-09-15 20:31:31 by jwe] jwe parents: 4970 diff changeset	473
8551 906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8546 diff changeset	474 octave_value next_subsref (bool auto_add, const std::string& type, const
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	475 std::list<octave_value_list>& idx,
f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	476 size_t skip = 1);
8551 906f976d35a8 further improve struct&cell indexing & indexed assignment Jaroslav Hajek <highegg@gmail.com> parents: 8546 diff changeset	477
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	478 octave_value do_index_op (const octave_value_list& idx,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	479 bool resize_ok = false)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	480 { return rep->do_index_op (idx, resize_ok); }
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	481
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	482 octave_value subsasgn (const std::string& type,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	483 const std::list<octave_value_list>& idx,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	484 const octave_value& rhs);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	485
12171 d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	486 octave_value undef_subsasgn (const std::string& type,
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	487 const std::list<octave_value_list>& idx,
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	488 const octave_value& rhs);
d08901c05c1b fix bug in class assignment to undefined object with index John W. Eaton <jwe@octave.org> parents: 11586 diff changeset	489
10544 9961fc022d9d fix assignment to non-existing variables and octave_value::assign Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	490 octave_value& assign (assign_op op, const std::string& type,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	491 const std::list<octave_value_list>& idx,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	492 const octave_value& rhs);
2948 56be458e237f [project @ 1997-05-09 13:37:35 by jwe] jwe parents: 2942 diff changeset	493
10544 9961fc022d9d fix assignment to non-existing variables and octave_value::assign Jaroslav Hajek <highegg@gmail.com> parents: 10521 diff changeset	494 octave_value& assign (assign_op, const octave_value& rhs);
2948 56be458e237f [project @ 1997-05-09 13:37:35 by jwe] jwe parents: 2942 diff changeset	495
18130 e473c4853afc enable non-integer ranges as indices by default and deprecate preference John W. Eaton <jwe@octave.org> parents: 17870 diff changeset	496 idx_vector index_vector (bool require_integers = false) const
e473c4853afc enable non-integer ranges as indices by default and deprecate preference John W. Eaton <jwe@octave.org> parents: 17870 diff changeset	497 {
e473c4853afc enable non-integer ranges as indices by default and deprecate preference John W. Eaton <jwe@octave.org> parents: 17870 diff changeset	498 return rep->index_vector (require_integers);
e473c4853afc enable non-integer ranges as indices by default and deprecate preference John W. Eaton <jwe@octave.org> parents: 17870 diff changeset	499 }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	500
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	501 // Size.
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	502
26078 0549d088f50e move get_dims_str from variables.cc to octave_value class John W. Eaton <jwe@octave.org> parents: 25054 diff changeset	503 dim_vector dims (void) const { return rep->dims (); }
0549d088f50e move get_dims_str from variables.cc to octave_value class John W. Eaton <jwe@octave.org> parents: 25054 diff changeset	504
0549d088f50e move get_dims_str from variables.cc to octave_value class John W. Eaton <jwe@octave.org> parents: 25054 diff changeset	505 std::string get_dims_str (void) const;
4513 508238e65af7 [project @ 2003-09-19 21:40:57 by jwe] jwe parents: 4507 diff changeset	506
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	507 octave_idx_type rows (void) const { return rep->rows (); }
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	508
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	509 octave_idx_type columns (void) const { return rep->columns (); }
3195 7a5a5da64756 [project @ 1998-10-28 22:54:04 by jwe] jwe parents: 3189 diff changeset	510
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 5164 diff changeset	511 octave_idx_type length (void) const;
4554 78e34346f6fd [project @ 2003-10-27 22:01:49 by jwe] jwe parents: 4550 diff changeset	512
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	513 int ndims (void) const { return rep->ndims (); }
4563 742993a501b9 [project @ 2003-10-29 06:25:12 by jwe] jwe parents: 4559 diff changeset	514
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	515 bool all_zero_dims (void) const { return dims ().all_zero (); }
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5147 diff changeset	516
23590 eb3c7abad98f ov.h: Directly call replacement functions from deprecated functions. Rik <rik@octave.org> parents: 23589 diff changeset	517 // Are the dimensions of this constant zero by zero?
eb3c7abad98f ov.h: Directly call replacement functions from deprecated functions. Rik <rik@octave.org> parents: 23589 diff changeset	518 bool is_zero_by_zero (void) const
eb3c7abad98f ov.h: Directly call replacement functions from deprecated functions. Rik <rik@octave.org> parents: 23589 diff changeset	519 { return (ndims () == 2 && rows () == 0 && columns () == 0); }
eb3c7abad98f ov.h: Directly call replacement functions from deprecated functions. Rik <rik@octave.org> parents: 23589 diff changeset	520
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	521 octave_idx_type numel (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	522 { return rep->numel (); }
4559 802818bfac91 [project @ 2003-10-28 19:13:43 by jwe] jwe parents: 4554 diff changeset	523
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	524 size_t byte_size (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	525 { return rep->byte_size (); }
4791 62f2fb593455 [project @ 2004-02-20 18:02:59 by jwe] jwe parents: 4700 diff changeset	526
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	527 octave_idx_type nnz (void) const { return rep->nnz (); }
5602 dfa2da0563e5 [project @ 2006-01-31 03:43:40 by jwe] jwe parents: 5508 diff changeset	528
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	529 octave_idx_type nzmax (void) const { return rep->nzmax (); }
5604 2857357f9d3c [project @ 2006-01-31 18:22:59 by jwe] jwe parents: 5602 diff changeset	530
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5895 diff changeset	531 octave_idx_type nfields (void) const { return rep->nfields (); }
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5895 diff changeset	532
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	533 octave_value reshape (const dim_vector& dv) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	534 { return rep->reshape (dv); }
4567 fc30061d01da [project @ 2003-10-29 20:11:15 by jwe] jwe parents: 4563 diff changeset	535
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	536 octave_value permute (const Array<int>& vec, bool inv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	537 { return rep->permute (vec, inv); }
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4587 diff changeset	538
77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4587 diff changeset	539 octave_value ipermute (const Array<int>& vec) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	540 { return rep->permute (vec, true); }
4593 77566be8b9e9 [project @ 2003-11-11 17:25:42 by jwe] jwe parents: 4587 diff changeset	541
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	542 octave_value resize (const dim_vector& dv, bool fill = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	543 { return rep->resize (dv, fill);}
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	544
5785 6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	545 MatrixType matrix_type (void) const
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	546 { return rep->matrix_type (); }
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	547
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	548 MatrixType matrix_type (const MatrixType& typ) const
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	549 { return rep->matrix_type (typ); }
6b9cec830d72 [project @ 2006-05-03 19:32:46 by dbateman] dbateman parents: 5781 diff changeset	550
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	551 // Does this constant have a type? Both of these are provided since it is
7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	552 // sometimes more natural to write is_undefined() instead of ! is_defined().
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	553
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	554 bool is_defined (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	555 { return rep->is_defined (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	556
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	557 bool is_undefined (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	558 { return ! is_defined (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	559
23577 80c42f4cca13 maint: Deprecate is_empty and replace with isempty. Rik <rik@octave.org> parents: 23576 diff changeset	560 bool isempty (void) const
80c42f4cca13 maint: Deprecate is_empty and replace with isempty. Rik <rik@octave.org> parents: 23576 diff changeset	561 { return rep->isempty (); }
80c42f4cca13 maint: Deprecate is_empty and replace with isempty. Rik <rik@octave.org> parents: 23576 diff changeset	562
23576 00e518162fda maint: Deprecate is_cell and replace with iscell. Rik <rik@octave.org> parents: 23575 diff changeset	563 bool iscell (void) const
00e518162fda maint: Deprecate is_cell and replace with iscell. Rik <rik@octave.org> parents: 23575 diff changeset	564 { return rep->iscell (); }
00e518162fda maint: Deprecate is_cell and replace with iscell. Rik <rik@octave.org> parents: 23575 diff changeset	565
23575 e95738a119da maint: Deprecate is_cellstr and replace with iscellstr. Rik <rik@octave.org> parents: 23502 diff changeset	566 bool iscellstr (void) const
e95738a119da maint: Deprecate is_cellstr and replace with iscellstr. Rik <rik@octave.org> parents: 23502 diff changeset	567 { return rep->iscellstr (); }
e95738a119da maint: Deprecate is_cellstr and replace with iscellstr. Rik <rik@octave.org> parents: 23502 diff changeset	568
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	569 bool is_real_scalar (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	570 { return rep->is_real_scalar (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	571
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	572 bool is_real_matrix (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	573 { return rep->is_real_matrix (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	574
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	575 bool is_complex_scalar (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	576 { return rep->is_complex_scalar (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	577
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	578 bool is_complex_matrix (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	579 { return rep->is_complex_matrix (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	580
5881 70b3f8f1a793 [project @ 2006-07-08 03:54:17 by jwe] jwe parents: 5864 diff changeset	581 bool is_bool_scalar (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	582 { return rep->is_bool_scalar (); }
5881 70b3f8f1a793 [project @ 2006-07-08 03:54:17 by jwe] jwe parents: 5864 diff changeset	583
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	584 bool is_bool_matrix (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	585 { return rep->is_bool_matrix (); }
4587 7b957b442818 [project @ 2003-11-10 15:50:39 by jwe] jwe parents: 4567 diff changeset	586
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	587 bool is_char_matrix (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	588 { return rep->is_char_matrix (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	589
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8346 diff changeset	590 bool is_diag_matrix (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	591 { return rep->is_diag_matrix (); }
8366 8b1a2555c4e2 implement diagonal matrix objects Jaroslav Hajek <highegg@gmail.com> parents: 8346 diff changeset	592
8371 c3f7e2549abb make det & inv aware of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8367 diff changeset	593 bool is_perm_matrix (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	594 { return rep->is_perm_matrix (); }
8371 c3f7e2549abb make det & inv aware of diagonal & permutation matrices Jaroslav Hajek <highegg@gmail.com> parents: 8367 diff changeset	595
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	596 bool is_string (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	597 { return rep->is_string (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	598
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	599 bool is_sq_string (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	600 { return rep->is_sq_string (); }
5279 bd32f770c09a [project @ 2005-04-12 21:55:31 by jwe] jwe parents: 5275 diff changeset	601
5280 25c12c80ccc3 [project @ 2005-04-14 19:19:45 by jwe] jwe parents: 5279 diff changeset	602 bool is_dq_string (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	603 { return rep->is_string () && ! rep->is_sq_string (); }
5280 25c12c80ccc3 [project @ 2005-04-14 19:19:45 by jwe] jwe parents: 5279 diff changeset	604
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	605 bool is_range (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	606 { return rep->is_range (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	607
23584 7ed6b258db91 maint: Deprecate is_map and replace with isstruct. Rik <rik@octave.org> parents: 23583 diff changeset	608 bool isstruct (void) const
7ed6b258db91 maint: Deprecate is_map and replace with isstruct. Rik <rik@octave.org> parents: 23583 diff changeset	609 { return rep->isstruct (); }
7ed6b258db91 maint: Deprecate is_map and replace with isstruct. Rik <rik@octave.org> parents: 23583 diff changeset	610
23683 ffd27f53fc79 make +package function calls work again (bug #51295, #51296) John W. Eaton <jwe@octave.org> parents: 23680 diff changeset	611 bool is_classdef_meta (void) const
ffd27f53fc79 make +package function calls work again (bug #51295, #51296) John W. Eaton <jwe@octave.org> parents: 23680 diff changeset	612 { return rep->is_classdef_meta (); }
ffd27f53fc79 make +package function calls work again (bug #51295, #51296) John W. Eaton <jwe@octave.org> parents: 23680 diff changeset	613
19110 fa48651fbb8a isstruct for classdef objects should not return true. Michael Goffioul <michael.goffioul@gmail.com> parents: 19103 diff changeset	614 bool is_classdef_object (void) const
fa48651fbb8a isstruct for classdef objects should not return true. Michael Goffioul <michael.goffioul@gmail.com> parents: 19103 diff changeset	615 { return rep->is_classdef_object (); }
23843 a52eb3f210af maint: Strip trailing whitespace from source files. John W. Eaton <jwe@octave.org> parents: 23838 diff changeset	616
23865 d56c18dc1373 new predicates for classdef_superclass_ref objects John W. Eaton <jwe@octave.org> parents: 23843 diff changeset	617 bool is_classdef_superclass_ref (void) const
d56c18dc1373 new predicates for classdef_superclass_ref objects John W. Eaton <jwe@octave.org> parents: 23843 diff changeset	618 { return rep->is_classdef_superclass_ref (); }
d56c18dc1373 new predicates for classdef_superclass_ref objects John W. Eaton <jwe@octave.org> parents: 23843 diff changeset	619
23838 6e0fd7e3c262 Fix argument lookup in '+' package functions (Bug #51532). Piotr Held <pjheld@gmail.com> parents: 23683 diff changeset	620 bool is_package (void) const
6e0fd7e3c262 Fix argument lookup in '+' package functions (Bug #51532). Piotr Held <pjheld@gmail.com> parents: 23683 diff changeset	621 { return rep->is_package (); }
19110 fa48651fbb8a isstruct for classdef objects should not return true. Michael Goffioul <michael.goffioul@gmail.com> parents: 19103 diff changeset	622
23587 0c468af9dc00 maint: Deprecate is_object and replace with isobject. Rik <rik@octave.org> parents: 23586 diff changeset	623 bool isobject (void) const
0c468af9dc00 maint: Deprecate is_object and replace with isobject. Rik <rik@octave.org> parents: 23586 diff changeset	624 { return rep->isobject (); }
0c468af9dc00 maint: Deprecate is_object and replace with isobject. Rik <rik@octave.org> parents: 23586 diff changeset	625
23578 7b47b7c2d6c7 maint: Deprecate is_java and replace with isjava. Rik <rik@octave.org> parents: 23577 diff changeset	626 bool isjava (void) const
7b47b7c2d6c7 maint: Deprecate is_java and replace with isjava. Rik <rik@octave.org> parents: 23577 diff changeset	627 { return rep->isjava (); }
7b47b7c2d6c7 maint: Deprecate is_java and replace with isjava. Rik <rik@octave.org> parents: 23577 diff changeset	628
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	629 bool is_cs_list (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	630 { return rep->is_cs_list (); }
3977 95663a3a2682 [project @ 2002-07-05 17:43:37 by jwe] jwe parents: 3933 diff changeset	631
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	632 bool is_magic_colon (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	633 { return rep->is_magic_colon (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	634
23589 63950abd2f81 maint: Deprecate is_null_type and replace with isnull. Rik <rik@octave.org> parents: 23588 diff changeset	635 bool isnull (void) const
63950abd2f81 maint: Deprecate is_null_type and replace with isnull. Rik <rik@octave.org> parents: 23588 diff changeset	636 { return rep->isnull (); }
63950abd2f81 maint: Deprecate is_null_type and replace with isnull. Rik <rik@octave.org> parents: 23588 diff changeset	637
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	638 // Are any or all of the elements in this constant nonzero?
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	639
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	640 octave_value all (int dim = 0) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	641 { return rep->all (dim); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	642
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	643 octave_value any (int dim = 0) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	644 { return rep->any (dim); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	645
9685 e793865ede63 implement builtin_type Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	646 builtin_type_t builtin_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	647 { return rep->builtin_type (); }
9685 e793865ede63 implement builtin_type Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	648
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	649 // Floating point types.
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	650
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	651 bool is_double_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	652 { return rep->is_double_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	653
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	654 bool is_single_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	655 { return rep->is_single_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	656
23585 570170b6eb09 maint: Deprecate is_float_type and replace with isfloat. Rik <rik@octave.org> parents: 23584 diff changeset	657 bool isfloat (void) const
570170b6eb09 maint: Deprecate is_float_type and replace with isfloat. Rik <rik@octave.org> parents: 23584 diff changeset	658 { return rep->isfloat (); }
570170b6eb09 maint: Deprecate is_float_type and replace with isfloat. Rik <rik@octave.org> parents: 23584 diff changeset	659
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	660 // Integer types.
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	661
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	662 bool is_int8_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	663 { return rep->is_int8_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	664
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	665 bool is_int16_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	666 { return rep->is_int16_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	667
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	668 bool is_int32_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	669 { return rep->is_int32_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	670
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	671 bool is_int64_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	672 { return rep->is_int64_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	673
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	674 bool is_uint8_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	675 { return rep->is_uint8_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	676
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	677 bool is_uint16_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	678 { return rep->is_uint16_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	679
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	680 bool is_uint32_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	681 { return rep->is_uint32_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	682
b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	683 bool is_uint64_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	684 { return rep->is_uint64_type (); }
5895 b9c45e0cf685 [project @ 2006-07-19 01:57:44 by jwe] jwe parents: 5885 diff changeset	685
23586 f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23585 diff changeset	686 bool isinteger (void) const
f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23585 diff changeset	687 { return rep->isinteger (); }
f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23585 diff changeset	688
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	689 // Other type stuff.
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	690
23579 c20a0fa91c0c maint: Deprecate is_bool_type and replace with islogical. Rik <rik@octave.org> parents: 23578 diff changeset	691 bool islogical (void) const
c20a0fa91c0c maint: Deprecate is_bool_type and replace with islogical. Rik <rik@octave.org> parents: 23578 diff changeset	692 { return rep->islogical (); }
c20a0fa91c0c maint: Deprecate is_bool_type and replace with islogical. Rik <rik@octave.org> parents: 23578 diff changeset	693
23582 0cc2011d800e maint: Deprecate is_real_type and replace with isreal. Rik <rik@octave.org> parents: 23581 diff changeset	694 bool isreal (void) const
0cc2011d800e maint: Deprecate is_real_type and replace with isreal. Rik <rik@octave.org> parents: 23581 diff changeset	695 { return rep->isreal (); }
0cc2011d800e maint: Deprecate is_real_type and replace with isreal. Rik <rik@octave.org> parents: 23581 diff changeset	696
23581 c3075ae020e1 maint: Deprecate is_complex_type and replace with iscomplex. Rik <rik@octave.org> parents: 23580 diff changeset	697 bool iscomplex (void) const
c3075ae020e1 maint: Deprecate is_complex_type and replace with iscomplex. Rik <rik@octave.org> parents: 23580 diff changeset	698 { return rep->iscomplex (); }
c3075ae020e1 maint: Deprecate is_complex_type and replace with iscomplex. Rik <rik@octave.org> parents: 23580 diff changeset	699
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	700 bool is_scalar_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	701 { return rep->is_scalar_type (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	702
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	703 bool is_matrix_type (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	704 { return rep->is_matrix_type (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	705
23586 f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23585 diff changeset	706 bool isnumeric (void) const
f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23585 diff changeset	707 { return rep->isnumeric (); }
f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23585 diff changeset	708
23583 b7747a2c88b2 maint: Deprecate is_sparse_type and replace with issparse. Rik <rik@octave.org> parents: 23582 diff changeset	709 bool issparse (void) const
b7747a2c88b2 maint: Deprecate is_sparse_type and replace with issparse. Rik <rik@octave.org> parents: 23582 diff changeset	710 { return rep->issparse (); }
b7747a2c88b2 maint: Deprecate is_sparse_type and replace with issparse. Rik <rik@octave.org> parents: 23582 diff changeset	711
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	712 // Does this constant correspond to a truth value?
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	713
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	714 bool is_true (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	715 { return rep->is_true (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	716
8346 8302788f09db fix empty matrix handling in switch statement Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	717 // Do two constants match (in a switch statement)?
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	718
8346 8302788f09db fix empty matrix handling in switch statement Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	719 bool is_equal (const octave_value&) const;
8302788f09db fix empty matrix handling in switch statement Jaroslav Hajek <highegg@gmail.com> parents: 8345 diff changeset	720
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	721 bool is_constant (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	722 { return rep->is_constant (); }
2974 ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2963 diff changeset	723
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	724 bool is_function_handle (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	725 { return rep->is_function_handle (); }
4654 a9b22513b7a6 [project @ 2003-11-24 18:56:35 by jwe] jwe parents: 4645 diff changeset	726
13241 2a8dcb5b3a00 improve default indexing for objects John W. Eaton <jwe@octave.org> parents: 13110 diff changeset	727 bool is_anonymous_function (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	728 { return rep->is_anonymous_function (); }
13241 2a8dcb5b3a00 improve default indexing for objects John W. Eaton <jwe@octave.org> parents: 13110 diff changeset	729
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	730 bool is_inline_function (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	731 { return rep->is_inline_function (); }
4954 ed0f3cb6d3d4 [project @ 2004-09-01 21:24:53 by jwe] jwe parents: 4946 diff changeset	732
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	733 bool is_function (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	734 { return rep->is_function (); }
2891 1a30f46e1870 [project @ 1997-04-28 01:49:00 by jwe] jwe parents: 2880 diff changeset	735
7336 745a8299c2b5 [project @ 2007-12-28 20:56:55 by jwe] jwe parents: 7064 diff changeset	736 bool is_user_script (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	737 { return rep->is_user_script (); }
7336 745a8299c2b5 [project @ 2007-12-28 20:56:55 by jwe] jwe parents: 7064 diff changeset	738
745a8299c2b5 [project @ 2007-12-28 20:56:55 by jwe] jwe parents: 7064 diff changeset	739 bool is_user_function (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	740 { return rep->is_user_function (); }
7336 745a8299c2b5 [project @ 2007-12-28 20:56:55 by jwe] jwe parents: 7064 diff changeset	741
7719 87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	742 bool is_user_code (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	743 { return rep->is_user_code (); }
7719 87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	744
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	745 bool is_builtin_function (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	746 { return rep->is_builtin_function (); }
3325 2efa28a91e7a [project @ 1999-10-29 21:39:20 by jwe] jwe parents: 3301 diff changeset	747
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	748 bool is_dld_function (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	749 { return rep->is_dld_function (); }
3325 2efa28a91e7a [project @ 1999-10-29 21:39:20 by jwe] jwe parents: 3301 diff changeset	750
5864 e884ab4f29ee [project @ 2006-06-22 00:57:27 by jwe] jwe parents: 5848 diff changeset	751 bool is_mex_function (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	752 { return rep->is_mex_function (); }
5864 e884ab4f29ee [project @ 2006-06-22 00:57:27 by jwe] jwe parents: 5848 diff changeset	753
7876 8447a5024650 clear subfunctions when clearing parent function John W. Eaton <jwe@octave.org> parents: 7800 diff changeset	754 void erase_subfunctions (void) { rep->erase_subfunctions (); }
8447a5024650 clear subfunctions when clearing parent function John W. Eaton <jwe@octave.org> parents: 7800 diff changeset	755
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	756 // Values.
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	757
2891 1a30f46e1870 [project @ 1997-04-28 01:49:00 by jwe] jwe parents: 2880 diff changeset	758 octave_value eval (void) { return *this; }
1a30f46e1870 [project @ 1997-04-28 01:49:00 by jwe] jwe parents: 2880 diff changeset	759
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	760 short int
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	761 short_value (bool req_int = false, bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	762 { return rep->short_value (req_int, frc_str_conv); }
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	763
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	764 unsigned short int
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	765 ushort_value (bool req_int = false, bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	766 { return rep->ushort_value (req_int, frc_str_conv); }
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	767
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	768 int int_value (bool req_int = false, bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	769 { return rep->int_value (req_int, frc_str_conv); }
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	770
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	771 unsigned int
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	772 uint_value (bool req_int = false, bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	773 { return rep->uint_value (req_int, frc_str_conv); }
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	774
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	775 int nint_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	776 { return rep->nint_value (frc_str_conv); }
3202 44d82b369c78 [project @ 1998-10-29 20:27:57 by jwe] jwe parents: 3195 diff changeset	777
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	778 long int
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	779 long_value (bool req_int = false, bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	780 { return rep->long_value (req_int, frc_str_conv); }
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	781
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	782 unsigned long int
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	783 ulong_value (bool req_int = false, bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	784 { return rep->ulong_value (req_int, frc_str_conv); }
4254 df5f2e433a11 [project @ 2002-12-31 19:43:07 by jwe] jwe parents: 4252 diff changeset	785
16323 e769440b39db provide int64 extractors for octave_value class John W. Eaton <jwe@octave.org> parents: 16091 diff changeset	786 int64_t
e769440b39db provide int64 extractors for octave_value class John W. Eaton <jwe@octave.org> parents: 16091 diff changeset	787 int64_value (bool req_int = false, bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	788 { return rep->int64_value (req_int, frc_str_conv); }
16323 e769440b39db provide int64 extractors for octave_value class John W. Eaton <jwe@octave.org> parents: 16091 diff changeset	789
e769440b39db provide int64 extractors for octave_value class John W. Eaton <jwe@octave.org> parents: 16091 diff changeset	790 uint64_t
e769440b39db provide int64 extractors for octave_value class John W. Eaton <jwe@octave.org> parents: 16091 diff changeset	791 uint64_value (bool req_int = false, bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	792 { return rep->uint64_value (req_int, frc_str_conv); }
16323 e769440b39db provide int64 extractors for octave_value class John W. Eaton <jwe@octave.org> parents: 16091 diff changeset	793
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 6116 diff changeset	794 octave_idx_type
8017 260294a5520f octave_value::idx_type_value: move definition to ov.cc from ov.h John W. Eaton <jwe@octave.org> parents: 7885 diff changeset	795 idx_type_value (bool req_int = false, bool frc_str_conv = false) const;
6133 e0065af38cf4 [project @ 2006-11-02 03:33:50 by jwe] jwe parents: 6116 diff changeset	796
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	797 double double_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	798 { return rep->double_value (frc_str_conv); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	799
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	800 float float_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	801 { return rep->float_value (frc_str_conv); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	802
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	803 double scalar_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	804 { return rep->scalar_value (frc_str_conv); }
2916 4e7bea116f24 [project @ 1997-04-30 20:56:31 by jwe] jwe parents: 2909 diff changeset	805
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	806 float float_scalar_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	807 { return rep->float_scalar_value (frc_str_conv); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	808
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	809 Matrix matrix_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	810 { return rep->matrix_value (frc_str_conv); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	811
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	812 FloatMatrix float_matrix_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	813 { return rep->float_matrix_value (frc_str_conv); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	814
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	815 NDArray array_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	816 { return rep->array_value (frc_str_conv); }
4505 e944fbe3fff2 [project @ 2003-09-09 19:14:06 by jwe] jwe parents: 4478 diff changeset	817
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	818 FloatNDArray float_array_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	819 { return rep->float_array_value (frc_str_conv); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	820
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	821 Complex complex_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	822 { return rep->complex_value (frc_str_conv); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	823
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	824 FloatComplex float_complex_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	825 { return rep->float_complex_value (frc_str_conv); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	826
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	827 ComplexMatrix complex_matrix_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	828 { return rep->complex_matrix_value (frc_str_conv); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	829
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	830 FloatComplexMatrix
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	831 float_complex_matrix_value (bool frc_str_conv = false) const
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	832 { return rep->float_complex_matrix_value (frc_str_conv); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	833
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	834 ComplexNDArray complex_array_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	835 { return rep->complex_array_value (frc_str_conv); }
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	836
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	837 FloatComplexNDArray
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	838 float_complex_array_value (bool frc_str_conv = false) const
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	839 { return rep->float_complex_array_value (frc_str_conv); }
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	840
5943 c038c2947ee1 [project @ 2006-08-18 21:27:03 by jwe] jwe parents: 5900 diff changeset	841 bool bool_value (bool warn = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	842 { return rep->bool_value (warn); }
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	843
5943 c038c2947ee1 [project @ 2006-08-18 21:27:03 by jwe] jwe parents: 5900 diff changeset	844 boolMatrix bool_matrix_value (bool warn = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	845 { return rep->bool_matrix_value (warn); }
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	846
5943 c038c2947ee1 [project @ 2006-08-18 21:27:03 by jwe] jwe parents: 5900 diff changeset	847 boolNDArray bool_array_value (bool warn = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	848 { return rep->bool_array_value (warn); }
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	849
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	850 charMatrix char_matrix_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	851 { return rep->char_matrix_value (frc_str_conv); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	852
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	853 charNDArray char_array_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	854 { return rep->char_array_value (frc_str_conv); }
4550 69a9b22a72a2 [project @ 2003-10-27 15:41:55 by jwe] jwe parents: 4532 diff changeset	855
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	856 SparseMatrix sparse_matrix_value (bool frc_str_conv = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	857 { return rep->sparse_matrix_value (frc_str_conv); }
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5147 diff changeset	858
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	859 SparseComplexMatrix
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	860 sparse_complex_matrix_value (bool frc_str_conv = false) const
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	861 { return rep->sparse_complex_matrix_value (frc_str_conv); }
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5147 diff changeset	862
9852 aabf7a8c2e57 implement sparse logical conversion Jaroslav Hajek <highegg@gmail.com> parents: 9835 diff changeset	863 SparseBoolMatrix sparse_bool_matrix_value (bool warn = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	864 { return rep->sparse_bool_matrix_value (warn); }
5164 57077d0ddc8e [project @ 2005-02-25 19:55:24 by jwe] jwe parents: 5147 diff changeset	865
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8811 diff changeset	866 DiagMatrix diag_matrix_value (bool force = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	867 { return rep->diag_matrix_value (force); }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	868
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8811 diff changeset	869 FloatDiagMatrix float_diag_matrix_value (bool force = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	870 { return rep->float_diag_matrix_value (force); }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	871
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8811 diff changeset	872 ComplexDiagMatrix complex_diag_matrix_value (bool force = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	873 { return rep->complex_diag_matrix_value (force); }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	874
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	875 FloatComplexDiagMatrix
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	876 float_complex_diag_matrix_value (bool force = false) const
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	877 { return rep->float_complex_diag_matrix_value (force); }
8916 a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8811 diff changeset	878
a2878ba31a9e add diag & perm matrix query methods to octave_value Jaroslav Hajek <highegg@gmail.com> parents: 8811 diff changeset	879 PermMatrix perm_matrix_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	880 { return rep->perm_matrix_value (); }
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	881
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	882 octave_int8 int8_scalar_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	883 { return rep->int8_scalar_value (); }
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	884
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	885 octave_int16 int16_scalar_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	886 { return rep->int16_scalar_value (); }
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	887
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	888 octave_int32 int32_scalar_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	889 { return rep->int32_scalar_value (); }
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	890
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	891 octave_int64 int64_scalar_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	892 { return rep->int64_scalar_value (); }
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	893
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	894 octave_uint8 uint8_scalar_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	895 { return rep->uint8_scalar_value (); }
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	896
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	897 octave_uint16 uint16_scalar_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	898 { return rep->uint16_scalar_value (); }
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	899
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	900 octave_uint32 uint32_scalar_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	901 { return rep->uint32_scalar_value (); }
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	902
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	903 octave_uint64 uint64_scalar_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	904 { return rep->uint64_scalar_value (); }
4910 1242acab4246 [project @ 2004-07-12 17:14:13 by jwe] jwe parents: 4906 diff changeset	905
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	906 int8NDArray int8_array_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	907 { return rep->int8_array_value (); }
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4901 diff changeset	908
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	909 int16NDArray int16_array_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	910 { return rep->int16_array_value (); }
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4901 diff changeset	911
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	912 int32NDArray int32_array_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	913 { return rep->int32_array_value (); }
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4901 diff changeset	914
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	915 int64NDArray int64_array_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	916 { return rep->int64_array_value (); }
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4901 diff changeset	917
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	918 uint8NDArray uint8_array_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	919 { return rep->uint8_array_value (); }
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4901 diff changeset	920
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	921 uint16NDArray uint16_array_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	922 { return rep->uint16_array_value (); }
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4901 diff changeset	923
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	924 uint32NDArray uint32_array_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	925 { return rep->uint32_array_value (); }
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4901 diff changeset	926
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	927 uint64NDArray uint64_array_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	928 { return rep->uint64_array_value (); }
4906 6754342ef7ad [project @ 2004-06-23 11:11:50 by jwe] jwe parents: 4901 diff changeset	929
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	930 std::string string_value (bool force = false) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	931 { return rep->string_value (force); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	932
20990 fc9cca99b2de Deprecate all_strings, replace with string_vector_value. Rik <rik@octave.org> parents: 20791 diff changeset	933 string_vector string_vector_value (bool pad = false) const
fc9cca99b2de Deprecate all_strings, replace with string_vector_value. Rik <rik@octave.org> parents: 20791 diff changeset	934 { return rep->string_vector_value (pad); }
fc9cca99b2de Deprecate all_strings, replace with string_vector_value. Rik <rik@octave.org> parents: 20791 diff changeset	935
20703 85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	936 Cell cell_value (void) const;
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	937
8732 a669df7beb73 [mq]: x John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	938 Array<std::string> cellstr_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	939 { return rep->cellstr_value (); }
8732 a669df7beb73 [mq]: x John W. Eaton <jwe@octave.org> parents: 8721 diff changeset	940
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	941 Range range_value (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	942 { return rep->range_value (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	943
10742 604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	944 octave_map map_value (void) const;
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	945
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	946 octave_scalar_map scalar_map_value (void) const;
604e13a89c7f initial code for structs rewrite Jaroslav Hajek <highegg@gmail.com> parents: 10670 diff changeset	947
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	948 string_vector map_keys (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	949 { return rep->map_keys (); }
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	950
9151 d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9010 diff changeset	951 size_t nparents (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	952 { return rep->nparents (); }
9151 d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9010 diff changeset	953
d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9010 diff changeset	954 std::list<std::string> parent_class_name_list (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	955 { return rep->parent_class_name_list (); }
9151 d8f9588c6ba1 object exemplars John W. Eaton <jwe@octave.org> parents: 9010 diff changeset	956
9010 f914834836e7 Partial implementation of derived classes using the old form with "@" files. rtshort@smoketree.phaselocked.com parents: 8992 diff changeset	957 string_vector parent_class_names (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	958 { return rep->parent_class_names (); }
9010 f914834836e7 Partial implementation of derived classes using the old form with "@" files. rtshort@smoketree.phaselocked.com parents: 8992 diff changeset	959
f914834836e7 Partial implementation of derived classes using the old form with "@" files. rtshort@smoketree.phaselocked.com parents: 8992 diff changeset	960 octave_base_value *
f914834836e7 Partial implementation of derived classes using the old form with "@" files. rtshort@smoketree.phaselocked.com parents: 8992 diff changeset	961 find_parent_class (const std::string& parent_class_name)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	962 { return rep->find_parent_class (parent_class_name); }
9010 f914834836e7 Partial implementation of derived classes using the old form with "@" files. rtshort@smoketree.phaselocked.com parents: 8992 diff changeset	963
19103 56bc1464ec59 Implement "isa" for classdef objects. Michael Goffioul <michael.goffioul@gmail.com> parents: 18416 diff changeset	964 bool is_instance_of (const std::string& cls_name) const
56bc1464ec59 Implement "isa" for classdef objects. Michael Goffioul <michael.goffioul@gmail.com> parents: 18416 diff changeset	965 { return rep->is_instance_of (cls_name); }
56bc1464ec59 Implement "isa" for classdef objects. Michael Goffioul <michael.goffioul@gmail.com> parents: 18416 diff changeset	966
23881 5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23865 diff changeset	967 octave_classdef * classdef_object_value (bool silent = false) const;
5aec653c88e7 new function for accessing classdef objects John W. Eaton <jwe@octave.org> parents: 23865 diff changeset	968
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	969 octave_function * function_value (bool silent = false) const;
2974 ebbc34ff7f66 [project @ 1997-05-15 19:36:16 by jwe] jwe parents: 2963 diff changeset	970
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	971 octave_user_function * user_function_value (bool silent = false) const;
7761 5adeea5de26c symbol table reporting functions John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	972
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	973 octave_user_script * user_script_value (bool silent = false) const;
4700 ca3a1d687bba [project @ 2004-01-21 03:28:31 by jwe] jwe parents: 4687 diff changeset	974
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	975 octave_user_code * user_code_value (bool silent = false) const;
7719 87eda1f8faaa octave_user_code: new base class for octave_user_script and octave_user_function John W. Eaton <jwe@octave.org> parents: 7638 diff changeset	976
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	977 octave_fcn_handle * fcn_handle_value (bool silent = false) const;
4343 db5e0814277a [project @ 2003-02-20 16:44:16 by jwe] jwe parents: 4342 diff changeset	978
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	979 octave_fcn_inline * fcn_inline_value (bool silent = false) const;
4933 cd58733c326b [project @ 2004-08-05 16:08:28 by jwe] jwe parents: 4930 diff changeset	980
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	981 octave_value_list list_value (void) const;
2880 0a076230ca87 [project @ 1997-04-24 09:47:41 by jwe] jwe parents: 2847 diff changeset	982
3419 e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	983 ColumnVector column_vector_value (bool frc_str_conv = false,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	984 bool frc_vec_conv = false) const;
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	985
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	986 ComplexColumnVector
3419 e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	987 complex_column_vector_value (bool frc_str_conv = false,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	988 bool frc_vec_conv = false) const;
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	989
3419 e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	990 RowVector row_vector_value (bool frc_str_conv = false,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	991 bool frc_vec_conv = false) const;
3419 e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	992
e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	993 ComplexRowVector
e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	994 complex_row_vector_value (bool frc_str_conv = false,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	995 bool frc_vec_conv = false) const;
3419 e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	996
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	997 FloatColumnVector float_column_vector_value (bool frc_str_conv = false,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	998 bool frc_vec_conv = false) const;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	999
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1000 FloatComplexColumnVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1001 float_complex_column_vector_value (bool frc_str_conv = false,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1002 bool frc_vec_conv = false) const;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1003
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1004 FloatRowVector float_row_vector_value (bool frc_str_conv = false,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1005 bool frc_vec_conv = false) const;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1006
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1007 FloatComplexRowVector
82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1008 float_complex_row_vector_value (bool frc_str_conv = false,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1009 bool frc_vec_conv = false) const;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1010
4044 9678c5526190 [project @ 2002-08-15 16:54:55 by jwe] jwe parents: 4018 diff changeset	1011 Array<int> int_vector_value (bool req_int = false,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	1012 bool frc_str_conv = false,
f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	1013 bool frc_vec_conv = false) const;
4044 9678c5526190 [project @ 2002-08-15 16:54:55 by jwe] jwe parents: 4018 diff changeset	1014
8811 20dfb885f877 int -> octave_idx fixes John W. Eaton <jwe@octave.org> parents: 8734 diff changeset	1015 Array<octave_idx_type>
20dfb885f877 int -> octave_idx fixes John W. Eaton <jwe@octave.org> parents: 8734 diff changeset	1016 octave_idx_type_vector_value (bool req_int = false,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	1017 bool frc_str_conv = false,
f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	1018 bool frc_vec_conv = false) const;
8811 20dfb885f877 int -> octave_idx fixes John W. Eaton <jwe@octave.org> parents: 8734 diff changeset	1019
3419 e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	1020 Array<double> vector_value (bool frc_str_conv = false,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	1021 bool frc_vec_conv = false) const;
3419 e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	1022
e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	1023 Array<Complex> complex_vector_value (bool frc_str_conv = false,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	1024 bool frc_vec_conv = false) const;
3419 e71b3d1dd327 [project @ 2000-01-12 05:23:34 by jwe] jwe parents: 3418 diff changeset	1025
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1026 Array<float> float_vector_value (bool frc_str_conv = false,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1027 bool frc_vec_conv = false) const;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1028
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1029 Array<FloatComplex>
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1030 float_complex_vector_value (bool frc_str_conv = false,
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1031 bool frc_vec_conv = false) const;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7761 diff changeset	1032
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1033 // Extract values of specific types without any implicit type conversions.
7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1034 // Throw an error if an object is the wrong type for the requested value
7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1035 // extraction.
20700 68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20696 diff changeset	1036 //
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1037 // These functions are intended to provide a simple way to extract values of
7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1038 // specific types and display error messages that are more meaningful than
7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1039 // the generic "error: wrong type argument 'cell'" message.
20700 68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20696 diff changeset	1040
20703 85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1041 short int xshort_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1042
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1043 unsigned short int xushort_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1044
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1045 int xint_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1046
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1047 unsigned int xuint_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1048
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1049 int xnint_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1050
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1051 long int xlong_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1052
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1053 unsigned long int xulong_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1054
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1055 int64_t xint64_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1056
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1057 uint64_t xuint64_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1058
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1059 octave_idx_type xidx_type_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1060
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1061 double xdouble_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1062
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1063 float xfloat_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1064
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1065 double xscalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1066
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1067 float xfloat_scalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1068
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1069 Matrix xmatrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1070
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1071 FloatMatrix xfloat_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1072
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1073 NDArray xarray_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1074
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1075 FloatNDArray xfloat_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1076
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1077 Complex xcomplex_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1078
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1079 FloatComplex xfloat_complex_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1080
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1081 ComplexMatrix xcomplex_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1082
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1083 FloatComplexMatrix xfloat_complex_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1084
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1085 ComplexNDArray xcomplex_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1086
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1087 FloatComplexNDArray xfloat_complex_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1088
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1089 bool xbool_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1090
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1091 boolMatrix xbool_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1092
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1093 boolNDArray xbool_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1094
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1095 charMatrix xchar_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1096
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1097 charNDArray xchar_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1098
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1099 SparseMatrix xsparse_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1100
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1101 SparseComplexMatrix xsparse_complex_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1102
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1103 SparseBoolMatrix xsparse_bool_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1104
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1105 DiagMatrix xdiag_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1106
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1107 FloatDiagMatrix xfloat_diag_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1108
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1109 ComplexDiagMatrix xcomplex_diag_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1110
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1111 FloatComplexDiagMatrix xfloat_complex_diag_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1112
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1113 PermMatrix xperm_matrix_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1114
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1115 octave_int8 xint8_scalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1116
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1117 octave_int16 xint16_scalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1118
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1119 octave_int32 xint32_scalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1120
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1121 octave_int64 xint64_scalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1122
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1123 octave_uint8 xuint8_scalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1124
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1125 octave_uint16 xuint16_scalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1126
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1127 octave_uint32 xuint32_scalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1128
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1129 octave_uint64 xuint64_scalar_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1130
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1131 int8NDArray xint8_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1132
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1133 int16NDArray xint16_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1134
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1135 int32NDArray xint32_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1136
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1137 int64NDArray xint64_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1138
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1139 uint8NDArray xuint8_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1140
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1141 uint16NDArray xuint16_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1142
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1143 uint32NDArray xuint32_array_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1144
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1145 uint64NDArray xuint64_array_value (const char *fmt, ...) const;
20700 68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20696 diff changeset	1146
68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20696 diff changeset	1147 std::string xstring_value (const char *fmt, ...) const;
68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20696 diff changeset	1148
20990 fc9cca99b2de Deprecate all_strings, replace with string_vector_value. Rik <rik@octave.org> parents: 20791 diff changeset	1149 string_vector xstring_vector_value (const char *fmt, ...) const;
20704 571508c1ed06 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20703 diff changeset	1150
20703 85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1151 Cell xcell_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1152
20700 68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20696 diff changeset	1153 Array<std::string> xcellstr_value (const char *fmt, ...) const;
68e3a747ca02 rename octave_value value extractors that accept error message args John W. Eaton <jwe@octave.org> parents: 20696 diff changeset	1154
20703 85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1155 Range xrange_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1156
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1157 octave_map xmap_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1158
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1159 octave_scalar_map xscalar_map_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1160
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1161 ColumnVector xcolumn_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1162
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1163 ComplexColumnVector
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1164 xcomplex_column_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1165
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1166 RowVector xrow_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1167
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1168 ComplexRowVector xcomplex_row_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1169
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1170 FloatColumnVector xfloat_column_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1171
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1172 FloatComplexColumnVector
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1173 xfloat_complex_column_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1174
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1175 FloatRowVector xfloat_row_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1176
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1177 FloatComplexRowVector
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1178 xfloat_complex_row_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1179
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1180 Array<int> xint_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1181
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1182 Array<octave_idx_type>
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1183 xoctave_idx_type_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1184
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1185 Array<double> xvector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1186
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1187 Array<Complex> xcomplex_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1188
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1189 Array<float> xfloat_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1190
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1191 Array<FloatComplex> xfloat_complex_vector_value (const char *fmt, ...) const;
85e5efae848a eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20700 diff changeset	1192
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	1193 octave_function * xfunction_value (const char *fmt, ...) const;
cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	1194 octave_user_function * xuser_function_value (const char *fmt, ...) const;
cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	1195 octave_user_script * xuser_script_value (const char *fmt, ...) const;
cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	1196 octave_user_code * xuser_code_value (const char *fmt, ...) const;
cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	1197 octave_fcn_handle * xfcn_handle_value (const char *fmt, ...) const;
cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	1198 octave_fcn_inline * xfcn_inline_value (const char *fmt, ...) const;
20741 a5ab31b52ae8 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20704 diff changeset	1199
a5ab31b52ae8 eliminate more uses of error_state John W. Eaton <jwe@octave.org> parents: 20704 diff changeset	1200 octave_value_list xlist_value (const char *fmt, ...) const;
20768 7655b399abff eliminate trailing whitespace in source files we maintain John W. Eaton <jwe@octave.org> parents: 20741 diff changeset	1201
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1202 // Possibly economize a lazy-indexed value.
8150 283989f2da9b make null assignment matlab compatible Jaroslav Hajek <highegg@gmail.com> parents: 8017 diff changeset	1203
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1204 void maybe_economize (void)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1205 { rep->maybe_economize (); }
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1206
8531 b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8523 diff changeset	1207 // The following two hook conversions are called on any octave_value prior to
b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8523 diff changeset	1208 // storing it to a "permanent" location, like a named variable, a cell or a
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11523 diff changeset	1209 // struct component, or a return value of a function.
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1210
ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1211 octave_value storable_value (void) const;
8150 283989f2da9b make null assignment matlab compatible Jaroslav Hajek <highegg@gmail.com> parents: 8017 diff changeset	1212
21751 b571fc85953f maint: Use two spaces after period to indicate sentence break. Rik <rik@octave.org> parents: 21739 diff changeset	1213 // Ditto, but in place, i.e., equivalent to *this = this->storable_value (),
8531 b01fef323c24 add some explaining comments Jaroslav Hajek <highegg@gmail.com> parents: 8523 diff changeset	1214 // but possibly more efficient.
8150 283989f2da9b make null assignment matlab compatible Jaroslav Hajek <highegg@gmail.com> parents: 8017 diff changeset	1215
8523 ad3afaaa19c1 implement non-copying contiguous range indexing Jaroslav Hajek <highegg@gmail.com> parents: 8458 diff changeset	1216 void make_storable_value (void);
8150 283989f2da9b make null assignment matlab compatible Jaroslav Hajek <highegg@gmail.com> parents: 8017 diff changeset	1217
21076 b433f9990452 strip trailing whitespace from files John W. Eaton <jwe@octave.org> parents: 21040 diff changeset	1218 // FIXME: These should probably be private.
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1219 // Conversions. If a user of this class wants a certain kind of constant,
7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1220 // he should simply ask for it, and we should convert it if possible.
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1221
5279 bd32f770c09a [project @ 2005-04-12 21:55:31 by jwe] jwe parents: 5275 diff changeset	1222 octave_value convert_to_str (bool pad = false, bool force = false,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	1223 char type = '\'') const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1224 { return rep->convert_to_str (pad, force, type); }
4452 f3c21a1d1c62 [project @ 2003-07-09 23:20:18 by jwe] jwe parents: 4451 diff changeset	1225
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1226 octave_value
5279 bd32f770c09a [project @ 2005-04-12 21:55:31 by jwe] jwe parents: 5275 diff changeset	1227 convert_to_str_internal (bool pad, bool force, char type) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1228 { return rep->convert_to_str_internal (pad, force, type); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1229
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1230 void convert_to_row_or_column_vector (void)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1231 { rep->convert_to_row_or_column_vector (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1232
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1233 bool print_as_scalar (void) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1234 { return rep->print_as_scalar (); }
4604 cba347c642e2 [project @ 2003-11-13 04:38:05 by jwe] jwe parents: 4593 diff changeset	1235
18416 bcd71a2531d3 Support disp/display overloading in classdef Michael Goffioul <michael.goffioul@gmail.com> parents: 18402 diff changeset	1236 void print (std::ostream& os, bool pr_as_read_syntax = false)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1237 { rep->print (os, pr_as_read_syntax); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1238
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1239 void print_raw (std::ostream& os, bool pr_as_read_syntax = false) const
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1240 { rep->print_raw (os, pr_as_read_syntax); }
2903 facd9d10e5c1 [project @ 1997-04-30 03:53:07 by jwe] jwe parents: 2891 diff changeset	1241
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1242 bool print_name_tag (std::ostream& os, const std::string& name) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1243 { return rep->print_name_tag (os, name); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1244
13110 2d5035847529 Add Júlio Hoffimann Mendes to contributors.in John W. Eaton <jwe@octave.org> parents: 12171 diff changeset	1245 void print_with_name (std::ostream& os, const std::string& name) const
2d5035847529 Add Júlio Hoffimann Mendes to contributors.in John W. Eaton <jwe@octave.org> parents: 12171 diff changeset	1246 { rep->print_with_name (os, name, true); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1247
17870 1d2e709bbbda rework short_disp methods John W. Eaton <jwe@octave.org> parents: 17822 diff changeset	1248 void short_disp (std::ostream& os) const { rep->short_disp (os); }
16468 0f143f68078d use signal/slot for updating workspace instead of using event listener John W. Eaton <jwe@octave.org> parents: 16323 diff changeset	1249
24668 d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24643 diff changeset	1250 float_display_format get_edit_display_format (void) const;
d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24643 diff changeset	1251
d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24643 diff changeset	1252 std::string edit_display (const float_display_format& fmt,
d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24643 diff changeset	1253 octave_idx_type i, octave_idx_type j) const
24643 78aff6f14227 more variable editor improvements; allow more variable types to be edited John W. Eaton <jwe@octave.org> parents: 24624 diff changeset	1254 {
24668 d4dd741b2794 new octave_value functions for formatting output John W. Eaton <jwe@octave.org> parents: 24643 diff changeset	1255 return rep->edit_display (fmt, i, j);
24643 78aff6f14227 more variable editor improvements; allow more variable types to be edited John W. Eaton <jwe@octave.org> parents: 24624 diff changeset	1256 }
78aff6f14227 more variable editor improvements; allow more variable types to be edited John W. Eaton <jwe@octave.org> parents: 24624 diff changeset	1257
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1258 int type_id (void) const { return rep->type_id (); }
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1259
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1260 std::string type_name (void) const { return rep->type_name (); }
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1261
ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1262 std::string class_name (void) const { return rep->class_name (); }
4612 d44675070f1a [project @ 2003-11-14 19:49:56 by jwe] jwe parents: 4604 diff changeset	1263
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1264 // Unary and binary operations.
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1265
24565 dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1266 friend OCTINTERP_API octave_value
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1267 do_unary_op (octave::type_info& ti, unary_op op, const octave_value& a);
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1268
10614 d1194069e58c optimize code handling ++,-- Jaroslav Hajek <highegg@gmail.com> parents: 10544 diff changeset	1269 octave_value& do_non_const_unary_op (unary_op op);
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	1270
10614 d1194069e58c optimize code handling ++,-- Jaroslav Hajek <highegg@gmail.com> parents: 10544 diff changeset	1271 octave_value& do_non_const_unary_op (unary_op op, const std::string& type,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1272 const std::list<octave_value_list>& idx);
3205 549691faa638 [project @ 1998-10-31 04:20:15 by jwe] jwe parents: 3204 diff changeset	1273
24565 dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1274 friend OCTINTERP_API octave_value
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1275 do_binary_op (octave::type_info& ti, binary_op op,
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1276 const octave_value& a, const octave_value& b);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1277
24565 dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1278 friend OCTINTERP_API octave_value
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1279 do_binary_op (octave::type_info& ti, compound_binary_op op,
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1280 const octave_value& a, const octave_value& b);
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1281
24565 dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1282 friend OCTINTERP_API octave_value
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1283 do_cat_op (octave::type_info& ti, const octave_value& a,
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1284 const octave_value& b, const Array<octave_idx_type>& ra_idx);
4915 c638c144d4da [project @ 2004-07-23 19:01:22 by jwe] jwe parents: 4911 diff changeset	1285
19749 c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1286 friend OCTINTERP_API octave_value do_colon_op (const octave_value& base,
c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1287 const octave_value& limit,
20087 0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	1288 bool is_for_cmd_expr)
19749 c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1289 {
c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1290 return do_colon_op (base, octave_value (), limit, is_for_cmd_expr);
c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1291 }
c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1292
c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1293 friend OCTINTERP_API octave_value do_colon_op (const octave_value& base,
c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1294 const octave_value& increment,
c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1295 const octave_value& limit,
20087 0cf104d3371f ov.h: friend declaration specifying a default argument must be a definition (bug #44812). Mike Miller <mtmiller@octave.org> parents: 19863 diff changeset	1296 bool is_for_cmd_expr);
19749 c913247c85a8 make colon function work (bug #44290) John W. Eaton <jwe@octave.org> parents: 19697 diff changeset	1297
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1298 const octave_base_value& get_rep (void) const { return *rep; }
3301 02866242d3ae [project @ 1999-10-20 04:10:46 by jwe] jwe parents: 3240 diff changeset	1299
23433 c9fab0bc983e maint: Use convention 'int& x' for naming references. Rik <rik@octave.org> parents: 23352 diff changeset	1300 bool is_copy_of (const octave_value& val) const { return rep == val.rep; }
8456 c1709a45b45b optimize structure components access Jaroslav Hajek <highegg@gmail.com> parents: 8437 diff changeset	1301
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1302 void print_info (std::ostream& os,
21017 93748bcaec17 maint: Replace emtpy 'std::string ()' calls with "". Rik <rik@octave.org> parents: 21013 diff changeset	1303 const std::string& prefix = "") const;
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	1304
6974 9e32bb109980 [project @ 2007-10-08 11:06:47 by jwe] jwe parents: 6867 diff changeset	1305 bool save_ascii (std::ostream& os) { return rep->save_ascii (os); }
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4665 diff changeset	1306
6974 9e32bb109980 [project @ 2007-10-08 11:06:47 by jwe] jwe parents: 6867 diff changeset	1307 bool load_ascii (std::istream& is) { return rep->load_ascii (is); }
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4665 diff changeset	1308
26399 586413770c7f pass save_as_floats by value in octave_value save_binary functions John W. Eaton <jwe@octave.org> parents: 26377 diff changeset	1309 bool save_binary (std::ostream& os, bool save_as_floats)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1310 { return rep->save_binary (os, save_as_floats); }
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4665 diff changeset	1311
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1312 bool load_binary (std::istream& is, bool swap,
21739 c4ab2e54f100 use namespace for oct_mach_info class John W. Eaton <jwe@octave.org> parents: 21730 diff changeset	1313 octave::mach_info::float_format fmt)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1314 { return rep->load_binary (is, swap, fmt); }
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4665 diff changeset	1315
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: 19749 diff changeset	1316 bool save_hdf5 (octave_hdf5_id loc_id, const char *name,
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: 19749 diff changeset	1317 bool save_as_floats)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1318 { return rep->save_hdf5 (loc_id, name, save_as_floats); }
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4665 diff changeset	1319
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: 19749 diff changeset	1320 bool load_hdf5 (octave_hdf5_id loc_id, const char *name)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1321 { return rep->load_hdf5 (loc_id, name); }
4687 e95c86d48732 [project @ 2004-01-06 21:53:34 by jwe] jwe parents: 4665 diff changeset	1322
23059 b98ebcd7f11c move some octave stream classes into octave namespace John W. Eaton <jwe@octave.org> parents: 22755 diff changeset	1323 int write (octave::stream& os, int block_size,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1324 oct_data_conv::data_type output_type, int skip,
21739 c4ab2e54f100 use namespace for oct_mach_info class John W. Eaton <jwe@octave.org> parents: 21730 diff changeset	1325 octave::mach_info::float_format flt_fmt) const;
4944 44046bbaa52c [project @ 2004-08-31 05:30:46 by jwe] jwe parents: 4933 diff changeset	1326
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	1327 octave_base_value * internal_rep (void) const { return rep; }
4901 35bfb4e0b96b [project @ 2004-06-14 18:33:02 by jwe] jwe parents: 4791 diff changeset	1328
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5895 diff changeset	1329 // Unsafe. These functions exist to support the MEX interface.
c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5895 diff changeset	1330 // You should not use them anywhere else.
28126 4c21f99b4ad5 handle interleaved complex data and new typed data access functions for mex John W. Eaton <jwe@octave.org> parents: 28123 diff changeset	1331 void * mex_get_data (mxClassID class_id = mxUNKNOWN_CLASS,
4c21f99b4ad5 handle interleaved complex data and new typed data access functions for mex John W. Eaton <jwe@octave.org> parents: 28123 diff changeset	1332 mxComplexity complexity = mxREAL) const;
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5895 diff changeset	1333
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	1334 octave_idx_type * mex_get_ir (void) const { return rep->mex_get_ir (); }
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5895 diff changeset	1335
23446 cd4e1ee28716 maint: Use convention 'void * fcn ()' for functions which return pointers. Rik <rik@octave.org> parents: 23433 diff changeset	1336 octave_idx_type * mex_get_jc (void) const { return rep->mex_get_jc (); }
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5895 diff changeset	1337
28126 4c21f99b4ad5 handle interleaved complex data and new typed data access functions for mex John W. Eaton <jwe@octave.org> parents: 28123 diff changeset	1338 mxArray * as_mxArray (bool interleaved = false) const
4c21f99b4ad5 handle interleaved complex data and new typed data access functions for mex John W. Eaton <jwe@octave.org> parents: 28123 diff changeset	1339 { return rep->as_mxArray (interleaved); }
5900 c20eb7330d13 [project @ 2006-07-22 08:31:16 by jwe] jwe parents: 5895 diff changeset	1340
7620 36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7576 diff changeset	1341 octave_value diag (octave_idx_type k = 0) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1342 { return rep->diag (k); }
7620 36594d5bbe13 Move diag function into the octave_value class David Bateman <dbateman@free.fr> parents: 7576 diff changeset	1343
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14528 diff changeset	1344 octave_value diag (octave_idx_type m, octave_idx_type n) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1345 { return rep->diag (m, n); }
14557 e8e86ae3abbc make diag (x, m, n) return a proper diagonal matrix object (bug #36099) John W. Eaton <jwe@octave.org> parents: 14528 diff changeset	1346
7463 2467639bd8c0 eliminate UNDEFINED sort mode John W. Eaton <jwe@octave.org> parents: 7433 diff changeset	1347 octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1348 { return rep->sort (dim, mode); }
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1349 octave_value sort (Array<octave_idx_type> &sidx, octave_idx_type dim = 0,
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1350 sortmode mode = ASCENDING) const
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1351 { return rep->sort (sidx, dim, mode); }
7433 402168152bb9 [project @ 2008-01-31 18:59:09 by dbateman] dbateman parents: 7336 diff changeset	1352
23588 0549061d35b9 maint: Deprecate is_sorted and replace with issorted. Rik <rik@octave.org> parents: 23587 diff changeset	1353 sortmode issorted (sortmode mode = UNSORTED) const
0549061d35b9 maint: Deprecate is_sorted and replace with issorted. Rik <rik@octave.org> parents: 23587 diff changeset	1354 { return rep->issorted (mode); }
0549061d35b9 maint: Deprecate is_sorted and replace with issorted. Rik <rik@octave.org> parents: 23587 diff changeset	1355
8733 3ef774603887 rename all uses of sortrows_idx to sort_rows_idx John W. Eaton <jwe@octave.org> parents: 8732 diff changeset	1356 Array<octave_idx_type> sort_rows_idx (sortmode mode = ASCENDING) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1357 { return rep->sort_rows_idx (mode); }
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8676 diff changeset	1358
8734 767ed8cc6634 rename internal issorted and issorted_rows functions to is_sorted and is_sorted_rows John W. Eaton <jwe@octave.org> parents: 8733 diff changeset	1359 sortmode is_sorted_rows (sortmode mode = UNSORTED) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1360 { return rep->is_sorted_rows (mode); }
8721 e9cb742df9eb imported patch sort3.diff Jaroslav Hajek <highegg@gmail.com> parents: 8676 diff changeset	1361
7489 8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7463 diff changeset	1362 void lock (void) { rep->lock (); }
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7463 diff changeset	1363
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7463 diff changeset	1364 void unlock (void) { rep->unlock (); }
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7463 diff changeset	1365
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7463 diff changeset	1366 bool islocked (void) const { return rep->islocked (); }
8e4592e49fa7 don't clear locked functions John W. Eaton <jwe@octave.org> parents: 7463 diff changeset	1367
26655 cca0548f7b86 refactor calling object destructor John W. Eaton <jwe@octave.org> parents: 26399 diff changeset	1368 void call_object_destructor (void) { return rep->call_object_destructor (); }
cca0548f7b86 refactor calling object destructor John W. Eaton <jwe@octave.org> parents: 26399 diff changeset	1369
23680 ef71711f6d64 rework __dump_symbol_table__ function John W. Eaton <jwe@octave.org> parents: 23678 diff changeset	1370 octave_value dump (void) const { return rep->dump (); }
7761 5adeea5de26c symbol table reporting functions John W. Eaton <jwe@octave.org> parents: 7740 diff changeset	1371
9813 8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1372 #define MAPPER_FORWARD(F) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1373 octave_value F (void) const \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1374 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1375 return rep->map (octave_base_value::umap_ ## F); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1376 }
9813 8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1377
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1378 MAPPER_FORWARD (abs)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1379 MAPPER_FORWARD (acos)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1380 MAPPER_FORWARD (acosh)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1381 MAPPER_FORWARD (angle)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1382 MAPPER_FORWARD (arg)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1383 MAPPER_FORWARD (asin)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1384 MAPPER_FORWARD (asinh)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1385 MAPPER_FORWARD (atan)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1386 MAPPER_FORWARD (atanh)
10414 2a8b1db1e2ca implement built-in cbrt Jaroslav Hajek <highegg@gmail.com> parents: 10391 diff changeset	1387 MAPPER_FORWARD (cbrt)
9813 8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1388 MAPPER_FORWARD (ceil)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1389 MAPPER_FORWARD (conj)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1390 MAPPER_FORWARD (cos)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1391 MAPPER_FORWARD (cosh)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1392 MAPPER_FORWARD (erf)
9835 1bb1ed717d2f implement built-in erfinv Jaroslav Hajek <highegg@gmail.com> parents: 9813 diff changeset	1393 MAPPER_FORWARD (erfinv)
14770 cb85e836d035 New function: erfcinv (bug #36607) Axel Mathéi <axel.mathei@gmail.com> parents: 14557 diff changeset	1394 MAPPER_FORWARD (erfcinv)
9813 8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1395 MAPPER_FORWARD (erfc)
10391 59e34bcdff13 implement built-in erfcx Jaroslav Hajek <highegg@gmail.com> parents: 10325 diff changeset	1396 MAPPER_FORWARD (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	1397 MAPPER_FORWARD (erfi)
2fac72a256ce Add complex erf,erfc,erfcx,erfi,dawson routines from Faddeeva package. Steven G. Johnson <stevenj@alum.mit.edu> parents: 15487 diff changeset	1398 MAPPER_FORWARD (dawson)
9813 8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1399 MAPPER_FORWARD (exp)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1400 MAPPER_FORWARD (expm1)
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1401 MAPPER_FORWARD (isfinite)
9813 8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1402 MAPPER_FORWARD (fix)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1403 MAPPER_FORWARD (floor)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1404 MAPPER_FORWARD (gamma)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1405 MAPPER_FORWARD (imag)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1406 MAPPER_FORWARD (isinf)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1407 MAPPER_FORWARD (isna)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1408 MAPPER_FORWARD (isnan)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1409 MAPPER_FORWARD (lgamma)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1410 MAPPER_FORWARD (log)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1411 MAPPER_FORWARD (log2)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1412 MAPPER_FORWARD (log10)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1413 MAPPER_FORWARD (log1p)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1414 MAPPER_FORWARD (real)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1415 MAPPER_FORWARD (round)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1416 MAPPER_FORWARD (roundb)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1417 MAPPER_FORWARD (signum)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1418 MAPPER_FORWARD (sin)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1419 MAPPER_FORWARD (sinh)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1420 MAPPER_FORWARD (sqrt)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1421 MAPPER_FORWARD (tan)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1422 MAPPER_FORWARD (tanh)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1423
21013 7f4c6d594e3d Finish renaming mapper function finite to isfinite. Rik <rik@octave.org> parents: 21012 diff changeset	1424 // These functions are prefixed with X to avoid potential macro conflicts.
9813 8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1425
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1426 MAPPER_FORWARD (xisalnum)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1427 MAPPER_FORWARD (xisalpha)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1428 MAPPER_FORWARD (xisascii)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1429 MAPPER_FORWARD (xiscntrl)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1430 MAPPER_FORWARD (xisdigit)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1431 MAPPER_FORWARD (xisgraph)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1432 MAPPER_FORWARD (xislower)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1433 MAPPER_FORWARD (xisprint)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1434 MAPPER_FORWARD (xispunct)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1435 MAPPER_FORWARD (xisspace)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1436 MAPPER_FORWARD (xisupper)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1437 MAPPER_FORWARD (xisxdigit)
15487 ecf5be238b4a provide signbit mapper for real values John W. Eaton <jwe@octave.org> parents: 15429 diff changeset	1438 MAPPER_FORWARD (xsignbit)
9813 8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1439 MAPPER_FORWARD (xtolower)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1440 MAPPER_FORWARD (xtoupper)
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1441
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1442 #undef MAPPER_FORWARD
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1443
8fa32b527d9a improve & partially revert previous change Jaroslav Hajek <highegg@gmail.com> parents: 9812 diff changeset	1444 octave_value map (octave_base_value::unary_mapper_t umap) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1445 { return rep->map (umap); }
7503 8c32f95c2639 convert mapper functions to new format David Bateman <dbateman@free.fr> parents: 7489 diff changeset	1446
27216 823b4bcf79fc unless necessary for formatting or code, use ' instead of ` John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	1447 //! Extract the n-th element, aka 'val(n)'.
24624 ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1448 //!
27216 823b4bcf79fc unless necessary for formatting or code, use ' instead of ` John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	1449 //! @return Result is undefined if 'val' is not an array type
24624 ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1450 //! or @p n is out of range.
ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1451 //!
ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1452 //! @warning Function calls should never error.
ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1453
10670 654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10614 diff changeset	1454 octave_value
654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10614 diff changeset	1455 fast_elem_extract (octave_idx_type n) const
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1456 { return rep->fast_elem_extract (n); }
10670 654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10614 diff changeset	1457
27216 823b4bcf79fc unless necessary for formatting or code, use ' instead of ` John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	1458 //! Assign the n-th element, aka 'val(n) = x'.
24624 ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1459 //!
27216 823b4bcf79fc unless necessary for formatting or code, use ' instead of ` John W. Eaton <jwe@octave.org> parents: 26922 diff changeset	1460 //! @returns false if 'val' is not an array type,
24624 ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1461 //! @p x is not a matching scalar type,
ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1462 //! or @p n is out of range.
ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1463 //!
ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1464 //! @warning Function calls should never error.
ce2eb28e0a6d doc: make all Doxygen comment blocks more consistent Mike Miller <mtmiller@octave.org> parents: 24620 diff changeset	1465
24040 8e8dbabd6e84 ov.h(fast_elem_insert): Remove "virtual" declaration. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 23913 diff changeset	1466 bool
10670 654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10614 diff changeset	1467 fast_elem_insert (octave_idx_type n, const octave_value& x)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1468 {
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1469 make_unique ();
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1470 return rep->fast_elem_insert (n, x);
175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1471 }
10670 654fbde5dceb make cellfun's fast scalar collection mechanism public Jaroslav Hajek <highegg@gmail.com> parents: 10614 diff changeset	1472
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1473 protected:
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1474
24040 8e8dbabd6e84 ov.h(fast_elem_insert): Remove "virtual" declaration. Kai T. Ohlhus <k.ohlhus@gmail.com> parents: 23913 diff changeset	1475 //! The real representation.
5759 ce79d238f142 [project @ 2006-04-13 13:04:32 by jwe] jwe parents: 5758 diff changeset	1476 octave_base_value *rep;
2413 44753e0cadf2 [project @ 1996-10-15 17:02:26 by jwe] jwe parents: 2410 diff changeset	1477
3933 f9ea3dcf58ee [project @ 2002-05-15 03:21:00 by jwe] jwe parents: 3930 diff changeset	1478 private:
2903 facd9d10e5c1 [project @ 1997-04-30 03:53:07 by jwe] jwe parents: 2891 diff changeset	1479
21573 f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372) John W. Eaton <jwe@octave.org> parents: 20087 diff changeset	1480 static octave_base_value *nil_rep (void);
f3f8e1d3e399 avoid mulitple definitions of static function-scope vars (bug #47372) John W. Eaton <jwe@octave.org> parents: 20087 diff changeset	1481
3205 549691faa638 [project @ 1998-10-31 04:20:15 by jwe] jwe parents: 3204 diff changeset	1482 assign_op unary_op_to_assign_op (unary_op op);
549691faa638 [project @ 1998-10-31 04:20:15 by jwe] jwe parents: 3204 diff changeset	1483
3204 81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3203 diff changeset	1484 binary_op op_eq_to_binary_op (assign_op op);
81738e630f57 [project @ 1998-10-30 23:28:29 by jwe] jwe parents: 3203 diff changeset	1485
9521 e08d72bb988e simplify cloning Jaroslav Hajek <highegg@gmail.com> parents: 9479 diff changeset	1486 // This declaration protects against constructing octave_value from
e08d72bb988e simplify cloning Jaroslav Hajek <highegg@gmail.com> parents: 9479 diff changeset	1487 // const octave_base_value* which actually silently calls octave_value (bool).
e08d72bb988e simplify cloning Jaroslav Hajek <highegg@gmail.com> parents: 9479 diff changeset	1488 octave_value (const octave_base_value *);
e08d72bb988e simplify cloning Jaroslav Hajek <highegg@gmail.com> parents: 9479 diff changeset	1489
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1490 };
2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1491
24565 dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1492 // Publish externally used friend functions. Which compiler requires
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1493 // these extra declarations?
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1494
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1495 extern OCTINTERP_API octave_value
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1496 do_unary_op (octave::type_info& ti, octave_value::unary_op op,
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1497 const octave_value& a);
5508 7865515fc6c2 [project @ 2005-10-26 15:24:07 by jwe] jwe parents: 5353 diff changeset	1498
6109 c68896f193e3 [project @ 2006-10-27 02:16:18 by jwe] jwe parents: 5958 diff changeset	1499 extern OCTINTERP_API octave_value
5508 7865515fc6c2 [project @ 2005-10-26 15:24:07 by jwe] jwe parents: 5353 diff changeset	1500 do_unary_op (octave_value::unary_op op, const octave_value& a);
7865515fc6c2 [project @ 2005-10-26 15:24:07 by jwe] jwe parents: 5353 diff changeset	1501
6109 c68896f193e3 [project @ 2006-10-27 02:16:18 by jwe] jwe parents: 5958 diff changeset	1502 extern OCTINTERP_API octave_value
24565 dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1503 do_binary_op (octave::type_info& ti, octave_value::binary_op op,
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1504 const octave_value& a, const octave_value& b);
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1505
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1506 extern OCTINTERP_API octave_value
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1507 do_binary_op (octave::type_info& ti, octave_value::compound_binary_op op,
10313 f3b65e1ae355 untabify src header files John W. Eaton <jwe@octave.org> parents: 10293 diff changeset	1508 const octave_value& a, const octave_value& b);
5508 7865515fc6c2 [project @ 2005-10-26 15:24:07 by jwe] jwe parents: 5353 diff changeset	1509
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1510 extern OCTINTERP_API octave_value
24565 dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1511 do_binary_op (octave_value::binary_op op, const octave_value& a,
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1512 const octave_value& b);
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1513
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1514 extern OCTINTERP_API octave_value
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1515 do_binary_op (octave_value::compound_binary_op op, const octave_value& a,
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1516 const octave_value& b);
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1517
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1518 extern OCTINTERP_API octave_value
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1519 do_cat_op (octave::type_info& ti, const octave_value& a,
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1520 const octave_value& b, const Array<octave_idx_type>& ra_idx);
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1521
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1522 extern OCTINTERP_API octave_value
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1523 do_cat_op (const octave_value& a, const octave_value& b,
dbec1e04f499 accept type_info obj as arg to binary_op, unary_op, and cat_op functions John W. Eaton <jwe@octave.org> parents: 24540 diff changeset	1524 const Array<octave_idx_type>& ra_idx);
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1525
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1526 #define OV_UNOP_FN(name) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1527 inline octave_value \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1528 name (const octave_value& a) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1529 { \
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1530 return do_unary_op (octave_value::name, a); \
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1531 }
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1532
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1533 #define OV_UNOP_OP(name, op) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1534 inline octave_value \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1535 operator op (const octave_value& a) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1536 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1537 return name (a); \
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1538 }
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1539
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1540 #define OV_UNOP_FN_OP(name, op) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1541 OV_UNOP_FN (name) \
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1542 OV_UNOP_OP (name, op)
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1543
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1544 OV_UNOP_FN_OP (op_not, !)
6518 952c8b00525e [project @ 2007-04-11 20:50:22 by jwe] jwe parents: 6338 diff changeset	1545 OV_UNOP_FN_OP (op_uplus, +)
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1546 OV_UNOP_FN_OP (op_uminus, -)
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1547
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1548 OV_UNOP_FN (op_transpose)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1549 OV_UNOP_FN (op_hermitian)
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1550
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1551 // No simple way to define these for prefix and suffix ops?
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1552 //
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1553 // incr
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1554 // decr
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1555
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1556 #define OV_BINOP_FN(name) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1557 inline octave_value \
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1558 name (const octave_value& a1, const octave_value& a2) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1559 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1560 return do_binary_op (octave_value::name, a1, a2); \
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1561 }
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1562
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1563 #define OV_BINOP_OP(name, op) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1564 inline octave_value \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1565 operator op (const octave_value& a1, const octave_value& a2) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1566 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1567 return name (a1, a2); \
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1568 }
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1569
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1570 #define OV_BINOP_FN_OP(name, op) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1571 OV_BINOP_FN (name) \
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1572 OV_BINOP_OP (name, op)
bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1573
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1574 OV_BINOP_FN_OP (op_add, +)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1575 OV_BINOP_FN_OP (op_sub, -)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1576 OV_BINOP_FN_OP (op_mul, *)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1577 OV_BINOP_FN_OP (op_div, /)
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1578
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1579 OV_BINOP_FN (op_pow)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1580 OV_BINOP_FN (op_ldiv)
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1581
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1582 OV_BINOP_FN_OP (op_lt, <)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1583 OV_BINOP_FN_OP (op_le, <=)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1584 OV_BINOP_FN_OP (op_eq, ==)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1585 OV_BINOP_FN_OP (op_ge, >=)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1586 OV_BINOP_FN_OP (op_gt, >)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1587 OV_BINOP_FN_OP (op_ne, !=)
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1588
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1589 OV_BINOP_FN (op_el_mul)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1590 OV_BINOP_FN (op_el_div)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1591 OV_BINOP_FN (op_el_pow)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1592 OV_BINOP_FN (op_el_ldiv)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1593 OV_BINOP_FN (op_el_and)
6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1594 OV_BINOP_FN (op_el_or)
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1595
3525 6cfa474c5b99 [project @ 2000-02-02 10:48:41 by jwe] jwe parents: 3523 diff changeset	1596 OV_BINOP_FN (op_struct_ref)
3203 bc61b0e8d60e [project @ 1998-10-30 20:26:27 by jwe] jwe parents: 3202 diff changeset	1597
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1598 #define OV_COMP_BINOP_FN(name) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1599 inline octave_value \
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1600 name (const octave_value& a1, const octave_value& a2) \
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1601 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1602 return do_binary_op (octave_value::name, a1, a2); \
7800 5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1603 }
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1604
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1605 OV_COMP_BINOP_FN (op_trans_mul)
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1606 OV_COMP_BINOP_FN (op_mul_trans)
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1607 OV_COMP_BINOP_FN (op_herm_mul)
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1608 OV_COMP_BINOP_FN (op_mul_herm)
5861b95e9879 support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm Jaroslav Hajek <highegg@gmail.com> parents: 7789 diff changeset	1609
24540 46440078d73b don't use singleton for octave_value_typeinfo John W. Eaton <jwe@octave.org> parents: 24534 diff changeset	1610 extern OCTINTERP_API void install_types (octave::type_info&);
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1611
9657 3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1612 // Templated value extractors.
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21134 diff changeset	1613 template <typename Value>
9657 3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1614 inline Value octave_value_extract (const octave_value&)
17787 175b392e91fe Use GNU style coding conventions for code in libinterp/ Rik <rik@octave.org> parents: 17744 diff changeset	1615 { assert (false); }
9657 3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1616
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1617 #define DEF_VALUE_EXTRACTOR(VALUE,MPREFIX) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1618 template <> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1619 inline VALUE octave_value_extract<VALUE> (const octave_value& v) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1620 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1621 return v.MPREFIX ## _value (); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1622 }
9657 3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1623
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1624 DEF_VALUE_EXTRACTOR (double, scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1625 DEF_VALUE_EXTRACTOR (float, float_scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1626 DEF_VALUE_EXTRACTOR (Complex, complex)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1627 DEF_VALUE_EXTRACTOR (FloatComplex, float_complex)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1628 DEF_VALUE_EXTRACTOR (bool, bool)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1629
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1630 DEF_VALUE_EXTRACTOR (octave_int8, int8_scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1631 DEF_VALUE_EXTRACTOR (octave_int16, int16_scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1632 DEF_VALUE_EXTRACTOR (octave_int32, int32_scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1633 DEF_VALUE_EXTRACTOR (octave_int64, int64_scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1634 DEF_VALUE_EXTRACTOR (octave_uint8, uint8_scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1635 DEF_VALUE_EXTRACTOR (octave_uint16, uint16_scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1636 DEF_VALUE_EXTRACTOR (octave_uint32, uint32_scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1637 DEF_VALUE_EXTRACTOR (octave_uint64, uint64_scalar)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1638
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1639 DEF_VALUE_EXTRACTOR (NDArray, array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1640 DEF_VALUE_EXTRACTOR (FloatNDArray, float_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1641 DEF_VALUE_EXTRACTOR (ComplexNDArray, complex_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1642 DEF_VALUE_EXTRACTOR (FloatComplexNDArray, float_complex_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1643 DEF_VALUE_EXTRACTOR (boolNDArray, bool_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1644
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1645 DEF_VALUE_EXTRACTOR (charNDArray, char_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1646 DEF_VALUE_EXTRACTOR (int8NDArray, int8_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1647 DEF_VALUE_EXTRACTOR (int16NDArray, int16_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1648 DEF_VALUE_EXTRACTOR (int32NDArray, int32_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1649 DEF_VALUE_EXTRACTOR (int64NDArray, int64_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1650 DEF_VALUE_EXTRACTOR (uint8NDArray, uint8_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1651 DEF_VALUE_EXTRACTOR (uint16NDArray, uint16_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1652 DEF_VALUE_EXTRACTOR (uint32NDArray, uint32_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1653 DEF_VALUE_EXTRACTOR (uint64NDArray, uint64_array)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1654
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1655 DEF_VALUE_EXTRACTOR (Matrix, matrix)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1656 DEF_VALUE_EXTRACTOR (FloatMatrix, float_matrix)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1657 DEF_VALUE_EXTRACTOR (ComplexMatrix, complex_matrix)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1658 DEF_VALUE_EXTRACTOR (FloatComplexMatrix, float_complex_matrix)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1659 DEF_VALUE_EXTRACTOR (boolMatrix, bool_matrix)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1660
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1661 DEF_VALUE_EXTRACTOR (ColumnVector, column_vector)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1662 DEF_VALUE_EXTRACTOR (FloatColumnVector, float_column_vector)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1663 DEF_VALUE_EXTRACTOR (ComplexColumnVector, complex_column_vector)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1664 DEF_VALUE_EXTRACTOR (FloatComplexColumnVector, float_complex_column_vector)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1665
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1666 DEF_VALUE_EXTRACTOR (RowVector, row_vector)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1667 DEF_VALUE_EXTRACTOR (FloatRowVector, float_row_vector)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1668 DEF_VALUE_EXTRACTOR (ComplexRowVector, complex_row_vector)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1669 DEF_VALUE_EXTRACTOR (FloatComplexRowVector, float_complex_row_vector)
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1670
9685 e793865ede63 implement builtin_type Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	1671 DEF_VALUE_EXTRACTOR (DiagMatrix, diag_matrix)
e793865ede63 implement builtin_type Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	1672 DEF_VALUE_EXTRACTOR (FloatDiagMatrix, float_diag_matrix)
e793865ede63 implement builtin_type Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	1673 DEF_VALUE_EXTRACTOR (ComplexDiagMatrix, complex_diag_matrix)
e793865ede63 implement builtin_type Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	1674 DEF_VALUE_EXTRACTOR (FloatComplexDiagMatrix, float_complex_diag_matrix)
e793865ede63 implement builtin_type Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	1675 DEF_VALUE_EXTRACTOR (PermMatrix, perm_matrix)
e793865ede63 implement builtin_type Jaroslav Hajek <highegg@gmail.com> parents: 9661 diff changeset	1676
9789 97f5de91427b support sparse templated extractors Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	1677 DEF_VALUE_EXTRACTOR (SparseMatrix, sparse_matrix)
97f5de91427b support sparse templated extractors Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	1678 DEF_VALUE_EXTRACTOR (SparseComplexMatrix, sparse_complex_matrix)
97f5de91427b support sparse templated extractors Jaroslav Hajek <highegg@gmail.com> parents: 9732 diff changeset	1679 DEF_VALUE_EXTRACTOR (SparseBoolMatrix, sparse_bool_matrix)
9657 3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1680 #undef DEF_VALUE_EXTRACTOR
3c1c3a38ec7b implement templated octave_value extractor Jaroslav Hajek <highegg@gmail.com> parents: 9607 diff changeset	1681
22197 e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1682 #define DEF_DUMMY_VALUE_EXTRACTOR(VALUE,DEFVAL) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1683 template <> \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1684 inline VALUE octave_value_extract<VALUE> (const octave_value&) \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1685 { \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1686 assert (false); \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1687 return DEFVAL; \
e43d83253e28 refill multi-line macro definitions John W. Eaton <jwe@octave.org> parents: 22022 diff changeset	1688 }
13733 b1186adb567e Add dummy template specializations with a return value. Michael Goffioul <michael.goffioul@gmail.com> parents: 13294 diff changeset	1689
b1186adb567e Add dummy template specializations with a return value. Michael Goffioul <michael.goffioul@gmail.com> parents: 13294 diff changeset	1690 DEF_DUMMY_VALUE_EXTRACTOR (char, 0)
b1186adb567e Add dummy template specializations with a return value. Michael Goffioul <michael.goffioul@gmail.com> parents: 13294 diff changeset	1691 DEF_DUMMY_VALUE_EXTRACTOR (octave_value, octave_value ())
b1186adb567e Add dummy template specializations with a return value. Michael Goffioul <michael.goffioul@gmail.com> parents: 13294 diff changeset	1692 #undef DEF_DUMMY_VALUE_EXTRACTOR
b1186adb567e Add dummy template specializations with a return value. Michael Goffioul <michael.goffioul@gmail.com> parents: 13294 diff changeset	1693
2376 2142216bf85a [project @ 1996-10-12 01:39:07 by jwe] jwe parents: diff changeset	1694 #endif

Mercurial > octave

annotate libinterp/octave-value/ov.h @ 28126:4c21f99b4ad5