Mercurial > octave
annotate src/ov.h @ 13294:7dce7e110511
make concatenation of class objects work
* data.h: New file.
* src/Makefile.am (octinclude_HEADERS): Add it to the list.
* data.cc (attempt_type_conversion): New static function.
(do_class_concat): New function.
(do_cat): Use it if any elements of the list are objects.
Check whether any elements of the list are objects or cells.
Check whether all elements of the list are complex.
Check whether the first element of the list is a struct.
Maybe convert elements of the list to cells.
New tests for horzcat and vertcat.
* data.h (do_class_concat): Provide decl.
* ov-class.h (octave_class::octave_class): Allow optional parent
list.
* ov.h, ov.h (octave_value::octave_value (const Octave_map&,
const std::string&)): Likewise.
* pt-mat.cc (do_class_concat): New static function.
(tree_matrix::rvalue1): Use it to concatenate objects.
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Fri, 07 Oct 2011 22:16:07 -0400 |
| parents | 2a8dcb5b3a00 |
| children | b1186adb567e |
| rev | line source |
|---|---|
| 2376 | 1 /* |
| 2 | |
| 11523 | 3 Copyright (C) 1996-2011 John W. Eaton |
| 4 Copyright (C) 2009-2010 VZLU Prague | |
| 2376 | 5 |
| 6 This file is part of Octave. | |
| 7 | |
| 8 Octave is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 7016 | 10 Free Software Foundation; either version 3 of the License, or (at your |
| 11 option) any later version. | |
| 2376 | 12 |
| 13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 7016 | 19 along with Octave; see the file COPYING. If not, see |
| 20 <http://www.gnu.org/licenses/>. | |
| 2376 | 21 |
| 22 */ | |
| 23 | |
| 24 #if !defined (octave_value_h) | |
| 25 #define octave_value_h 1 | |
| 26 | |
| 27 #include <cstdlib> | |
| 28 | |
|
8950
d865363208d6
include <iosfwd> instead of <iostream> in header files
John W. Eaton <jwe@octave.org>
parents:
8920
diff
changeset
|
29 #include <iosfwd> |
| 2376 | 30 #include <string> |
| 4219 | 31 #include <list> |
| 2376 | 32 |
| 33 #include "Range.h" | |
| 5828 | 34 #include "data-conv.h" |
| 2376 | 35 #include "idx-vector.h" |
| 5828 | 36 #include "mach-info.h" |
| 5900 | 37 #include "mxarray.h" |
| 2376 | 38 #include "mx-base.h" |
| 2477 | 39 #include "oct-alloc.h" |
| 4254 | 40 #include "oct-time.h" |
| 2942 | 41 #include "str-vec.h" |
| 42 | |
| 8676 | 43 #include "oct-hdf5.h" |
| 7433 | 44 #include "oct-sort.h" |
| 45 | |
| 3351 | 46 class Cell; |
|
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10670
diff
changeset
|
47 class octave_map; |
|
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10670
diff
changeset
|
48 class octave_scalar_map; |
| 2376 | 49 class Octave_map; |
| 2903 | 50 class octave_stream; |
| 2974 | 51 class octave_function; |
| 4700 | 52 class octave_user_function; |
| 4342 | 53 class octave_fcn_handle; |
| 4933 | 54 class octave_fcn_inline; |
| 2376 | 55 class octave_value_list; |
| 2979 | 56 class octave_lvalue; |
| 2376 | 57 |
| 5759 | 58 #include "ov-base.h" |
| 2376 | 59 |
| 5759 | 60 // Constants. |
| 2376 | 61 |
| 2427 | 62 class octave_value; |
| 63 | |
| 2376 | 64 class |
| 6109 | 65 OCTINTERP_API |
| 2974 | 66 octave_value |
| 2376 | 67 { |
| 68 public: | |
| 69 | |
| 3203 | 70 enum unary_op |
| 71 { | |
| 6518 | 72 op_not, // not |
| 73 op_uplus, // uplus | |
| 74 op_uminus, // uminus | |
| 75 op_transpose, // transpose | |
| 76 op_hermitian, // ctranspose | |
| 3525 | 77 op_incr, |
| 78 op_decr, | |
| 3203 | 79 num_unary_ops, |
| 80 unknown_unary_op | |
| 81 }; | |
| 82 | |
| 2376 | 83 enum binary_op |
| 84 { | |
| 6518 | 85 op_add, // plus |
| 86 op_sub, // minus | |
| 87 op_mul, // mtimes | |
| 88 op_div, // mrdivide | |
| 89 op_pow, // mpower | |
| 90 op_ldiv, // mldivide | |
| 3525 | 91 op_lshift, |
| 92 op_rshift, | |
| 6518 | 93 op_lt, // lt |
| 94 op_le, // le | |
| 95 op_eq, // eq | |
| 96 op_ge, // ge | |
| 97 op_gt, // gt | |
| 98 op_ne, // ne | |
| 99 op_el_mul, // times | |
| 100 op_el_div, // rdivide | |
| 101 op_el_pow, // power | |
| 102 op_el_ldiv, // ldivide | |
| 103 op_el_and, // and | |
| 104 op_el_or, // or | |
| 3525 | 105 op_struct_ref, |
| 2376 | 106 num_binary_ops, |
| 107 unknown_binary_op | |
| 108 }; | |
| 109 | |
|
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
|
110 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
|
111 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
112 // ** compound operations ** |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
113 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
|
114 op_mul_trans, |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
115 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
|
116 op_mul_herm, |
|
9661
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9657
diff
changeset
|
117 op_trans_ldiv, |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9657
diff
changeset
|
118 op_herm_ldiv, |
|
8982
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
119 op_el_not_and, |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
120 op_el_not_or, |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
121 op_el_and_not, |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
122 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
|
123 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
|
124 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
|
125 }; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
126 |
| 2880 | 127 enum assign_op |
| 128 { | |
| 3525 | 129 op_asn_eq, |
| 130 op_add_eq, | |
| 131 op_sub_eq, | |
| 132 op_mul_eq, | |
| 133 op_div_eq, | |
| 134 op_ldiv_eq, | |
| 4018 | 135 op_pow_eq, |
| 3525 | 136 op_lshift_eq, |
| 137 op_rshift_eq, | |
| 138 op_el_mul_eq, | |
| 139 op_el_div_eq, | |
| 140 op_el_ldiv_eq, | |
| 4018 | 141 op_el_pow_eq, |
| 3525 | 142 op_el_and_eq, |
| 143 op_el_or_eq, | |
| 2880 | 144 num_assign_ops, |
| 145 unknown_assign_op | |
| 146 }; | |
| 147 | |
|
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9521
diff
changeset
|
148 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
|
149 |
| 3523 | 150 static std::string unary_op_as_string (unary_op); |
| 7336 | 151 static std::string unary_op_fcn_name (unary_op); |
| 3203 | 152 |
| 3523 | 153 static std::string binary_op_as_string (binary_op); |
| 7336 | 154 static std::string binary_op_fcn_name (binary_op); |
| 2376 | 155 |
|
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
|
156 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
|
157 |
| 3523 | 158 static std::string assign_op_as_string (assign_op); |
| 2880 | 159 |
| 3933 | 160 static octave_value empty_conv (const std::string& type, |
| 10313 | 161 const octave_value& rhs = octave_value ()); |
| 3933 | 162 |
| 2376 | 163 enum magic_colon { magic_colon_t }; |
| 164 | |
|
8992
d12f44a5dce3
implement fast octave_value constructor
Jaroslav Hajek <highegg@gmail.com>
parents:
8982
diff
changeset
|
165 octave_value (void) |
|
d12f44a5dce3
implement fast octave_value constructor
Jaroslav Hajek <highegg@gmail.com>
parents:
8982
diff
changeset
|
166 { |
|
d12f44a5dce3
implement fast octave_value constructor
Jaroslav Hajek <highegg@gmail.com>
parents:
8982
diff
changeset
|
167 static octave_base_value nil_rep; |
|
d12f44a5dce3
implement fast octave_value constructor
Jaroslav Hajek <highegg@gmail.com>
parents:
8982
diff
changeset
|
168 rep = &nil_rep; |
|
d12f44a5dce3
implement fast octave_value constructor
Jaroslav Hajek <highegg@gmail.com>
parents:
8982
diff
changeset
|
169 rep->count++; |
|
d12f44a5dce3
implement fast octave_value constructor
Jaroslav Hajek <highegg@gmail.com>
parents:
8982
diff
changeset
|
170 } |
|
d12f44a5dce3
implement fast octave_value constructor
Jaroslav Hajek <highegg@gmail.com>
parents:
8982
diff
changeset
|
171 |
| 4254 | 172 octave_value (short int i); |
| 173 octave_value (unsigned short int i); | |
| 4233 | 174 octave_value (int i); |
| 4254 | 175 octave_value (unsigned int i); |
| 176 octave_value (long int i); | |
| 177 octave_value (unsigned long int i); | |
| 4353 | 178 |
| 5775 | 179 // FIXME -- these are kluges. They turn into doubles |
| 4353 | 180 // internally, which will break for very large values. We just use |
| 181 // them to store things like 64-bit ino_t, etc, and hope that those | |
| 182 // values are never actually larger than can be represented exactly | |
| 183 // in a double. | |
| 184 | |
| 185 #if defined (HAVE_LONG_LONG_INT) | |
| 186 octave_value (long long int i); | |
| 187 #endif | |
| 4356 | 188 #if defined (HAVE_UNSIGNED_LONG_LONG_INT) |
| 4353 | 189 octave_value (unsigned long long int i); |
| 190 #endif | |
| 191 | |
| 4254 | 192 octave_value (octave_time t); |
| 2376 | 193 octave_value (double d); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
194 octave_value (float d); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
195 octave_value (const Array<octave_value>& a, bool is_cs_list = false); |
| 4532 | 196 octave_value (const Cell& c, bool is_cs_list = false); |
| 5785 | 197 octave_value (const Matrix& m, const MatrixType& t = MatrixType()); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
198 octave_value (const FloatMatrix& m, const MatrixType& t = MatrixType()); |
| 4513 | 199 octave_value (const NDArray& nda); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
200 octave_value (const FloatNDArray& nda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
201 octave_value (const Array<double>& m); |
|
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
202 octave_value (const Array<float>& m); |
| 2376 | 203 octave_value (const DiagMatrix& d); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
204 octave_value (const FloatDiagMatrix& d); |
| 3418 | 205 octave_value (const RowVector& v); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
206 octave_value (const FloatRowVector& v); |
| 3418 | 207 octave_value (const ColumnVector& v); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
208 octave_value (const FloatColumnVector& v); |
| 2376 | 209 octave_value (const Complex& C); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
210 octave_value (const FloatComplex& C); |
| 5785 | 211 octave_value (const ComplexMatrix& m, const MatrixType& t = MatrixType()); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
212 octave_value (const FloatComplexMatrix& m, const MatrixType& t = MatrixType()); |
| 4513 | 213 octave_value (const ComplexNDArray& cnda); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
214 octave_value (const FloatComplexNDArray& cnda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
215 octave_value (const Array<Complex>& m); |
|
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
216 octave_value (const Array<FloatComplex>& m); |
| 2376 | 217 octave_value (const ComplexDiagMatrix& d); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
218 octave_value (const FloatComplexDiagMatrix& d); |
| 3418 | 219 octave_value (const ComplexRowVector& v); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
220 octave_value (const FloatComplexRowVector& v); |
| 3418 | 221 octave_value (const ComplexColumnVector& v); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
222 octave_value (const FloatComplexColumnVector& v); |
|
8960
93f18f166aba
remove float perm matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8950
diff
changeset
|
223 octave_value (const PermMatrix& p); |
| 2825 | 224 octave_value (bool b); |
| 5785 | 225 octave_value (const boolMatrix& bm, const MatrixType& t = MatrixType()); |
| 4513 | 226 octave_value (const boolNDArray& bnda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
227 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
|
228 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
|
229 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
|
230 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
|
231 octave_value (const string_vector& s, char type = '\''); |
| 10313 | 232 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
|
233 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
|
234 octave_value (const Array<char>& chnda, char type = '\''); |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9685
diff
changeset
|
235 octave_value (const charMatrix& chm, bool is_string, |
| 10313 | 236 char type = '\'') GCC_ATTR_DEPRECATED; |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9685
diff
changeset
|
237 octave_value (const charNDArray& chnda, bool is_string, |
| 10313 | 238 char type = '\'') GCC_ATTR_DEPRECATED; |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
239 octave_value (const Array<char>& chnda, bool is_string, |
| 10313 | 240 char type = '\'') GCC_ATTR_DEPRECATED; |
| 5785 | 241 octave_value (const SparseMatrix& m, const MatrixType& t = MatrixType ()); |
| 6863 | 242 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
|
243 octave_value (const SparseComplexMatrix& m, |
| 10313 | 244 const MatrixType& t = MatrixType ()); |
| 6863 | 245 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
|
246 octave_value (const SparseBoolMatrix& bm, |
| 10313 | 247 const MatrixType& t = MatrixType ()); |
| 7433 | 248 octave_value (const Sparse<bool>& m, const MatrixType& t = MatrixType ()); |
| 4901 | 249 octave_value (const octave_int8& i); |
| 4910 | 250 octave_value (const octave_int16& i); |
| 251 octave_value (const octave_int32& i); | |
| 252 octave_value (const octave_int64& i); | |
| 4901 | 253 octave_value (const octave_uint8& i); |
| 254 octave_value (const octave_uint16& i); | |
| 255 octave_value (const octave_uint32& i); | |
| 256 octave_value (const octave_uint64& i); | |
| 257 octave_value (const int8NDArray& inda); | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
258 octave_value (const Array<octave_int8>& inda); |
| 4910 | 259 octave_value (const int16NDArray& inda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
260 octave_value (const Array<octave_int16>& inda); |
| 4910 | 261 octave_value (const int32NDArray& inda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
262 octave_value (const Array<octave_int32>& inda); |
| 4910 | 263 octave_value (const int64NDArray& inda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
264 octave_value (const Array<octave_int64>& inda); |
| 4901 | 265 octave_value (const uint8NDArray& inda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
266 octave_value (const Array<octave_uint8>& inda); |
| 4901 | 267 octave_value (const uint16NDArray& inda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
268 octave_value (const Array<octave_uint16>& inda); |
| 4901 | 269 octave_value (const uint32NDArray& inda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
270 octave_value (const Array<octave_uint32>& inda); |
| 4901 | 271 octave_value (const uint64NDArray& inda); |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
272 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
|
273 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
|
274 bool zero_based = false, bool cache_index = false); |
| 9725 | 275 octave_value (const Array<std::string>& cellstr); |
|
10325
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10313
diff
changeset
|
276 octave_value (const idx_vector& idx, bool lazy = true); |
| 2376 | 277 octave_value (double base, double limit, double inc); |
| 278 octave_value (const Range& r); | |
|
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10670
diff
changeset
|
279 octave_value (const octave_map& m); |
|
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10670
diff
changeset
|
280 octave_value (const octave_scalar_map& m); |
| 2376 | 281 octave_value (const Octave_map& m); |
|
13294
7dce7e110511
make concatenation of class objects work
John W. Eaton <jwe@octave.org>
parents:
13241
diff
changeset
|
282 octave_value (const Octave_map& m, const std::string& id, |
|
7dce7e110511
make concatenation of class objects work
John W. Eaton <jwe@octave.org>
parents:
13241
diff
changeset
|
283 const std::list<std::string>& plist |
|
7dce7e110511
make concatenation of class objects work
John W. Eaton <jwe@octave.org>
parents:
13241
diff
changeset
|
284 = std::list<std::string> ()); |
| 10293 | 285 octave_value (const octave_value_list& m, bool = false); |
| 2376 | 286 octave_value (octave_value::magic_colon); |
| 287 | |
|
9728
70925b11ba46
again allow the obsolete syntax for cellfun
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
288 octave_value (octave_base_value *new_rep, bool borrow = false); |
|
70925b11ba46
again allow the obsolete syntax for cellfun
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
289 octave_value (octave_base_value *new_rep, int xcount) GCC_ATTR_DEPRECATED; |
| 2376 | 290 |
| 291 // Copy constructor. | |
| 292 | |
| 293 octave_value (const octave_value& a) | |
| 294 { | |
| 295 rep = a.rep; | |
| 296 rep->count++; | |
| 297 } | |
| 298 | |
| 3933 | 299 // This should only be called for derived types. |
| 300 | |
| 5759 | 301 octave_base_value *clone (void) const; |
| 3933 | 302 |
| 5759 | 303 octave_base_value *empty_clone (void) const |
| 3933 | 304 { return rep->empty_clone (); } |
| 305 | |
| 2376 | 306 // Delete the representation of this constant if the count drops to |
| 307 // zero. | |
| 308 | |
| 6338 | 309 ~octave_value (void) |
| 310 { | |
| 311 if (--rep->count == 0) | |
| 312 delete rep; | |
| 313 } | |
| 2376 | 314 |
| 315 void make_unique (void) | |
| 316 { | |
| 317 if (rep->count > 1) | |
| 10313 | 318 { |
| 319 --rep->count; | |
| 320 rep = rep->unique_clone (); | |
| 321 } | |
| 2376 | 322 } |
| 323 | |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
324 // This uniquifies the value if it is referenced by more than a certain |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
325 // number of shallow copies. This is useful for optimizations where we |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
326 // 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
|
327 void make_unique (int obsolete_copies) |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
328 { |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
329 if (rep->count > obsolete_copies + 1) |
| 10313 | 330 { |
| 331 --rep->count; | |
| 332 rep = rep->unique_clone (); | |
| 333 } | |
|
8546
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
334 } |
|
3d8a914c580e
improve parser indexed assigment code
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
335 |
| 2376 | 336 // Simple assignment. |
| 337 | |
| 338 octave_value& operator = (const octave_value& a) | |
| 339 { | |
| 340 if (rep != a.rep) | |
| 10313 | 341 { |
| 342 if (--rep->count == 0) | |
| 343 delete rep; | |
| 2376 | 344 |
| 10313 | 345 rep = a.rep; |
| 346 rep->count++; | |
| 347 } | |
| 2376 | 348 |
| 349 return *this; | |
| 350 } | |
| 351 | |
|
9703
9a5598cf899d
octave_value::get_count: return octave_idx_type, not int
John W. Eaton <jwe@octave.org>
parents:
9689
diff
changeset
|
352 octave_idx_type get_count (void) const { return rep->count; } |
| 3239 | 353 |
|
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
354 octave_base_value::type_conv_info numeric_conversion_function (void) const |
| 2376 | 355 { return rep->numeric_conversion_function (); } |
| 356 | |
|
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
357 octave_base_value::type_conv_info numeric_demotion_function (void) const |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
358 { return rep->numeric_demotion_function (); } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
359 |
| 2409 | 360 void maybe_mutate (void); |
| 361 | |
| 5759 | 362 octave_value squeeze (void) const |
| 4532 | 363 { return rep->squeeze (); } |
| 364 | |
|
8458
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8456
diff
changeset
|
365 // The result of full(). |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8456
diff
changeset
|
366 octave_value full_value (void) const |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8456
diff
changeset
|
367 { return rep->full_value (); } |
|
d254a21e0120
reimplement full as method of octave_base_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8456
diff
changeset
|
368 |
| 5759 | 369 octave_base_value *try_narrowing_conversion (void) |
| 2410 | 370 { return rep->try_narrowing_conversion (); } |
| 2409 | 371 |
|
9329
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9151
diff
changeset
|
372 // 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
|
373 Matrix size (void) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9151
diff
changeset
|
374 { return rep->size (); } |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9151
diff
changeset
|
375 |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9151
diff
changeset
|
376 octave_idx_type numel (const octave_value_list& idx) |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9151
diff
changeset
|
377 { return rep->numel (idx); } |
|
67fc970dad7d
improve indexed assignment using indexed numel
Jaroslav Hajek <highegg@gmail.com>
parents:
9151
diff
changeset
|
378 |
| 4271 | 379 octave_value single_subsref (const std::string& type, |
| 10313 | 380 const octave_value_list& idx); |
| 4271 | 381 |
| 5759 | 382 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
|
383 const std::list<octave_value_list>& idx) |
| 3933 | 384 { return rep->subsref (type, idx); } |
| 385 | |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
386 octave_value subsref (const std::string& type, |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
387 const std::list<octave_value_list>& idx, |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
388 bool auto_add) |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
389 { return rep->subsref (type, idx, auto_add); } |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
390 |
| 5759 | 391 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
|
392 const std::list<octave_value_list>& idx, |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
393 int nargout); |
| 3933 | 394 |
|
10832
1b2fcd122c6a
allow user detect ignored outputs in m-functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10768
diff
changeset
|
395 octave_value_list subsref (const std::string& type, |
|
1b2fcd122c6a
allow user detect ignored outputs in m-functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10768
diff
changeset
|
396 const std::list<octave_value_list>& idx, |
|
1b2fcd122c6a
allow user detect ignored outputs in m-functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10768
diff
changeset
|
397 int nargout, |
|
1b2fcd122c6a
allow user detect ignored outputs in m-functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10768
diff
changeset
|
398 const std::list<octave_lvalue> *lvalue_list); |
|
1b2fcd122c6a
allow user detect ignored outputs in m-functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10768
diff
changeset
|
399 |
| 4247 | 400 octave_value next_subsref (const std::string& type, const |
| 10313 | 401 std::list<octave_value_list>& idx, |
| 402 size_t skip = 1); | |
| 3933 | 403 |
| 4994 | 404 octave_value_list next_subsref (int nargout, |
| 10313 | 405 const std::string& type, const |
| 406 std::list<octave_value_list>& idx, | |
| 407 size_t skip = 1); | |
| 4994 | 408 |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
409 octave_value next_subsref (bool auto_add, const std::string& type, const |
| 10313 | 410 std::list<octave_value_list>& idx, |
| 411 size_t skip = 1); | |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8546
diff
changeset
|
412 |
| 5759 | 413 octave_value do_index_op (const octave_value_list& idx, |
| 10313 | 414 bool resize_ok = false) |
| 3933 | 415 { return rep->do_index_op (idx, resize_ok); } |
| 416 | |
| 5759 | 417 octave_value_list |
| 3544 | 418 do_multi_index_op (int nargout, const octave_value_list& idx); |
| 2974 | 419 |
|
10832
1b2fcd122c6a
allow user detect ignored outputs in m-functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10768
diff
changeset
|
420 octave_value_list |
|
1b2fcd122c6a
allow user detect ignored outputs in m-functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10768
diff
changeset
|
421 do_multi_index_op (int nargout, const octave_value_list& idx, |
|
1b2fcd122c6a
allow user detect ignored outputs in m-functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10768
diff
changeset
|
422 const std::list<octave_lvalue> *lvalue_list); |
|
1b2fcd122c6a
allow user detect ignored outputs in m-functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10768
diff
changeset
|
423 |
| 5759 | 424 octave_value subsasgn (const std::string& type, |
| 10313 | 425 const std::list<octave_value_list>& idx, |
| 426 const octave_value& rhs); | |
| 2376 | 427 |
|
12171
d08901c05c1b
fix bug in class assignment to undefined object with index
John W. Eaton <jwe@octave.org>
parents:
11586
diff
changeset
|
428 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
|
429 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
|
430 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
|
431 |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
432 octave_value& assign (assign_op op, const std::string& type, |
| 10313 | 433 const std::list<octave_value_list>& idx, |
| 434 const octave_value& rhs); | |
| 2948 | 435 |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
436 octave_value& assign (assign_op, const octave_value& rhs); |
| 2948 | 437 |
| 5759 | 438 idx_vector index_vector (void) const |
| 2376 | 439 { return rep->index_vector (); } |
| 440 | |
| 441 // Size. | |
| 442 | |
| 5759 | 443 dim_vector dims (void) const |
| 4513 | 444 { return rep->dims (); } |
| 445 | |
| 5759 | 446 octave_idx_type rows (void) const { return rep->rows (); } |
| 4563 | 447 |
| 5759 | 448 octave_idx_type columns (void) const { return rep->columns (); } |
| 3195 | 449 |
| 5275 | 450 octave_idx_type length (void) const; |
| 4554 | 451 |
| 5759 | 452 int ndims (void) const { return rep->ndims (); } |
| 4563 | 453 |
| 5164 | 454 bool all_zero_dims (void) const { return dims().all_zero (); } |
| 455 | |
| 5759 | 456 octave_idx_type numel (void) const |
| 5080 | 457 { return rep->numel (); } |
| 4559 | 458 |
| 5759 | 459 octave_idx_type capacity (void) const |
| 5164 | 460 { return rep->capacity (); } |
| 461 | |
| 5759 | 462 size_t byte_size (void) const |
| 4791 | 463 { return rep->byte_size (); } |
| 464 | |
| 5759 | 465 octave_idx_type nnz (void) const { return rep->nnz (); } |
| 5602 | 466 |
| 5759 | 467 octave_idx_type nzmax (void) const { return rep->nzmax (); } |
| 5604 | 468 |
| 5900 | 469 octave_idx_type nfields (void) const { return rep->nfields (); } |
| 470 | |
| 5759 | 471 octave_value reshape (const dim_vector& dv) const |
| 4587 | 472 { return rep->reshape (dv); } |
| 4567 | 473 |
| 5759 | 474 octave_value permute (const Array<int>& vec, bool inv = false) const |
| 4593 | 475 { return rep->permute (vec, inv); } |
| 476 | |
| 477 octave_value ipermute (const Array<int>& vec) const | |
| 478 { return rep->permute (vec, true); } | |
| 479 | |
| 5759 | 480 octave_value resize (const dim_vector& dv, bool fill = false) const |
| 481 { return rep->resize (dv, fill);} | |
| 4915 | 482 |
| 5785 | 483 MatrixType matrix_type (void) const |
| 484 { return rep->matrix_type (); } | |
| 485 | |
| 486 MatrixType matrix_type (const MatrixType& typ) const | |
| 487 { return rep->matrix_type (typ); } | |
| 488 | |
| 2376 | 489 // Does this constant have a type? Both of these are provided since |
| 490 // it is sometimes more natural to write is_undefined() instead of | |
| 491 // ! is_defined(). | |
| 492 | |
| 5759 | 493 bool is_defined (void) const |
| 2376 | 494 { return rep->is_defined (); } |
| 495 | |
| 496 bool is_undefined (void) const | |
| 497 { return ! is_defined (); } | |
| 498 | |
| 4559 | 499 bool is_empty (void) const |
| 5759 | 500 { return rep->is_empty (); } |
| 4559 | 501 |
| 5759 | 502 bool is_cell (void) const |
| 3351 | 503 { return rep->is_cell (); } |
| 504 | |
| 6116 | 505 bool is_cellstr (void) const |
| 506 { return rep->is_cellstr (); } | |
| 507 | |
| 5759 | 508 bool is_real_scalar (void) const |
| 2376 | 509 { return rep->is_real_scalar (); } |
| 510 | |
| 5759 | 511 bool is_real_matrix (void) const |
| 2376 | 512 { return rep->is_real_matrix (); } |
| 513 | |
| 5759 | 514 bool is_real_nd_array (void) const |
| 4505 | 515 { return rep->is_real_nd_array (); } |
| 516 | |
| 5759 | 517 bool is_complex_scalar (void) const |
| 2376 | 518 { return rep->is_complex_scalar (); } |
| 519 | |
| 5759 | 520 bool is_complex_matrix (void) const |
| 2376 | 521 { return rep->is_complex_matrix (); } |
| 522 | |
| 5881 | 523 bool is_bool_scalar (void) const |
| 524 { return rep->is_bool_scalar (); } | |
| 525 | |
| 5759 | 526 bool is_bool_matrix (void) const |
| 4587 | 527 { return rep->is_bool_matrix (); } |
| 528 | |
| 5759 | 529 bool is_char_matrix (void) const |
| 2376 | 530 { return rep->is_char_matrix (); } |
| 531 | |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
532 bool is_diag_matrix (void) const |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
533 { return rep->is_diag_matrix (); } |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
534 |
|
8371
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
535 bool is_perm_matrix (void) const |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
536 { return rep->is_perm_matrix (); } |
|
c3f7e2549abb
make det & inv aware of diagonal & permutation matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
537 |
| 5759 | 538 bool is_string (void) const |
| 2376 | 539 { return rep->is_string (); } |
| 540 | |
| 5759 | 541 bool is_sq_string (void) const |
| 5279 | 542 { return rep->is_sq_string (); } |
| 543 | |
| 5280 | 544 bool is_dq_string (void) const |
| 545 { return rep->is_string () && ! rep->is_sq_string (); } | |
| 546 | |
| 5759 | 547 bool is_range (void) const |
| 2376 | 548 { return rep->is_range (); } |
| 549 | |
| 5759 | 550 bool is_map (void) const |
| 2376 | 551 { return rep->is_map (); } |
| 552 | |
| 7336 | 553 bool is_object (void) const |
| 554 { return rep->is_object (); } | |
| 555 | |
| 5759 | 556 bool is_cs_list (void) const |
| 3977 | 557 { return rep->is_cs_list (); } |
| 558 | |
| 5759 | 559 bool is_magic_colon (void) const |
| 2376 | 560 { return rep->is_magic_colon (); } |
| 561 | |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8017
diff
changeset
|
562 bool is_null_value (void) const |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8017
diff
changeset
|
563 { return rep->is_null_value (); } |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8017
diff
changeset
|
564 |
| 2376 | 565 // Are any or all of the elements in this constant nonzero? |
| 566 | |
| 5759 | 567 octave_value all (int dim = 0) const |
| 4015 | 568 { return rep->all (dim); } |
| 2376 | 569 |
| 5759 | 570 octave_value any (int dim = 0) const |
| 4015 | 571 { return rep->any (dim); } |
| 2376 | 572 |
| 9685 | 573 builtin_type_t builtin_type (void) const |
| 574 { return rep->builtin_type (); } | |
| 575 | |
| 5895 | 576 // Floating point types. |
| 577 | |
| 578 bool is_double_type (void) const | |
| 579 { return rep->is_double_type (); } | |
| 580 | |
| 581 bool is_single_type (void) const | |
| 582 { return rep->is_single_type (); } | |
| 583 | |
| 7576 | 584 bool is_float_type (void) const |
| 585 { return rep->is_float_type (); } | |
| 586 | |
| 5895 | 587 // Integer types. |
| 588 | |
| 589 bool is_int8_type (void) const | |
| 590 { return rep->is_int8_type (); } | |
| 591 | |
| 592 bool is_int16_type (void) const | |
| 593 { return rep->is_int16_type (); } | |
| 594 | |
| 595 bool is_int32_type (void) const | |
| 596 { return rep->is_int32_type (); } | |
| 597 | |
| 598 bool is_int64_type (void) const | |
| 599 { return rep->is_int64_type (); } | |
| 600 | |
| 601 bool is_uint8_type (void) const | |
| 602 { return rep->is_uint8_type (); } | |
| 603 | |
| 604 bool is_uint16_type (void) const | |
| 605 { return rep->is_uint16_type (); } | |
| 606 | |
| 607 bool is_uint32_type (void) const | |
| 608 { return rep->is_uint32_type (); } | |
| 609 | |
| 610 bool is_uint64_type (void) const | |
| 611 { return rep->is_uint64_type (); } | |
| 612 | |
| 2376 | 613 // Other type stuff. |
| 614 | |
| 5759 | 615 bool is_bool_type (void) const |
| 3209 | 616 { return rep->is_bool_type (); } |
| 617 | |
| 6223 | 618 bool is_integer_type (void) const |
| 619 { return rep->is_integer_type (); } | |
| 620 | |
| 5759 | 621 bool is_real_type (void) const |
| 2376 | 622 { return rep->is_real_type (); } |
| 623 | |
| 5759 | 624 bool is_complex_type (void) const |
| 2376 | 625 { return rep->is_complex_type (); } |
| 626 | |
| 5759 | 627 bool is_scalar_type (void) const |
| 2376 | 628 { return rep->is_scalar_type (); } |
| 629 | |
| 5759 | 630 bool is_matrix_type (void) const |
| 2376 | 631 { return rep->is_matrix_type (); } |
| 632 | |
| 5759 | 633 bool is_numeric_type (void) const |
| 2376 | 634 { return rep->is_numeric_type (); } |
| 635 | |
| 5759 | 636 bool is_sparse_type (void) const |
| 5631 | 637 { return rep->is_sparse_type (); } |
| 638 | |
| 2376 | 639 // Does this constant correspond to a truth value? |
| 640 | |
| 5759 | 641 bool is_true (void) const |
| 2376 | 642 { return rep->is_true (); } |
| 643 | |
|
8346
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
644 // 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
|
645 |
|
8346
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
646 bool is_equal (const octave_value&) const; |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
647 |
| 2376 | 648 // Are the dimensions of this constant zero by zero? |
| 649 | |
| 5759 | 650 bool is_zero_by_zero (void) const |
| 651 { return (rows () == 0 && columns () == 0); } | |
| 2376 | 652 |
| 5759 | 653 bool is_constant (void) const |
| 2974 | 654 { return rep->is_constant (); } |
| 655 | |
| 5759 | 656 bool is_function_handle (void) const |
| 4654 | 657 { return rep->is_function_handle (); } |
| 658 | |
|
13241
2a8dcb5b3a00
improve default indexing for objects
John W. Eaton <jwe@octave.org>
parents:
13110
diff
changeset
|
659 bool is_anonymous_function (void) const |
|
2a8dcb5b3a00
improve default indexing for objects
John W. Eaton <jwe@octave.org>
parents:
13110
diff
changeset
|
660 { return rep->is_anonymous_function (); } |
|
2a8dcb5b3a00
improve default indexing for objects
John W. Eaton <jwe@octave.org>
parents:
13110
diff
changeset
|
661 |
| 5759 | 662 bool is_inline_function (void) const |
| 4954 | 663 { return rep->is_inline_function (); } |
| 664 | |
| 5759 | 665 bool is_function (void) const |
| 2974 | 666 { return rep->is_function (); } |
| 2891 | 667 |
| 7336 | 668 bool is_user_script (void) const |
| 669 { return rep->is_user_script (); } | |
| 670 | |
| 671 bool is_user_function (void) const | |
| 672 { return rep->is_user_function (); } | |
| 673 | |
|
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
|
674 bool is_user_code (void) const |
|
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
|
675 { return rep->is_user_code (); } |
|
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
|
676 |
| 5759 | 677 bool is_builtin_function (void) const |
| 3325 | 678 { return rep->is_builtin_function (); } |
| 679 | |
| 5759 | 680 bool is_dld_function (void) const |
| 3325 | 681 { return rep->is_dld_function (); } |
| 682 | |
| 5864 | 683 bool is_mex_function (void) const |
| 684 { return rep->is_mex_function (); } | |
| 685 | |
|
7876
8447a5024650
clear subfunctions when clearing parent function
John W. Eaton <jwe@octave.org>
parents:
7800
diff
changeset
|
686 void erase_subfunctions (void) { rep->erase_subfunctions (); } |
|
8447a5024650
clear subfunctions when clearing parent function
John W. Eaton <jwe@octave.org>
parents:
7800
diff
changeset
|
687 |
| 2376 | 688 // Values. |
| 689 | |
| 2891 | 690 octave_value eval (void) { return *this; } |
| 691 | |
| 5759 | 692 short int |
| 4254 | 693 short_value (bool req_int = false, bool frc_str_conv = false) const |
| 694 { return rep->short_value (req_int, frc_str_conv); } | |
| 695 | |
| 5759 | 696 unsigned short int |
| 4254 | 697 ushort_value (bool req_int = false, bool frc_str_conv = false) const |
| 698 { return rep->ushort_value (req_int, frc_str_conv); } | |
| 699 | |
| 5759 | 700 int int_value (bool req_int = false, bool frc_str_conv = false) const |
| 3202 | 701 { return rep->int_value (req_int, frc_str_conv); } |
| 702 | |
| 5759 | 703 unsigned int |
| 4254 | 704 uint_value (bool req_int = false, bool frc_str_conv = false) const |
| 705 { return rep->uint_value (req_int, frc_str_conv); } | |
| 706 | |
| 5759 | 707 int nint_value (bool frc_str_conv = false) const |
| 3202 | 708 { return rep->nint_value (frc_str_conv); } |
| 709 | |
| 5759 | 710 long int |
| 4254 | 711 long_value (bool req_int = false, bool frc_str_conv = false) const |
| 712 { return rep->long_value (req_int, frc_str_conv); } | |
| 713 | |
| 5759 | 714 unsigned long int |
| 4254 | 715 ulong_value (bool req_int = false, bool frc_str_conv = false) const |
| 716 { return rep->ulong_value (req_int, frc_str_conv); } | |
| 717 | |
| 6133 | 718 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
|
719 idx_type_value (bool req_int = false, bool frc_str_conv = false) const; |
| 6133 | 720 |
| 5759 | 721 double double_value (bool frc_str_conv = false) const |
| 2376 | 722 { return rep->double_value (frc_str_conv); } |
| 723 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
724 float float_value (bool frc_str_conv = false) const |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
725 { return rep->float_value (frc_str_conv); } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
726 |
| 5759 | 727 double scalar_value (bool frc_str_conv = false) const |
| 2916 | 728 { return rep->scalar_value (frc_str_conv); } |
| 729 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
730 float float_scalar_value (bool frc_str_conv = false) const |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
731 { return rep->float_scalar_value (frc_str_conv); } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
732 |
| 5759 | 733 Cell cell_value (void) const; |
| 3351 | 734 |
| 5759 | 735 Matrix matrix_value (bool frc_str_conv = false) const |
| 2376 | 736 { return rep->matrix_value (frc_str_conv); } |
| 737 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
738 FloatMatrix float_matrix_value (bool frc_str_conv = false) const |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
739 { return rep->float_matrix_value (frc_str_conv); } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
740 |
| 5759 | 741 NDArray array_value (bool frc_str_conv = false) const |
| 4550 | 742 { return rep->array_value (frc_str_conv); } |
| 4505 | 743 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
744 FloatNDArray float_array_value (bool frc_str_conv = false) const |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
745 { return rep->float_array_value (frc_str_conv); } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
746 |
| 5759 | 747 Complex complex_value (bool frc_str_conv = false) const |
| 2376 | 748 { return rep->complex_value (frc_str_conv); } |
| 749 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
750 FloatComplex float_complex_value (bool frc_str_conv = false) const |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
751 { return rep->float_complex_value (frc_str_conv); } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
752 |
| 5759 | 753 ComplexMatrix complex_matrix_value (bool frc_str_conv = false) const |
| 2376 | 754 { return rep->complex_matrix_value (frc_str_conv); } |
| 755 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
756 FloatComplexMatrix float_complex_matrix_value (bool frc_str_conv = false) const |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
757 { return rep->float_complex_matrix_value (frc_str_conv); } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
758 |
| 5759 | 759 ComplexNDArray complex_array_value (bool frc_str_conv = false) const |
| 4550 | 760 { return rep->complex_array_value (frc_str_conv); } |
| 761 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
762 FloatComplexNDArray float_complex_array_value (bool frc_str_conv = false) const |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
763 { return rep->float_complex_array_value (frc_str_conv); } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
764 |
| 5943 | 765 bool bool_value (bool warn = false) const |
| 766 { return rep->bool_value (warn); } | |
| 4550 | 767 |
| 5943 | 768 boolMatrix bool_matrix_value (bool warn = false) const |
| 769 { return rep->bool_matrix_value (warn); } | |
| 4550 | 770 |
| 5943 | 771 boolNDArray bool_array_value (bool warn = false) const |
| 772 { return rep->bool_array_value (warn); } | |
| 4550 | 773 |
| 5759 | 774 charMatrix char_matrix_value (bool frc_str_conv = false) const |
| 2376 | 775 { return rep->char_matrix_value (frc_str_conv); } |
| 776 | |
| 5759 | 777 charNDArray char_array_value (bool frc_str_conv = false) const |
| 4550 | 778 { return rep->char_array_value (frc_str_conv); } |
| 779 | |
| 5759 | 780 SparseMatrix sparse_matrix_value (bool frc_str_conv = false) const |
| 781 { return rep->sparse_matrix_value (frc_str_conv); } | |
| 5164 | 782 |
| 5759 | 783 SparseComplexMatrix sparse_complex_matrix_value (bool frc_str_conv = false) const |
| 784 { return rep->sparse_complex_matrix_value (frc_str_conv); } | |
| 5164 | 785 |
|
9852
aabf7a8c2e57
implement sparse logical conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9835
diff
changeset
|
786 SparseBoolMatrix sparse_bool_matrix_value (bool warn = false) const |
|
aabf7a8c2e57
implement sparse logical conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9835
diff
changeset
|
787 { return rep->sparse_bool_matrix_value (warn); } |
| 5164 | 788 |
|
8916
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
789 DiagMatrix diag_matrix_value (bool force = false) const |
|
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
790 { return rep->diag_matrix_value (force); } |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
791 |
|
8916
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
792 FloatDiagMatrix float_diag_matrix_value (bool force = false) const |
|
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
793 { 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
|
794 |
|
8916
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
795 ComplexDiagMatrix complex_diag_matrix_value (bool force = false) const |
|
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
796 { 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
|
797 |
|
8916
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
798 FloatComplexDiagMatrix float_complex_diag_matrix_value (bool force = false) const |
|
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
799 { return rep->float_complex_diag_matrix_value (force); } |
|
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
800 |
|
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
801 PermMatrix perm_matrix_value (void) const |
|
a2878ba31a9e
add diag & perm matrix query methods to octave_value
Jaroslav Hajek <highegg@gmail.com>
parents:
8811
diff
changeset
|
802 { return rep->perm_matrix_value (); } |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
803 |
| 5759 | 804 octave_int8 int8_scalar_value (void) const |
| 4910 | 805 { return rep->int8_scalar_value (); } |
| 806 | |
| 5759 | 807 octave_int16 int16_scalar_value (void) const |
| 4910 | 808 { return rep->int16_scalar_value (); } |
| 809 | |
| 5759 | 810 octave_int32 int32_scalar_value (void) const |
| 4910 | 811 { return rep->int32_scalar_value (); } |
| 812 | |
| 5759 | 813 octave_int64 int64_scalar_value (void) const |
| 4910 | 814 { return rep->int64_scalar_value (); } |
| 815 | |
| 5759 | 816 octave_uint8 uint8_scalar_value (void) const |
| 4910 | 817 { return rep->uint8_scalar_value (); } |
| 818 | |
| 5759 | 819 octave_uint16 uint16_scalar_value (void) const |
| 4910 | 820 { return rep->uint16_scalar_value (); } |
| 821 | |
| 5759 | 822 octave_uint32 uint32_scalar_value (void) const |
| 4910 | 823 { return rep->uint32_scalar_value (); } |
| 824 | |
| 5759 | 825 octave_uint64 uint64_scalar_value (void) const |
| 4910 | 826 { return rep->uint64_scalar_value (); } |
| 827 | |
| 5759 | 828 int8NDArray int8_array_value (void) const |
| 4906 | 829 { return rep->int8_array_value (); } |
| 830 | |
| 5759 | 831 int16NDArray int16_array_value (void) const |
| 4906 | 832 { return rep->int16_array_value (); } |
| 833 | |
| 5759 | 834 int32NDArray int32_array_value (void) const |
| 4906 | 835 { return rep->int32_array_value (); } |
| 836 | |
| 5759 | 837 int64NDArray int64_array_value (void) const |
| 4906 | 838 { return rep->int64_array_value (); } |
| 839 | |
| 5759 | 840 uint8NDArray uint8_array_value (void) const |
| 4906 | 841 { return rep->uint8_array_value (); } |
| 842 | |
| 5759 | 843 uint16NDArray uint16_array_value (void) const |
| 4906 | 844 { return rep->uint16_array_value (); } |
| 845 | |
| 5759 | 846 uint32NDArray uint32_array_value (void) const |
| 4906 | 847 { return rep->uint32_array_value (); } |
| 848 | |
| 5759 | 849 uint64NDArray uint64_array_value (void) const |
| 4906 | 850 { return rep->uint64_array_value (); } |
| 851 | |
| 5759 | 852 string_vector all_strings (bool pad = false) const |
| 5715 | 853 { return rep->all_strings (pad); } |
| 2376 | 854 |
| 5759 | 855 std::string string_value (bool force = false) const |
| 4665 | 856 { return rep->string_value (force); } |
| 2376 | 857 |
| 8732 | 858 Array<std::string> cellstr_value (void) const |
| 859 { return rep->cellstr_value (); } | |
| 860 | |
| 5759 | 861 Range range_value (void) const |
| 2376 | 862 { return rep->range_value (); } |
| 863 | |
|
10742
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10670
diff
changeset
|
864 octave_map map_value (void) const; |
|
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10670
diff
changeset
|
865 |
|
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10670
diff
changeset
|
866 octave_scalar_map scalar_map_value (void) const; |
|
604e13a89c7f
initial code for structs rewrite
Jaroslav Hajek <highegg@gmail.com>
parents:
10670
diff
changeset
|
867 |
| 5759 | 868 string_vector map_keys (void) const |
| 3933 | 869 { return rep->map_keys (); } |
| 870 | |
| 9151 | 871 size_t nparents (void) const |
| 872 { return rep->nparents (); } | |
| 873 | |
| 874 std::list<std::string> parent_class_name_list (void) const | |
| 875 { return rep->parent_class_name_list (); } | |
| 876 | |
|
9010
f914834836e7
Partial implementation of derived classes using the old form with "@" files.
rtshort@smoketree.phaselocked.com
parents:
8992
diff
changeset
|
877 string_vector parent_class_names (void) const |
|
f914834836e7
Partial implementation of derived classes using the old form with "@" files.
rtshort@smoketree.phaselocked.com
parents:
8992
diff
changeset
|
878 { return rep->parent_class_names (); } |
|
f914834836e7
Partial implementation of derived classes using the old form with "@" files.
rtshort@smoketree.phaselocked.com
parents:
8992
diff
changeset
|
879 |
|
f914834836e7
Partial implementation of derived classes using the old form with "@" files.
rtshort@smoketree.phaselocked.com
parents:
8992
diff
changeset
|
880 octave_base_value * |
|
f914834836e7
Partial implementation of derived classes using the old form with "@" files.
rtshort@smoketree.phaselocked.com
parents:
8992
diff
changeset
|
881 find_parent_class (const std::string& parent_class_name) |
|
f914834836e7
Partial implementation of derived classes using the old form with "@" files.
rtshort@smoketree.phaselocked.com
parents:
8992
diff
changeset
|
882 { return rep->find_parent_class (parent_class_name); } |
|
f914834836e7
Partial implementation of derived classes using the old form with "@" files.
rtshort@smoketree.phaselocked.com
parents:
8992
diff
changeset
|
883 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9881
diff
changeset
|
884 octave_function *function_value (bool silent = false) const; |
| 2974 | 885 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9881
diff
changeset
|
886 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
|
887 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9881
diff
changeset
|
888 octave_user_script *user_script_value (bool silent = false) const; |
| 4700 | 889 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9881
diff
changeset
|
890 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
|
891 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9881
diff
changeset
|
892 octave_fcn_handle *fcn_handle_value (bool silent = false) const; |
| 4343 | 893 |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
9881
diff
changeset
|
894 octave_fcn_inline *fcn_inline_value (bool silent = false) const; |
| 4933 | 895 |
| 5759 | 896 octave_value_list list_value (void) const; |
| 2880 | 897 |
| 3419 | 898 ColumnVector column_vector_value (bool frc_str_conv = false, |
| 10313 | 899 bool frc_vec_conv = false) const; |
| 2376 | 900 |
| 901 ComplexColumnVector | |
| 3419 | 902 complex_column_vector_value (bool frc_str_conv = false, |
| 10313 | 903 bool frc_vec_conv = false) const; |
| 2376 | 904 |
| 3419 | 905 RowVector row_vector_value (bool frc_str_conv = false, |
| 10313 | 906 bool frc_vec_conv = false) const; |
| 3419 | 907 |
| 908 ComplexRowVector | |
| 909 complex_row_vector_value (bool frc_str_conv = false, | |
| 10313 | 910 bool frc_vec_conv = false) const; |
| 3419 | 911 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
912 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
913 FloatColumnVector float_column_vector_value (bool frc_str_conv = false, |
| 10313 | 914 bool frc_vec_conv = false) const; |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
915 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
916 FloatComplexColumnVector |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
917 float_complex_column_vector_value (bool frc_str_conv = false, |
| 10313 | 918 bool frc_vec_conv = false) const; |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
919 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
920 FloatRowVector float_row_vector_value (bool frc_str_conv = false, |
| 10313 | 921 bool frc_vec_conv = false) const; |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
922 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
923 FloatComplexRowVector |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
924 float_complex_row_vector_value (bool frc_str_conv = false, |
| 10313 | 925 bool frc_vec_conv = false) const; |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
926 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
927 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
928 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
929 |
| 4044 | 930 Array<int> int_vector_value (bool req_int = false, |
| 10313 | 931 bool frc_str_conv = false, |
| 932 bool frc_vec_conv = false) const; | |
| 4044 | 933 |
| 8811 | 934 Array<octave_idx_type> |
| 935 octave_idx_type_vector_value (bool req_int = false, | |
| 10313 | 936 bool frc_str_conv = false, |
| 937 bool frc_vec_conv = false) const; | |
| 8811 | 938 |
| 3419 | 939 Array<double> vector_value (bool frc_str_conv = false, |
| 10313 | 940 bool frc_vec_conv = false) const; |
| 3419 | 941 |
| 942 Array<Complex> complex_vector_value (bool frc_str_conv = false, | |
| 10313 | 943 bool frc_vec_conv = false) const; |
| 3419 | 944 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
945 Array<float> float_vector_value (bool frc_str_conv = false, |
| 10313 | 946 bool frc_vec_conv = false) const; |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
947 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
948 Array<FloatComplex> float_complex_vector_value (bool frc_str_conv = false, |
| 10313 | 949 bool frc_vec_conv = false) const; |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
950 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
951 // Possibly economize a lazy-indexed value. |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8017
diff
changeset
|
952 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
953 void maybe_economize (void) |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
954 { rep->maybe_economize (); } |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
955 |
|
8531
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8523
diff
changeset
|
956 // 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
|
957 // 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
|
958 // 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
|
959 |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
960 octave_value storable_value (void) const; |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8017
diff
changeset
|
961 |
|
8531
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8523
diff
changeset
|
962 // Ditto, but in place, i.e. equivalent to *this = this->storable_value (), |
|
b01fef323c24
add some explaining comments
Jaroslav Hajek <highegg@gmail.com>
parents:
8523
diff
changeset
|
963 // but possibly more efficient. |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8017
diff
changeset
|
964 |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8458
diff
changeset
|
965 void make_storable_value (void); |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8017
diff
changeset
|
966 |
| 2376 | 967 // Conversions. These should probably be private. If a user of this |
| 968 // class wants a certain kind of constant, he should simply ask for | |
| 969 // it, and we should convert it if possible. | |
| 970 | |
| 5279 | 971 octave_value convert_to_str (bool pad = false, bool force = false, |
| 10313 | 972 char type = '\'') const |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9685
diff
changeset
|
973 { return rep->convert_to_str (pad, force, type); } |
| 4452 | 974 |
| 5759 | 975 octave_value |
| 5279 | 976 convert_to_str_internal (bool pad, bool force, char type) const |
| 977 { return rep->convert_to_str_internal (pad, force, type); } | |
| 2376 | 978 |
| 5759 | 979 void convert_to_row_or_column_vector (void) |
| 2376 | 980 { rep->convert_to_row_or_column_vector (); } |
| 981 | |
| 5759 | 982 bool print_as_scalar (void) const |
| 4604 | 983 { return rep->print_as_scalar (); } |
| 984 | |
| 5759 | 985 void print (std::ostream& os, bool pr_as_read_syntax = false) const |
| 2466 | 986 { rep->print (os, pr_as_read_syntax); } |
| 2376 | 987 |
| 5759 | 988 void print_raw (std::ostream& os, |
| 10313 | 989 bool pr_as_read_syntax = false) const |
| 2903 | 990 { rep->print_raw (os, pr_as_read_syntax); } |
| 991 | |
| 5759 | 992 bool print_name_tag (std::ostream& os, const std::string& name) const |
| 2903 | 993 { return rep->print_name_tag (os, name); } |
| 2376 | 994 |
|
13110
2d5035847529
Add Júlio Hoffimann Mendes to contributors.in
John W. Eaton <jwe@octave.org>
parents:
12171
diff
changeset
|
995 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
|
996 { rep->print_with_name (os, name, true); } |
| 2376 | 997 |
| 5759 | 998 int type_id (void) const { return rep->type_id (); } |
| 2376 | 999 |
| 5759 | 1000 std::string type_name (void) const { return rep->type_name (); } |
| 1001 | |
| 1002 std::string class_name (void) const { return rep->class_name (); } | |
| 4612 | 1003 |
| 3203 | 1004 // Unary and binary operations. |
| 1005 | |
| 6109 | 1006 friend OCTINTERP_API octave_value do_unary_op (unary_op op, |
| 10313 | 1007 const octave_value& a); |
| 3203 | 1008 |
|
10614
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
1009 octave_value& do_non_const_unary_op (unary_op op); |
| 3933 | 1010 |
|
10614
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
1011 octave_value& do_non_const_unary_op (unary_op op, const std::string& type, |
| 10313 | 1012 const std::list<octave_value_list>& idx); |
| 3205 | 1013 |
| 6109 | 1014 friend OCTINTERP_API octave_value do_binary_op (binary_op op, |
| 10313 | 1015 const octave_value& a, |
| 1016 const octave_value& b); | |
| 2376 | 1017 |
|
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
|
1018 friend OCTINTERP_API octave_value do_binary_op (compound_binary_op 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
|
1019 const octave_value& a, |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1020 const octave_value& b); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1021 |
| 6109 | 1022 friend OCTINTERP_API octave_value do_cat_op (const octave_value& a, |
| 10313 | 1023 const octave_value& b, |
| 1024 const Array<octave_idx_type>& ra_idx); | |
| 4915 | 1025 |
| 5759 | 1026 const octave_base_value& get_rep (void) const { return *rep; } |
| 3301 | 1027 |
|
8456
c1709a45b45b
optimize structure components access
Jaroslav Hajek <highegg@gmail.com>
parents:
8437
diff
changeset
|
1028 bool is_copy_of (const octave_value &val) const { return rep == val.rep; } |
|
c1709a45b45b
optimize structure components access
Jaroslav Hajek <highegg@gmail.com>
parents:
8437
diff
changeset
|
1029 |
| 5759 | 1030 void print_info (std::ostream& os, |
| 10313 | 1031 const std::string& prefix = std::string ()) const; |
| 3933 | 1032 |
| 6974 | 1033 bool save_ascii (std::ostream& os) { return rep->save_ascii (os); } |
| 4687 | 1034 |
| 6974 | 1035 bool load_ascii (std::istream& is) { return rep->load_ascii (is); } |
| 4687 | 1036 |
| 5759 | 1037 bool save_binary (std::ostream& os, bool& save_as_floats) |
| 4687 | 1038 { return rep->save_binary (os, save_as_floats); } |
| 1039 | |
| 5759 | 1040 bool load_binary (std::istream& is, bool swap, |
| 10313 | 1041 oct_mach_info::float_format fmt) |
| 4687 | 1042 { return rep->load_binary (is, swap, fmt); } |
| 1043 | |
| 1044 #if defined (HAVE_HDF5) | |
| 5759 | 1045 bool save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) |
| 4687 | 1046 { return rep->save_hdf5 (loc_id, name, save_as_floats); } |
| 1047 | |
|
9881
b3089dba88bf
Remove HDF5 cruft for older versions of HDF5
Kacper Kowalik
parents:
9852
diff
changeset
|
1048 bool load_hdf5 (hid_t loc_id, const char *name) |
|
b3089dba88bf
Remove HDF5 cruft for older versions of HDF5
Kacper Kowalik
parents:
9852
diff
changeset
|
1049 { return rep->load_hdf5 (loc_id, name); } |
| 4687 | 1050 #endif |
| 1051 | |
| 5759 | 1052 int write (octave_stream& os, int block_size, |
| 10313 | 1053 oct_data_conv::data_type output_type, int skip, |
| 1054 oct_mach_info::float_format flt_fmt) const; | |
| 4944 | 1055 |
| 5759 | 1056 octave_base_value *internal_rep (void) const { return rep; } |
| 4901 | 1057 |
| 5900 | 1058 // Unsafe. These functions exist to support the MEX interface. |
| 1059 // You should not use them anywhere else. | |
| 1060 void *mex_get_data (void) const { return rep->mex_get_data (); } | |
| 1061 | |
| 1062 octave_idx_type *mex_get_ir (void) const { return rep->mex_get_ir (); } | |
| 1063 | |
| 1064 octave_idx_type *mex_get_jc (void) const { return rep->mex_get_jc (); } | |
| 1065 | |
| 1066 mxArray *as_mxArray (void) const { return rep->as_mxArray (); } | |
| 1067 | |
|
7620
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7576
diff
changeset
|
1068 octave_value diag (octave_idx_type k = 0) const |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7576
diff
changeset
|
1069 { return rep->diag (k); } |
|
36594d5bbe13
Move diag function into the octave_value class
David Bateman <dbateman@free.fr>
parents:
7576
diff
changeset
|
1070 |
|
7463
2467639bd8c0
eliminate UNDEFINED sort mode
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
1071 octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1072 { return rep->sort (dim, mode); } |
| 7433 | 1073 octave_value sort (Array<octave_idx_type> &sidx, octave_idx_type dim = 0, |
| 10313 | 1074 sortmode mode = ASCENDING) const |
|
11586
12df7854fa7c
strip trailing whitespace from source files
John W. Eaton <jwe@octave.org>
parents:
11523
diff
changeset
|
1075 { return rep->sort (sidx, dim, mode); } |
| 7433 | 1076 |
|
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
|
1077 sortmode is_sorted (sortmode mode = UNSORTED) const |
|
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
|
1078 { return rep->is_sorted (mode); } |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8676
diff
changeset
|
1079 |
|
8733
3ef774603887
rename all uses of sortrows_idx to sort_rows_idx
John W. Eaton <jwe@octave.org>
parents:
8732
diff
changeset
|
1080 Array<octave_idx_type> sort_rows_idx (sortmode mode = ASCENDING) const |
|
3ef774603887
rename all uses of sortrows_idx to sort_rows_idx
John W. Eaton <jwe@octave.org>
parents:
8732
diff
changeset
|
1081 { return rep->sort_rows_idx (mode); } |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8676
diff
changeset
|
1082 |
|
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
|
1083 sortmode is_sorted_rows (sortmode mode = UNSORTED) const |
|
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
|
1084 { return rep->is_sorted_rows (mode); } |
|
8721
e9cb742df9eb
imported patch sort3.diff
Jaroslav Hajek <highegg@gmail.com>
parents:
8676
diff
changeset
|
1085 |
|
7489
8e4592e49fa7
don't clear locked functions
John W. Eaton <jwe@octave.org>
parents:
7463
diff
changeset
|
1086 void lock (void) { rep->lock (); } |
|
8e4592e49fa7
don't clear locked functions
John W. Eaton <jwe@octave.org>
parents:
7463
diff
changeset
|
1087 |
|
8e4592e49fa7
don't clear locked functions
John W. Eaton <jwe@octave.org>
parents:
7463
diff
changeset
|
1088 void unlock (void) { rep->unlock (); } |
|
8e4592e49fa7
don't clear locked functions
John W. Eaton <jwe@octave.org>
parents:
7463
diff
changeset
|
1089 |
|
8e4592e49fa7
don't clear locked functions
John W. Eaton <jwe@octave.org>
parents:
7463
diff
changeset
|
1090 bool islocked (void) const { return rep->islocked (); } |
|
8e4592e49fa7
don't clear locked functions
John W. Eaton <jwe@octave.org>
parents:
7463
diff
changeset
|
1091 |
|
7761
5adeea5de26c
symbol table reporting functions
John W. Eaton <jwe@octave.org>
parents:
7740
diff
changeset
|
1092 void dump (std::ostream& os) const { rep->dump (os); } |
|
5adeea5de26c
symbol table reporting functions
John W. Eaton <jwe@octave.org>
parents:
7740
diff
changeset
|
1093 |
|
9813
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1094 #define MAPPER_FORWARD(F) \ |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1095 octave_value F (void) const { return rep->map (octave_base_value::umap_ ## F); } |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1096 |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1097 MAPPER_FORWARD (abs) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1098 MAPPER_FORWARD (acos) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1099 MAPPER_FORWARD (acosh) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1100 MAPPER_FORWARD (angle) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1101 MAPPER_FORWARD (arg) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1102 MAPPER_FORWARD (asin) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1103 MAPPER_FORWARD (asinh) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1104 MAPPER_FORWARD (atan) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1105 MAPPER_FORWARD (atanh) |
|
10414
2a8b1db1e2ca
implement built-in cbrt
Jaroslav Hajek <highegg@gmail.com>
parents:
10391
diff
changeset
|
1106 MAPPER_FORWARD (cbrt) |
|
9813
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1107 MAPPER_FORWARD (ceil) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1108 MAPPER_FORWARD (conj) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1109 MAPPER_FORWARD (cos) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1110 MAPPER_FORWARD (cosh) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1111 MAPPER_FORWARD (erf) |
|
9835
1bb1ed717d2f
implement built-in erfinv
Jaroslav Hajek <highegg@gmail.com>
parents:
9813
diff
changeset
|
1112 MAPPER_FORWARD (erfinv) |
|
9813
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1113 MAPPER_FORWARD (erfc) |
|
10391
59e34bcdff13
implement built-in erfcx
Jaroslav Hajek <highegg@gmail.com>
parents:
10325
diff
changeset
|
1114 MAPPER_FORWARD (erfcx) |
|
9813
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1115 MAPPER_FORWARD (exp) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1116 MAPPER_FORWARD (expm1) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1117 MAPPER_FORWARD (finite) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1118 MAPPER_FORWARD (fix) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1119 MAPPER_FORWARD (floor) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1120 MAPPER_FORWARD (gamma) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1121 MAPPER_FORWARD (imag) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1122 MAPPER_FORWARD (isinf) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1123 MAPPER_FORWARD (isna) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1124 MAPPER_FORWARD (isnan) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1125 MAPPER_FORWARD (lgamma) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1126 MAPPER_FORWARD (log) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1127 MAPPER_FORWARD (log2) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1128 MAPPER_FORWARD (log10) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1129 MAPPER_FORWARD (log1p) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1130 MAPPER_FORWARD (real) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1131 MAPPER_FORWARD (round) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1132 MAPPER_FORWARD (roundb) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1133 MAPPER_FORWARD (signum) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1134 MAPPER_FORWARD (sin) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1135 MAPPER_FORWARD (sinh) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1136 MAPPER_FORWARD (sqrt) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1137 MAPPER_FORWARD (tan) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1138 MAPPER_FORWARD (tanh) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1139 |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1140 // These functions are prefixed with X to avoid potential macro |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1141 // conflicts. |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1142 |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1143 MAPPER_FORWARD (xisalnum) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1144 MAPPER_FORWARD (xisalpha) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1145 MAPPER_FORWARD (xisascii) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1146 MAPPER_FORWARD (xiscntrl) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1147 MAPPER_FORWARD (xisdigit) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1148 MAPPER_FORWARD (xisgraph) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1149 MAPPER_FORWARD (xislower) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1150 MAPPER_FORWARD (xisprint) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1151 MAPPER_FORWARD (xispunct) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1152 MAPPER_FORWARD (xisspace) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1153 MAPPER_FORWARD (xisupper) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1154 MAPPER_FORWARD (xisxdigit) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1155 MAPPER_FORWARD (xtoascii) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1156 MAPPER_FORWARD (xtolower) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1157 MAPPER_FORWARD (xtoupper) |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1158 |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1159 #undef MAPPER_FORWARD |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1160 |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1161 octave_value map (octave_base_value::unary_mapper_t umap) const |
|
8fa32b527d9a
improve & partially revert previous change
Jaroslav Hajek <highegg@gmail.com>
parents:
9812
diff
changeset
|
1162 { return rep->map (umap); } |
|
7503
8c32f95c2639
convert mapper functions to new format
David Bateman <dbateman@free.fr>
parents:
7489
diff
changeset
|
1163 |
|
10670
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1164 // Extract the n-th element, aka val(n). Result is undefined if val is not an |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1165 // array type or n is out of range. Never error. |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1166 octave_value |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1167 fast_elem_extract (octave_idx_type n) const |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1168 { return rep->fast_elem_extract (n); } |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1169 |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1170 // Assign the n-th element, aka val(n) = x. Returns false if val is not an |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1171 // array type, x is not a matching scalar type, or n is out of range. |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1172 // Never error. |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1173 virtual bool |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1174 fast_elem_insert (octave_idx_type n, const octave_value& x) |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1175 { |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1176 make_unique (); |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1177 return rep->fast_elem_insert (n, x); |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1178 } |
|
654fbde5dceb
make cellfun's fast scalar collection mechanism public
Jaroslav Hajek <highegg@gmail.com>
parents:
10614
diff
changeset
|
1179 |
| 2376 | 1180 protected: |
| 1181 | |
| 5759 | 1182 // The real representation. |
| 1183 octave_base_value *rep; | |
| 2413 | 1184 |
| 3933 | 1185 private: |
| 2903 | 1186 |
| 3205 | 1187 assign_op unary_op_to_assign_op (unary_op op); |
| 1188 | |
| 3204 | 1189 binary_op op_eq_to_binary_op (assign_op op); |
| 1190 | |
| 9521 | 1191 // This declaration protects against constructing octave_value from |
| 1192 // const octave_base_value* which actually silently calls octave_value (bool). | |
| 1193 octave_value (const octave_base_value *); | |
| 1194 | |
| 3219 | 1195 DECLARE_OCTAVE_ALLOCATOR |
| 2376 | 1196 }; |
| 1197 | |
| 5508 | 1198 // Publish externally used friend functions. |
| 1199 | |
| 6109 | 1200 extern OCTINTERP_API octave_value |
| 5508 | 1201 do_unary_op (octave_value::unary_op op, const octave_value& a); |
| 1202 | |
| 6109 | 1203 extern OCTINTERP_API octave_value |
| 5508 | 1204 do_binary_op (octave_value::binary_op op, |
| 10313 | 1205 const octave_value& a, const octave_value& b); |
| 5508 | 1206 |
|
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
|
1207 extern OCTINTERP_API octave_value |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1208 do_binary_op (octave_value::compound_binary_op 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
|
1209 const octave_value& a, const octave_value& b); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1210 |
| 3203 | 1211 #define OV_UNOP_FN(name) \ |
| 1212 inline octave_value \ | |
| 1213 name (const octave_value& a) \ | |
| 1214 { \ | |
| 1215 return do_unary_op (octave_value::name, a); \ | |
| 1216 } | |
| 1217 | |
| 1218 #define OV_UNOP_OP(name, op) \ | |
| 1219 inline octave_value \ | |
| 1220 operator op (const octave_value& a) \ | |
| 1221 { \ | |
| 1222 return name (a); \ | |
| 1223 } | |
| 1224 | |
| 1225 #define OV_UNOP_FN_OP(name, op) \ | |
| 1226 OV_UNOP_FN (name) \ | |
| 1227 OV_UNOP_OP (name, op) | |
| 1228 | |
| 3525 | 1229 OV_UNOP_FN_OP (op_not, !) |
| 6518 | 1230 OV_UNOP_FN_OP (op_uplus, +) |
| 3525 | 1231 OV_UNOP_FN_OP (op_uminus, -) |
| 3203 | 1232 |
| 3525 | 1233 OV_UNOP_FN (op_transpose) |
| 1234 OV_UNOP_FN (op_hermitian) | |
| 3203 | 1235 |
| 1236 // No simple way to define these for prefix and suffix ops? | |
| 1237 // | |
| 1238 // incr | |
| 1239 // decr | |
| 1240 | |
| 1241 #define OV_BINOP_FN(name) \ | |
| 1242 inline octave_value \ | |
| 1243 name (const octave_value& a1, const octave_value& a2) \ | |
| 1244 { \ | |
| 1245 return do_binary_op (octave_value::name, a1, a2); \ | |
| 1246 } | |
| 1247 | |
| 1248 #define OV_BINOP_OP(name, op) \ | |
| 1249 inline octave_value \ | |
| 1250 operator op (const octave_value& a1, const octave_value& a2) \ | |
| 1251 { \ | |
| 1252 return name (a1, a2); \ | |
| 1253 } | |
| 1254 | |
| 1255 #define OV_BINOP_FN_OP(name, op) \ | |
| 1256 OV_BINOP_FN (name) \ | |
| 1257 OV_BINOP_OP (name, op) | |
| 1258 | |
| 3525 | 1259 OV_BINOP_FN_OP (op_add, +) |
| 1260 OV_BINOP_FN_OP (op_sub, -) | |
| 1261 OV_BINOP_FN_OP (op_mul, *) | |
| 1262 OV_BINOP_FN_OP (op_div, /) | |
| 3203 | 1263 |
| 3525 | 1264 OV_BINOP_FN (op_pow) |
| 1265 OV_BINOP_FN (op_ldiv) | |
| 1266 OV_BINOP_FN (op_lshift) | |
| 1267 OV_BINOP_FN (op_rshift) | |
| 3203 | 1268 |
| 3525 | 1269 OV_BINOP_FN_OP (op_lt, <) |
| 1270 OV_BINOP_FN_OP (op_le, <=) | |
| 1271 OV_BINOP_FN_OP (op_eq, ==) | |
| 1272 OV_BINOP_FN_OP (op_ge, >=) | |
| 1273 OV_BINOP_FN_OP (op_gt, >) | |
| 1274 OV_BINOP_FN_OP (op_ne, !=) | |
| 3203 | 1275 |
| 3525 | 1276 OV_BINOP_FN (op_el_mul) |
| 1277 OV_BINOP_FN (op_el_div) | |
| 1278 OV_BINOP_FN (op_el_pow) | |
| 1279 OV_BINOP_FN (op_el_ldiv) | |
| 1280 OV_BINOP_FN (op_el_and) | |
| 1281 OV_BINOP_FN (op_el_or) | |
| 3203 | 1282 |
| 3525 | 1283 OV_BINOP_FN (op_struct_ref) |
| 3203 | 1284 |
|
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
|
1285 #define OV_COMP_BINOP_FN(name) \ |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1286 inline octave_value \ |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1287 name (const octave_value& a1, const octave_value& a2) \ |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1288 { \ |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1289 return do_binary_op (octave_value::name, a1, a2); \ |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1290 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1291 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
1292 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
|
1293 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
|
1294 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
|
1295 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
|
1296 |
| 6109 | 1297 extern OCTINTERP_API void install_types (void); |
| 2376 | 1298 |
| 5759 | 1299 // This will eventually go away, but for now it can be used to |
| 1300 // simplify the transition to the new octave_value class hierarchy, | |
| 1301 // which uses octave_base_value instead of octave_value for the type | |
| 1302 // of octave_value::rep. | |
| 1303 #define OV_REP_TYPE octave_base_value | |
| 1304 | |
|
9657
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1305 // Templated value extractors. |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1306 template<class Value> |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1307 inline Value octave_value_extract (const octave_value&) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1308 { assert (false); } |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1309 |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1310 #define DEF_VALUE_EXTRACTOR(VALUE,MPREFIX) \ |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1311 template<> \ |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1312 inline VALUE octave_value_extract<VALUE> (const octave_value& v) \ |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1313 { return v.MPREFIX ## _value (); } |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1314 |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1315 DEF_VALUE_EXTRACTOR (double, scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1316 DEF_VALUE_EXTRACTOR (float, float_scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1317 DEF_VALUE_EXTRACTOR (Complex, complex) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1318 DEF_VALUE_EXTRACTOR (FloatComplex, float_complex) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1319 DEF_VALUE_EXTRACTOR (bool, bool) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1320 |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1321 DEF_VALUE_EXTRACTOR (octave_int8, int8_scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1322 DEF_VALUE_EXTRACTOR (octave_int16, int16_scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1323 DEF_VALUE_EXTRACTOR (octave_int32, int32_scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1324 DEF_VALUE_EXTRACTOR (octave_int64, int64_scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1325 DEF_VALUE_EXTRACTOR (octave_uint8, uint8_scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1326 DEF_VALUE_EXTRACTOR (octave_uint16, uint16_scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1327 DEF_VALUE_EXTRACTOR (octave_uint32, uint32_scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1328 DEF_VALUE_EXTRACTOR (octave_uint64, uint64_scalar) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1329 |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1330 |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1331 DEF_VALUE_EXTRACTOR (NDArray, array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1332 DEF_VALUE_EXTRACTOR (FloatNDArray, float_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1333 DEF_VALUE_EXTRACTOR (ComplexNDArray, complex_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1334 DEF_VALUE_EXTRACTOR (FloatComplexNDArray, float_complex_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1335 DEF_VALUE_EXTRACTOR (boolNDArray, bool_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1336 |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1337 DEF_VALUE_EXTRACTOR (charNDArray, char_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1338 DEF_VALUE_EXTRACTOR (int8NDArray, int8_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1339 DEF_VALUE_EXTRACTOR (int16NDArray, int16_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1340 DEF_VALUE_EXTRACTOR (int32NDArray, int32_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1341 DEF_VALUE_EXTRACTOR (int64NDArray, int64_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1342 DEF_VALUE_EXTRACTOR (uint8NDArray, uint8_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1343 DEF_VALUE_EXTRACTOR (uint16NDArray, uint16_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1344 DEF_VALUE_EXTRACTOR (uint32NDArray, uint32_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1345 DEF_VALUE_EXTRACTOR (uint64NDArray, uint64_array) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1346 |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1347 DEF_VALUE_EXTRACTOR (Matrix, matrix) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1348 DEF_VALUE_EXTRACTOR (FloatMatrix, float_matrix) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1349 DEF_VALUE_EXTRACTOR (ComplexMatrix, complex_matrix) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1350 DEF_VALUE_EXTRACTOR (FloatComplexMatrix, float_complex_matrix) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1351 DEF_VALUE_EXTRACTOR (boolMatrix, bool_matrix) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1352 |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1353 DEF_VALUE_EXTRACTOR (ColumnVector, column_vector) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1354 DEF_VALUE_EXTRACTOR (FloatColumnVector, float_column_vector) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1355 DEF_VALUE_EXTRACTOR (ComplexColumnVector, complex_column_vector) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1356 DEF_VALUE_EXTRACTOR (FloatComplexColumnVector, float_complex_column_vector) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1357 |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1358 DEF_VALUE_EXTRACTOR (RowVector, row_vector) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1359 DEF_VALUE_EXTRACTOR (FloatRowVector, float_row_vector) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1360 DEF_VALUE_EXTRACTOR (ComplexRowVector, complex_row_vector) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1361 DEF_VALUE_EXTRACTOR (FloatComplexRowVector, float_complex_row_vector) |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1362 |
| 9685 | 1363 DEF_VALUE_EXTRACTOR (DiagMatrix, diag_matrix) |
| 1364 DEF_VALUE_EXTRACTOR (FloatDiagMatrix, float_diag_matrix) | |
| 1365 DEF_VALUE_EXTRACTOR (ComplexDiagMatrix, complex_diag_matrix) | |
| 1366 DEF_VALUE_EXTRACTOR (FloatComplexDiagMatrix, float_complex_diag_matrix) | |
| 1367 DEF_VALUE_EXTRACTOR (PermMatrix, perm_matrix) | |
| 1368 | |
|
9789
97f5de91427b
support sparse templated extractors
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
1369 DEF_VALUE_EXTRACTOR (SparseMatrix, sparse_matrix) |
|
97f5de91427b
support sparse templated extractors
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
1370 DEF_VALUE_EXTRACTOR (SparseComplexMatrix, sparse_complex_matrix) |
|
97f5de91427b
support sparse templated extractors
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
1371 DEF_VALUE_EXTRACTOR (SparseBoolMatrix, sparse_bool_matrix) |
|
9657
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1372 #undef DEF_VALUE_EXTRACTOR |
|
3c1c3a38ec7b
implement templated octave_value extractor
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1373 |
| 2376 | 1374 #endif |