Mercurial > octave-nkf
annotate src/ov.cc @ 10614:d1194069e58c
optimize code handling ++,--
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Sat, 08 May 2010 15:15:22 +0200 |
| parents | 9961fc022d9d |
| children | 984b8b6bee02 |
| rev | line source |
|---|---|
| 2376 | 1 /* |
| 2 | |
| 7017 | 3 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, |
| 8920 | 4 2006, 2007, 2008, 2009 John W. Eaton |
|
10521
4d1fc073fbb7
add some missing copyright stmts
Jaroslav Hajek <highegg@gmail.com>
parents:
10405
diff
changeset
|
5 Copyright (C) 2009, 2010 VZLU Prague |
| 2376 | 6 |
| 7 This file is part of Octave. | |
| 8 | |
| 9 Octave is free software; you can redistribute it and/or modify it | |
| 10 under the terms of the GNU General Public License as published by the | |
| 7016 | 11 Free Software Foundation; either version 3 of the License, or (at your |
| 12 option) any later version. | |
| 2376 | 13 |
| 14 Octave is distributed in the hope that it will be useful, but WITHOUT | |
| 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 17 for more details. | |
| 18 | |
| 19 You should have received a copy of the GNU General Public License | |
| 7016 | 20 along with Octave; see the file COPYING. If not, see |
| 21 <http://www.gnu.org/licenses/>. | |
| 2376 | 22 |
| 23 */ | |
| 24 | |
| 25 #ifdef HAVE_CONFIG_H | |
| 26 #include <config.h> | |
| 27 #endif | |
| 28 | |
| 4970 | 29 #include "data-conv.h" |
| 30 #include "quit.h" | |
| 2942 | 31 #include "str-vec.h" |
| 2376 | 32 |
| 2974 | 33 #include "oct-obj.h" |
| 4944 | 34 #include "oct-stream.h" |
| 2376 | 35 #include "ov.h" |
| 36 #include "ov-base.h" | |
| 2825 | 37 #include "ov-bool.h" |
| 38 #include "ov-bool-mat.h" | |
| 3351 | 39 #include "ov-cell.h" |
| 2376 | 40 #include "ov-scalar.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
41 #include "ov-float.h" |
| 2376 | 42 #include "ov-re-mat.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
43 #include "ov-flt-re-mat.h" |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
44 #include "ov-re-diag.h" |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
45 #include "ov-flt-re-diag.h" |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
46 #include "ov-perm.h" |
| 5164 | 47 #include "ov-bool-sparse.h" |
| 48 #include "ov-cx-sparse.h" | |
| 49 #include "ov-re-sparse.h" | |
| 4901 | 50 #include "ov-int8.h" |
| 51 #include "ov-int16.h" | |
| 52 #include "ov-int32.h" | |
| 53 #include "ov-int64.h" | |
| 54 #include "ov-uint8.h" | |
| 55 #include "ov-uint16.h" | |
| 56 #include "ov-uint32.h" | |
| 57 #include "ov-uint64.h" | |
| 2376 | 58 #include "ov-complex.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
59 #include "ov-flt-complex.h" |
| 2376 | 60 #include "ov-cx-mat.h" |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
61 #include "ov-flt-cx-mat.h" |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
62 #include "ov-cx-diag.h" |
|
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
63 #include "ov-flt-cx-diag.h" |
| 2376 | 64 #include "ov-ch-mat.h" |
| 65 #include "ov-str-mat.h" | |
| 66 #include "ov-range.h" | |
| 67 #include "ov-struct.h" | |
| 7336 | 68 #include "ov-class.h" |
| 3977 | 69 #include "ov-cs-list.h" |
| 2376 | 70 #include "ov-colon.h" |
| 2974 | 71 #include "ov-builtin.h" |
| 4649 | 72 #include "ov-dld-fcn.h" |
| 2974 | 73 #include "ov-usr-fcn.h" |
| 4342 | 74 #include "ov-fcn-handle.h" |
| 4966 | 75 #include "ov-fcn-inline.h" |
| 2376 | 76 #include "ov-typeinfo.h" |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
77 #include "ov-null-mat.h" |
|
10325
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
78 #include "ov-lazy-idx.h" |
| 2376 | 79 |
| 80 #include "defun.h" | |
| 2880 | 81 #include "error.h" |
| 2376 | 82 #include "gripes.h" |
| 83 #include "pager.h" | |
| 4005 | 84 #include "parse.h" |
| 2376 | 85 #include "pr-output.h" |
| 7336 | 86 #include "symtab.h" |
| 2376 | 87 #include "utils.h" |
| 88 #include "variables.h" | |
| 89 | |
| 2477 | 90 // We are likely to have a lot of octave_value objects to allocate, so |
| 91 // make the grow_size large. | |
| 3219 | 92 DEFINE_OCTAVE_ALLOCATOR2(octave_value, 1024); |
| 2477 | 93 |
| 5775 | 94 // FIXME |
| 2880 | 95 |
| 2376 | 96 // Octave's value type. |
| 97 | |
| 3536 | 98 std::string |
| 3203 | 99 octave_value::unary_op_as_string (unary_op op) |
| 100 { | |
| 3523 | 101 std::string retval; |
| 3203 | 102 |
| 103 switch (op) | |
| 104 { | |
| 3533 | 105 case op_not: |
| 3203 | 106 retval = "!"; |
| 107 break; | |
| 108 | |
| 4965 | 109 case op_uplus: |
| 110 retval = "+"; | |
| 111 break; | |
| 112 | |
| 3533 | 113 case op_uminus: |
| 3203 | 114 retval = "-"; |
| 115 break; | |
| 116 | |
| 3533 | 117 case op_transpose: |
| 3203 | 118 retval = ".'"; |
| 119 break; | |
| 120 | |
| 3533 | 121 case op_hermitian: |
| 3203 | 122 retval = "'"; |
| 123 break; | |
| 124 | |
| 3533 | 125 case op_incr: |
| 3203 | 126 retval = "++"; |
| 127 break; | |
| 128 | |
| 3533 | 129 case op_decr: |
| 3203 | 130 retval = "--"; |
| 131 break; | |
| 132 | |
| 133 default: | |
| 134 retval = "<unknown>"; | |
| 135 } | |
| 136 | |
| 137 return retval; | |
| 138 } | |
| 139 | |
| 3536 | 140 std::string |
| 7336 | 141 octave_value::unary_op_fcn_name (unary_op op) |
| 142 { | |
| 143 std::string retval; | |
| 144 | |
| 145 switch (op) | |
| 146 { | |
| 147 case op_not: | |
| 148 retval = "not"; | |
| 149 break; | |
| 150 | |
| 151 case op_uplus: | |
| 152 retval = "uplus"; | |
| 153 break; | |
| 154 | |
| 155 case op_uminus: | |
| 156 retval = "uminus"; | |
| 157 break; | |
| 158 | |
| 159 case op_transpose: | |
| 160 retval = "transpose"; | |
| 161 break; | |
| 162 | |
| 163 case op_hermitian: | |
| 164 retval = "ctranspose"; | |
| 165 break; | |
| 166 | |
| 167 default: | |
| 168 break; | |
| 169 } | |
| 170 | |
| 171 return retval; | |
| 172 } | |
| 173 | |
| 174 std::string | |
| 2376 | 175 octave_value::binary_op_as_string (binary_op op) |
| 176 { | |
| 3523 | 177 std::string retval; |
| 2376 | 178 |
| 179 switch (op) | |
| 180 { | |
| 3533 | 181 case op_add: |
| 2376 | 182 retval = "+"; |
| 183 break; | |
| 184 | |
| 3533 | 185 case op_sub: |
| 2376 | 186 retval = "-"; |
| 187 break; | |
| 188 | |
| 3533 | 189 case op_mul: |
| 2376 | 190 retval = "*"; |
| 191 break; | |
| 192 | |
| 3533 | 193 case op_div: |
| 2376 | 194 retval = "/"; |
| 195 break; | |
| 196 | |
| 3533 | 197 case op_pow: |
| 2376 | 198 retval = "^"; |
| 199 break; | |
| 200 | |
| 3533 | 201 case op_ldiv: |
| 2376 | 202 retval = "\\"; |
| 203 break; | |
| 204 | |
| 3533 | 205 case op_lshift: |
| 2903 | 206 retval = "<<"; |
| 207 break; | |
| 208 | |
| 3533 | 209 case op_rshift: |
| 2903 | 210 retval = ">>"; |
| 211 break; | |
| 212 | |
| 3533 | 213 case op_lt: |
| 2376 | 214 retval = "<"; |
| 215 break; | |
| 216 | |
| 3533 | 217 case op_le: |
| 2376 | 218 retval = "<="; |
| 219 break; | |
| 220 | |
| 3533 | 221 case op_eq: |
| 2376 | 222 retval = "=="; |
| 223 break; | |
| 224 | |
| 3533 | 225 case op_ge: |
| 2376 | 226 retval = ">="; |
| 227 break; | |
| 228 | |
| 3533 | 229 case op_gt: |
| 2376 | 230 retval = ">"; |
| 231 break; | |
| 232 | |
| 3533 | 233 case op_ne: |
| 2376 | 234 retval = "!="; |
| 235 break; | |
| 236 | |
| 3533 | 237 case op_el_mul: |
| 2376 | 238 retval = ".*"; |
| 239 break; | |
| 240 | |
| 3533 | 241 case op_el_div: |
| 2376 | 242 retval = "./"; |
| 243 break; | |
| 244 | |
| 3533 | 245 case op_el_pow: |
| 2376 | 246 retval = ".^"; |
| 247 break; | |
| 248 | |
| 3533 | 249 case op_el_ldiv: |
| 2376 | 250 retval = ".\\"; |
| 251 break; | |
| 252 | |
| 3533 | 253 case op_el_and: |
| 2376 | 254 retval = "&"; |
| 255 break; | |
| 256 | |
| 3533 | 257 case op_el_or: |
| 2376 | 258 retval = "|"; |
| 259 break; | |
| 260 | |
| 3533 | 261 case op_struct_ref: |
| 2376 | 262 retval = "."; |
| 263 break; | |
| 264 | |
| 265 default: | |
| 266 retval = "<unknown>"; | |
| 267 } | |
| 268 | |
| 269 return retval; | |
| 270 } | |
| 271 | |
| 3536 | 272 std::string |
| 7336 | 273 octave_value::binary_op_fcn_name (binary_op op) |
| 274 { | |
| 275 std::string retval; | |
| 276 | |
| 277 switch (op) | |
| 278 { | |
| 279 case op_add: | |
| 280 retval = "plus"; | |
| 281 break; | |
| 282 | |
| 283 case op_sub: | |
| 284 retval = "minus"; | |
| 285 break; | |
| 286 | |
| 287 case op_mul: | |
| 288 retval = "mtimes"; | |
| 289 break; | |
| 290 | |
| 291 case op_div: | |
| 292 retval = "mrdivide"; | |
| 293 break; | |
| 294 | |
| 295 case op_pow: | |
| 296 retval = "mpower"; | |
| 297 break; | |
| 298 | |
| 299 case op_ldiv: | |
| 300 retval = "mldivide"; | |
| 301 break; | |
| 302 | |
| 303 case op_lt: | |
| 304 retval = "lt"; | |
| 305 break; | |
| 306 | |
| 307 case op_le: | |
| 308 retval = "le"; | |
| 309 break; | |
| 310 | |
| 311 case op_eq: | |
| 312 retval = "eq"; | |
| 313 break; | |
| 314 | |
| 315 case op_ge: | |
| 316 retval = "ge"; | |
| 317 break; | |
| 318 | |
| 319 case op_gt: | |
| 320 retval = "gt"; | |
| 321 break; | |
| 322 | |
| 323 case op_ne: | |
| 324 retval = "ne"; | |
| 325 break; | |
| 326 | |
| 327 case op_el_mul: | |
| 328 retval = "times"; | |
| 329 break; | |
| 330 | |
| 331 case op_el_div: | |
| 332 retval = "rdivide"; | |
| 333 break; | |
| 334 | |
| 335 case op_el_pow: | |
| 336 retval = "power"; | |
| 337 break; | |
| 338 | |
| 339 case op_el_ldiv: | |
| 340 retval = "ldivide"; | |
| 341 break; | |
| 342 | |
| 343 case op_el_and: | |
| 344 retval = "and"; | |
| 345 break; | |
| 346 | |
| 347 case op_el_or: | |
| 348 retval = "or"; | |
| 349 break; | |
| 350 | |
| 351 default: | |
| 352 break; | |
| 353 } | |
| 354 | |
| 355 return retval; | |
| 356 } | |
| 357 | |
| 358 std::string | |
|
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
|
359 octave_value::binary_op_fcn_name (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
|
360 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
361 std::string retval; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
362 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
363 switch (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
|
364 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
365 case 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
|
366 retval = "transtimes"; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
367 break; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
368 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
369 case 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
|
370 retval = "timestrans"; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
371 break; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
372 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
373 case 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
|
374 retval = "hermtimes"; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
375 break; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
376 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
377 case 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
|
378 retval = "timesherm"; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
379 break; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
380 |
|
9661
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
381 case op_trans_ldiv: |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
382 retval = "transldiv"; |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
383 break; |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
384 |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
385 case op_herm_ldiv: |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
386 retval = "hermldiv"; |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
387 break; |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
388 |
|
8982
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
389 case op_el_and_not: |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
390 retval = "andnot"; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
391 break; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
392 |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
393 case op_el_or_not: |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
394 retval = "ornot"; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
395 break; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
396 |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
397 case op_el_not_and: |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
398 retval = "notand"; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
399 break; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
400 |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
401 case op_el_not_or: |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
402 retval = "notor"; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
403 break; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
404 |
|
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
|
405 default: |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
406 break; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
407 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
408 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
409 return retval; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
410 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
411 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
412 std::string |
| 2880 | 413 octave_value::assign_op_as_string (assign_op op) |
| 414 { | |
| 3523 | 415 std::string retval; |
| 2880 | 416 |
| 417 switch (op) | |
| 418 { | |
| 3533 | 419 case op_asn_eq: |
| 2880 | 420 retval = "="; |
| 421 break; | |
| 422 | |
| 3533 | 423 case op_add_eq: |
| 2880 | 424 retval = "+="; |
| 425 break; | |
| 426 | |
| 3533 | 427 case op_sub_eq: |
| 2880 | 428 retval = "-="; |
| 429 break; | |
| 430 | |
| 3533 | 431 case op_mul_eq: |
| 2880 | 432 retval = "*="; |
| 433 break; | |
| 434 | |
| 3533 | 435 case op_div_eq: |
| 2880 | 436 retval = "/="; |
| 437 break; | |
| 438 | |
| 3533 | 439 case op_ldiv_eq: |
| 3204 | 440 retval = "\\="; |
| 441 break; | |
| 442 | |
| 4018 | 443 case op_pow_eq: |
| 444 retval = "^="; | |
| 445 break; | |
| 446 | |
| 3533 | 447 case op_lshift_eq: |
| 2903 | 448 retval = "<<="; |
| 449 break; | |
| 450 | |
| 3533 | 451 case op_rshift_eq: |
| 2903 | 452 retval = ">>="; |
| 453 break; | |
| 454 | |
| 3533 | 455 case op_el_mul_eq: |
| 2880 | 456 retval = ".*="; |
| 457 break; | |
| 458 | |
| 3533 | 459 case op_el_div_eq: |
| 2880 | 460 retval = "./="; |
| 461 break; | |
| 462 | |
| 3533 | 463 case op_el_ldiv_eq: |
| 3204 | 464 retval = ".\\="; |
| 465 break; | |
| 466 | |
| 4018 | 467 case op_el_pow_eq: |
| 468 retval = ".^="; | |
| 469 break; | |
| 470 | |
| 3533 | 471 case op_el_and_eq: |
| 2880 | 472 retval = "&="; |
| 473 break; | |
| 474 | |
| 3533 | 475 case op_el_or_eq: |
| 2880 | 476 retval = "|="; |
| 477 break; | |
| 478 | |
| 479 default: | |
| 480 retval = "<unknown>"; | |
| 481 } | |
| 482 | |
| 483 return retval; | |
| 484 } | |
| 485 | |
|
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
486 octave_value::assign_op |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
487 octave_value::binary_op_to_assign_op (binary_op op) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
488 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
489 assign_op retval; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
490 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
491 switch (op) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
492 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
493 case op_add: |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
494 retval = op_add_eq; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
495 break; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
496 case op_sub: |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
497 retval = op_sub_eq; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
498 break; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
499 case op_mul: |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
500 retval = op_mul_eq; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
501 break; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
502 case op_div: |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
503 retval = op_div_eq; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
504 break; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
505 case op_el_mul: |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
506 retval = op_el_mul_eq; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
507 break; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
508 case op_el_div: |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
509 retval = op_el_div_eq; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
510 break; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
511 case op_el_and: |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
512 retval = op_el_and_eq; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
513 break; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
514 case op_el_or: |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
515 retval = op_el_or_eq; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
516 break; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
517 default: |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
518 retval = unknown_assign_op; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
519 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
520 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
521 return retval; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
522 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
523 |
| 4254 | 524 octave_value::octave_value (short int i) |
| 525 : rep (new octave_scalar (i)) | |
| 526 { | |
| 527 } | |
| 528 | |
| 529 octave_value::octave_value (unsigned short int i) | |
| 530 : rep (new octave_scalar (i)) | |
| 531 { | |
| 532 } | |
| 533 | |
| 4233 | 534 octave_value::octave_value (int i) |
| 535 : rep (new octave_scalar (i)) | |
| 536 { | |
| 537 } | |
| 538 | |
| 4254 | 539 octave_value::octave_value (unsigned int i) |
| 540 : rep (new octave_scalar (i)) | |
| 541 { | |
| 542 } | |
| 543 | |
| 544 octave_value::octave_value (long int i) | |
| 545 : rep (new octave_scalar (i)) | |
| 546 { | |
| 547 } | |
| 548 | |
| 549 octave_value::octave_value (unsigned long int i) | |
| 550 : rep (new octave_scalar (i)) | |
| 551 { | |
| 552 } | |
| 553 | |
| 4353 | 554 #if defined (HAVE_LONG_LONG_INT) |
| 555 octave_value::octave_value (long long int i) | |
| 556 : rep (new octave_scalar (i)) | |
| 557 { | |
| 558 } | |
| 559 #endif | |
| 560 | |
| 4355 | 561 #if defined (HAVE_UNSIGNED_LONG_LONG_INT) |
| 4353 | 562 octave_value::octave_value (unsigned long long int i) |
| 563 : rep (new octave_scalar (i)) | |
| 564 { | |
| 565 } | |
| 566 #endif | |
| 567 | |
| 4254 | 568 octave_value::octave_value (octave_time t) |
| 7065 | 569 : rep (new octave_scalar (t.double_value ())) |
| 4254 | 570 { |
| 571 } | |
| 572 | |
| 2376 | 573 octave_value::octave_value (double d) |
| 2825 | 574 : rep (new octave_scalar (d)) |
| 575 { | |
| 576 } | |
| 2376 | 577 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
578 octave_value::octave_value (float d) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
579 : rep (new octave_float_scalar (d)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
580 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
581 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
582 |
| 4587 | 583 octave_value::octave_value (const Cell& c, bool is_csl) |
| 5477 | 584 : rep (is_csl |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
585 ? dynamic_cast<octave_base_value *> (new octave_cs_list (c)) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
586 : dynamic_cast<octave_base_value *> (new octave_cell (c))) |
| 3351 | 587 { |
| 588 } | |
| 589 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
590 octave_value::octave_value (const Array<octave_value>& a, bool is_csl) |
| 5477 | 591 : rep (is_csl |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
592 ? dynamic_cast<octave_base_value *> (new octave_cs_list (Cell (a))) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
593 : dynamic_cast<octave_base_value *> (new octave_cell (Cell (a)))) |
| 5147 | 594 { |
| 595 } | |
| 596 | |
| 5785 | 597 octave_value::octave_value (const Matrix& m, const MatrixType& t) |
| 598 : rep (new octave_matrix (m, t)) | |
| 2423 | 599 { |
| 600 maybe_mutate (); | |
| 601 } | |
| 2376 | 602 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
603 octave_value::octave_value (const FloatMatrix& m, const MatrixType& t) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
604 : rep (new octave_float_matrix (m, t)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
605 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
606 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
607 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
608 |
| 4507 | 609 octave_value::octave_value (const NDArray& a) |
| 4513 | 610 : rep (new octave_matrix (a)) |
| 4478 | 611 { |
| 612 maybe_mutate (); | |
| 613 } | |
| 614 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
615 octave_value::octave_value (const FloatNDArray& a) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
616 : rep (new octave_float_matrix (a)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
617 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
618 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
619 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
620 |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
621 octave_value::octave_value (const Array<double>& a) |
| 4911 | 622 : rep (new octave_matrix (a)) |
| 623 { | |
| 624 maybe_mutate (); | |
| 625 } | |
| 626 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
627 octave_value::octave_value (const Array<float>& a) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
628 : rep (new octave_float_matrix (a)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
629 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
630 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
631 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
632 |
| 2376 | 633 octave_value::octave_value (const DiagMatrix& d) |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
634 : rep (new octave_diag_matrix (d)) |
| 2423 | 635 { |
| 636 maybe_mutate (); | |
| 637 } | |
| 2376 | 638 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
639 octave_value::octave_value (const FloatDiagMatrix& d) |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
640 : rep (new octave_float_diag_matrix (d)) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
641 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
642 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
643 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
644 |
| 3418 | 645 octave_value::octave_value (const RowVector& v) |
| 646 : rep (new octave_matrix (v)) | |
| 2423 | 647 { |
| 648 maybe_mutate (); | |
| 649 } | |
| 2376 | 650 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
651 octave_value::octave_value (const FloatRowVector& v) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
652 : rep (new octave_float_matrix (v)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
653 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
654 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
655 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
656 |
| 3418 | 657 octave_value::octave_value (const ColumnVector& v) |
| 658 : rep (new octave_matrix (v)) | |
| 2423 | 659 { |
| 660 maybe_mutate (); | |
| 661 } | |
| 2376 | 662 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
663 octave_value::octave_value (const FloatColumnVector& v) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
664 : rep (new octave_float_matrix (v)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
665 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
666 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
667 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
668 |
| 2376 | 669 octave_value::octave_value (const Complex& C) |
| 2423 | 670 : rep (new octave_complex (C)) |
| 671 { | |
| 672 maybe_mutate (); | |
| 673 } | |
| 2376 | 674 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
675 octave_value::octave_value (const FloatComplex& C) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
676 : rep (new octave_float_complex (C)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
677 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
678 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
679 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
680 |
| 5785 | 681 octave_value::octave_value (const ComplexMatrix& m, const MatrixType& t) |
| 682 : rep (new octave_complex_matrix (m, t)) | |
| 2423 | 683 { |
| 684 maybe_mutate (); | |
| 685 } | |
| 2376 | 686 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
687 octave_value::octave_value (const FloatComplexMatrix& m, const MatrixType& t) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
688 : rep (new octave_float_complex_matrix (m, t)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
689 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
690 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
691 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
692 |
| 4513 | 693 octave_value::octave_value (const ComplexNDArray& a) |
| 694 : rep (new octave_complex_matrix (a)) | |
| 4478 | 695 { |
| 696 maybe_mutate (); | |
| 697 } | |
| 698 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
699 octave_value::octave_value (const FloatComplexNDArray& a) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
700 : rep (new octave_float_complex_matrix (a)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
701 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
702 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
703 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
704 |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
705 octave_value::octave_value (const Array<Complex>& a) |
| 4911 | 706 : rep (new octave_complex_matrix (a)) |
| 707 { | |
| 708 maybe_mutate (); | |
| 709 } | |
| 710 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
711 octave_value::octave_value (const Array<FloatComplex>& a) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
712 : rep (new octave_float_complex_matrix (a)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
713 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
714 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
715 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
716 |
| 2376 | 717 octave_value::octave_value (const ComplexDiagMatrix& d) |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
718 : rep (new octave_complex_diag_matrix (d)) |
| 2423 | 719 { |
| 720 maybe_mutate (); | |
| 721 } | |
| 2376 | 722 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
723 octave_value::octave_value (const FloatComplexDiagMatrix& d) |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
724 : rep (new octave_float_complex_diag_matrix (d)) |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
725 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
726 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
727 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
728 |
| 3418 | 729 octave_value::octave_value (const ComplexRowVector& v) |
| 730 : rep (new octave_complex_matrix (v)) | |
| 2423 | 731 { |
| 732 maybe_mutate (); | |
| 733 } | |
| 2376 | 734 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
735 octave_value::octave_value (const FloatComplexRowVector& v) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
736 : rep (new octave_float_complex_matrix (v)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
737 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
738 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
739 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
740 |
| 3418 | 741 octave_value::octave_value (const ComplexColumnVector& v) |
| 742 : rep (new octave_complex_matrix (v)) | |
| 2423 | 743 { |
| 744 maybe_mutate (); | |
| 745 } | |
| 2376 | 746 |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
747 octave_value::octave_value (const FloatComplexColumnVector& v) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
748 : rep (new octave_float_complex_matrix (v)) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
749 { |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
750 maybe_mutate (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
751 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
752 |
|
8960
93f18f166aba
remove float perm matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
753 octave_value::octave_value (const PermMatrix& p) |
|
93f18f166aba
remove float perm matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
754 : rep (new octave_perm_matrix (p)) |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
755 { |
|
8960
93f18f166aba
remove float perm matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
8920
diff
changeset
|
756 maybe_mutate (); |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
757 } |
|
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
758 |
| 2825 | 759 octave_value::octave_value (bool b) |
| 760 : rep (new octave_bool (b)) | |
| 761 { | |
| 762 } | |
| 763 | |
| 5785 | 764 octave_value::octave_value (const boolMatrix& bm, const MatrixType& t) |
| 765 : rep (new octave_bool_matrix (bm, t)) | |
| 2825 | 766 { |
| 767 maybe_mutate (); | |
| 768 } | |
| 769 | |
| 4513 | 770 octave_value::octave_value (const boolNDArray& bnda) |
| 771 : rep (new octave_bool_matrix (bnda)) | |
| 772 { | |
| 773 maybe_mutate (); | |
| 774 } | |
| 775 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
776 octave_value::octave_value (const Array<bool>& bnda) |
| 7433 | 777 : rep (new octave_bool_matrix (bnda)) |
| 778 { | |
| 779 maybe_mutate (); | |
| 780 } | |
| 781 | |
| 5279 | 782 octave_value::octave_value (char c, char type) |
| 783 : rep (type == '"' | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
784 ? new octave_char_matrix_dq_str (c) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
785 : new octave_char_matrix_sq_str (c)) |
| 3189 | 786 { |
| 787 maybe_mutate (); | |
| 788 } | |
| 789 | |
| 5279 | 790 octave_value::octave_value (const char *s, char type) |
| 791 : rep (type == '"' | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
792 ? new octave_char_matrix_dq_str (s) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
793 : new octave_char_matrix_sq_str (s)) |
| 2423 | 794 { |
| 795 maybe_mutate (); | |
| 796 } | |
| 2376 | 797 |
| 5279 | 798 octave_value::octave_value (const std::string& s, char type) |
| 799 : rep (type == '"' | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
800 ? new octave_char_matrix_dq_str (s) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
801 : new octave_char_matrix_sq_str (s)) |
| 2423 | 802 { |
| 803 maybe_mutate (); | |
| 804 } | |
| 2376 | 805 |
| 5279 | 806 octave_value::octave_value (const string_vector& s, char type) |
| 807 : rep (type == '"' | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
808 ? new octave_char_matrix_dq_str (s) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
809 : new octave_char_matrix_sq_str (s)) |
| 2423 | 810 { |
| 811 maybe_mutate (); | |
| 812 } | |
| 2376 | 813 |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
814 octave_value::octave_value (const charMatrix& chm, char type) |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
815 : rep (type == '"' |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
816 ? new octave_char_matrix_dq_str (chm) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
817 : new octave_char_matrix_sq_str (chm)) |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
818 { |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
819 maybe_mutate (); |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
820 } |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
821 |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
822 octave_value::octave_value (const charNDArray& chm, char type) |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
823 : rep (type == '"' |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
824 ? new octave_char_matrix_dq_str (chm) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
825 : new octave_char_matrix_sq_str (chm)) |
| 2409 | 826 { |
| 4513 | 827 maybe_mutate (); |
| 828 } | |
| 2376 | 829 |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
830 octave_value::octave_value (const Array<char>& chm, char type) |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
831 : rep (type == '"' |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
832 ? new octave_char_matrix_dq_str (chm) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
833 : new octave_char_matrix_sq_str (chm)) |
| 4513 | 834 { |
| 2423 | 835 maybe_mutate (); |
| 2409 | 836 } |
| 2376 | 837 |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
838 octave_value::octave_value (const charMatrix& chm, bool, char type) |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
839 : rep (type == '"' |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
840 ? new octave_char_matrix_dq_str (chm) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
841 : new octave_char_matrix_sq_str (chm)) |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
842 { |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
843 maybe_mutate (); |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
844 } |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
845 |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
846 octave_value::octave_value (const charNDArray& chm, bool, char type) |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
847 : rep (type == '"' |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
848 ? new octave_char_matrix_dq_str (chm) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
849 : new octave_char_matrix_sq_str (chm)) |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
850 { |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
851 maybe_mutate (); |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
852 } |
|
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
853 |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
854 octave_value::octave_value (const Array<char>& chm, bool, char type) |
|
9689
34d6f005db4b
eliminate is_string argument from octave_value character array constructors
John W. Eaton <jwe@octave.org>
parents:
9661
diff
changeset
|
855 : rep (type == '"' |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
856 ? new octave_char_matrix_dq_str (chm) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
857 : new octave_char_matrix_sq_str (chm)) |
| 4997 | 858 { |
| 859 maybe_mutate (); | |
| 860 } | |
| 861 | |
| 5785 | 862 octave_value::octave_value (const SparseMatrix& m, const MatrixType &t) |
| 5164 | 863 : rep (new octave_sparse_matrix (m, t)) |
| 864 { | |
| 865 maybe_mutate (); | |
| 866 } | |
| 867 | |
| 6863 | 868 octave_value::octave_value (const Sparse<double>& m, const MatrixType &t) |
| 869 : rep (new octave_sparse_matrix (m, t)) | |
| 870 { | |
| 871 maybe_mutate (); | |
| 872 } | |
| 873 | |
| 5785 | 874 octave_value::octave_value (const SparseComplexMatrix& m, const MatrixType &t) |
| 5164 | 875 : rep (new octave_sparse_complex_matrix (m, t)) |
| 876 { | |
| 877 maybe_mutate (); | |
| 878 } | |
| 879 | |
| 6863 | 880 octave_value::octave_value (const Sparse<Complex>& m, const MatrixType &t) |
| 881 : rep (new octave_sparse_complex_matrix (m, t)) | |
| 882 { | |
| 883 maybe_mutate (); | |
| 884 } | |
| 885 | |
| 5785 | 886 octave_value::octave_value (const SparseBoolMatrix& bm, const MatrixType &t) |
| 5164 | 887 : rep (new octave_sparse_bool_matrix (bm, t)) |
| 888 { | |
| 889 maybe_mutate (); | |
| 890 } | |
| 891 | |
| 7433 | 892 octave_value::octave_value (const Sparse<bool>& bm, const MatrixType &t) |
| 893 : rep (new octave_sparse_bool_matrix (bm, t)) | |
| 894 { | |
| 895 maybe_mutate (); | |
| 896 } | |
| 897 | |
| 4901 | 898 octave_value::octave_value (const octave_int8& i) |
| 899 : rep (new octave_int8_scalar (i)) | |
| 900 { | |
| 901 maybe_mutate (); | |
| 902 } | |
| 903 | |
| 904 octave_value::octave_value (const octave_uint8& i) | |
| 905 : rep (new octave_uint8_scalar (i)) | |
| 906 { | |
| 907 maybe_mutate (); | |
| 908 } | |
| 909 | |
| 910 octave_value::octave_value (const octave_int16& i) | |
| 911 : rep (new octave_int16_scalar (i)) | |
| 912 { | |
| 913 maybe_mutate (); | |
| 914 } | |
| 915 | |
| 916 octave_value::octave_value (const octave_uint16& i) | |
| 917 : rep (new octave_uint16_scalar (i)) | |
| 918 { | |
| 919 maybe_mutate (); | |
| 920 } | |
| 921 | |
| 922 octave_value::octave_value (const octave_int32& i) | |
| 923 : rep (new octave_int32_scalar (i)) | |
| 924 { | |
| 925 maybe_mutate (); | |
| 926 } | |
| 927 | |
| 928 octave_value::octave_value (const octave_uint32& i) | |
| 929 : rep (new octave_uint32_scalar (i)) | |
| 930 { | |
| 931 maybe_mutate (); | |
| 932 } | |
| 933 | |
| 934 octave_value::octave_value (const octave_int64& i) | |
| 935 : rep (new octave_int64_scalar (i)) | |
| 936 { | |
| 937 maybe_mutate (); | |
| 938 } | |
| 939 | |
| 940 octave_value::octave_value (const octave_uint64& i) | |
| 941 : rep (new octave_uint64_scalar (i)) | |
| 942 { | |
| 943 maybe_mutate (); | |
| 944 } | |
| 945 | |
| 946 octave_value::octave_value (const int8NDArray& inda) | |
| 947 : rep (new octave_int8_matrix (inda)) | |
| 948 { | |
| 949 maybe_mutate (); | |
| 950 } | |
| 951 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
952 octave_value::octave_value (const Array<octave_int8>& inda) |
| 7064 | 953 : rep (new octave_int8_matrix (inda)) |
| 954 { | |
| 955 maybe_mutate (); | |
| 956 } | |
| 957 | |
| 4901 | 958 octave_value::octave_value (const uint8NDArray& inda) |
| 959 : rep (new octave_uint8_matrix (inda)) | |
| 960 { | |
| 961 maybe_mutate (); | |
| 962 } | |
| 963 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
964 octave_value::octave_value (const Array<octave_uint8>& inda) |
| 7064 | 965 : rep (new octave_uint8_matrix (inda)) |
| 966 { | |
| 967 maybe_mutate (); | |
| 968 } | |
| 969 | |
| 4901 | 970 octave_value::octave_value (const int16NDArray& inda) |
| 971 : rep (new octave_int16_matrix (inda)) | |
| 972 { | |
| 973 maybe_mutate (); | |
| 974 } | |
| 975 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
976 octave_value::octave_value (const Array<octave_int16>& inda) |
| 7064 | 977 : rep (new octave_int16_matrix (inda)) |
| 978 { | |
| 979 maybe_mutate (); | |
| 980 } | |
| 981 | |
| 4901 | 982 octave_value::octave_value (const uint16NDArray& inda) |
| 983 : rep (new octave_uint16_matrix (inda)) | |
| 984 { | |
| 985 maybe_mutate (); | |
| 986 } | |
| 987 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
988 octave_value::octave_value (const Array<octave_uint16>& inda) |
| 7064 | 989 : rep (new octave_uint16_matrix (inda)) |
| 990 { | |
| 991 maybe_mutate (); | |
| 992 } | |
| 993 | |
| 4901 | 994 octave_value::octave_value (const int32NDArray& inda) |
| 995 : rep (new octave_int32_matrix (inda)) | |
| 996 { | |
| 997 maybe_mutate (); | |
| 998 } | |
| 999 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
1000 octave_value::octave_value (const Array<octave_int32>& inda) |
| 7064 | 1001 : rep (new octave_int32_matrix (inda)) |
| 1002 { | |
| 1003 maybe_mutate (); | |
| 1004 } | |
| 1005 | |
| 4901 | 1006 octave_value::octave_value (const uint32NDArray& inda) |
| 1007 : rep (new octave_uint32_matrix (inda)) | |
| 1008 { | |
| 1009 maybe_mutate (); | |
| 1010 } | |
| 1011 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
1012 octave_value::octave_value (const Array<octave_uint32>& inda) |
| 7064 | 1013 : rep (new octave_uint32_matrix (inda)) |
| 1014 { | |
| 1015 maybe_mutate (); | |
| 1016 } | |
| 1017 | |
| 4901 | 1018 octave_value::octave_value (const int64NDArray& inda) |
| 1019 : rep (new octave_int64_matrix (inda)) | |
| 1020 { | |
| 1021 maybe_mutate (); | |
| 1022 } | |
| 1023 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
1024 octave_value::octave_value (const Array<octave_int64>& inda) |
| 7064 | 1025 : rep (new octave_int64_matrix (inda)) |
| 1026 { | |
| 1027 maybe_mutate (); | |
| 1028 } | |
| 1029 | |
| 4901 | 1030 octave_value::octave_value (const uint64NDArray& inda) |
| 1031 : rep (new octave_uint64_matrix (inda)) | |
| 1032 { | |
| 1033 maybe_mutate (); | |
| 1034 } | |
| 1035 | |
|
9732
b4fdfee405b5
remove ArrayN<T> + fix nonhom. diag-scalar ops
Jaroslav Hajek <highegg@gmail.com>
parents:
9728
diff
changeset
|
1036 octave_value::octave_value (const Array<octave_uint64>& inda) |
| 7064 | 1037 : rep (new octave_uint64_matrix (inda)) |
| 1038 { | |
| 1039 maybe_mutate (); | |
| 1040 } | |
| 1041 | |
|
9351
e2344f4af0cb
autocache indices returned from find et al.
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
1042 octave_value::octave_value (const Array<octave_idx_type>& inda, bool zero_based, |
|
e2344f4af0cb
autocache indices returned from find et al.
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
1043 bool cache_index) |
|
e2344f4af0cb
autocache indices returned from find et al.
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
1044 : rep (new octave_matrix (inda, zero_based, cache_index)) |
|
e2344f4af0cb
autocache indices returned from find et al.
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
1045 { |
|
e2344f4af0cb
autocache indices returned from find et al.
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
1046 maybe_mutate (); |
|
e2344f4af0cb
autocache indices returned from find et al.
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
1047 } |
|
e2344f4af0cb
autocache indices returned from find et al.
Jaroslav Hajek <highegg@gmail.com>
parents:
9329
diff
changeset
|
1048 |
|
10325
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1049 octave_value::octave_value (const idx_vector& idx, bool lazy) |
|
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1050 : rep () |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1051 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1052 double scalar; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1053 Range range; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1054 NDArray array; |
|
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1055 boolNDArray mask; |
|
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1056 idx_vector::idx_class_type idx_class; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1057 |
|
10325
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1058 if (lazy) |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1059 { |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1060 // Only make lazy indices out of ranges and index vectors. |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1061 switch (idx.idx_class ()) |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1062 { |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1063 case idx_vector::class_range: |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1064 case idx_vector::class_vector: |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1065 rep = new octave_lazy_index (idx); |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1066 maybe_mutate (); |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1067 return; |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1068 default: |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1069 break; |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1070 } |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1071 } |
|
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1072 |
|
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1073 idx.unconvert (idx_class, scalar, range, array, mask); |
|
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1074 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1075 switch (idx_class) |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1076 { |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1077 case idx_vector::class_colon: |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1078 rep = new octave_magic_colon (); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1079 break; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1080 case idx_vector::class_range: |
|
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1081 rep = new octave_range (range, idx); |
|
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1082 break; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1083 case idx_vector::class_scalar: |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1084 rep = new octave_scalar (scalar); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1085 break; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1086 case idx_vector::class_vector: |
|
9894
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1087 rep = new octave_matrix (array, idx); |
|
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1088 break; |
|
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1089 case idx_vector::class_mask: |
|
83bd7f34f9da
improve idx_vector->octave_value conversion
Jaroslav Hajek <highegg@gmail.com>
parents:
9879
diff
changeset
|
1090 rep = new octave_bool_matrix (mask, idx); |
|
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1091 break; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1092 default: |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1093 assert (false); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1094 break; |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1095 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1096 |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1097 // FIXME: needed? |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1098 maybe_mutate (); |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1099 } |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1100 |
| 9725 | 1101 octave_value::octave_value (const Array<std::string>& cellstr) |
| 1102 : rep (new octave_cell (cellstr)) | |
| 1103 { | |
| 1104 maybe_mutate (); | |
| 1105 } | |
| 1106 | |
| 2376 | 1107 octave_value::octave_value (double base, double limit, double inc) |
| 2423 | 1108 : rep (new octave_range (base, limit, inc)) |
| 1109 { | |
| 1110 maybe_mutate (); | |
| 1111 } | |
| 2376 | 1112 |
| 1113 octave_value::octave_value (const Range& r) | |
| 2423 | 1114 : rep (new octave_range (r)) |
| 1115 { | |
| 1116 maybe_mutate (); | |
| 1117 } | |
| 2376 | 1118 |
| 1119 octave_value::octave_value (const Octave_map& m) | |
| 2825 | 1120 : rep (new octave_struct (m)) |
| 1121 { | |
| 2880 | 1122 } |
| 1123 | |
| 7336 | 1124 octave_value::octave_value (const Octave_map& m, const std::string& id) |
| 1125 : rep (new octave_class (m, id)) | |
| 1126 { | |
| 1127 } | |
| 1128 | |
|
10232
0efd486813fe
remove deprecated list datatype
Jaroslav Hajek <highegg@gmail.com>
parents:
10160
diff
changeset
|
1129 octave_value::octave_value (const octave_value_list& l, bool) |
|
0efd486813fe
remove deprecated list datatype
Jaroslav Hajek <highegg@gmail.com>
parents:
10160
diff
changeset
|
1130 : rep (new octave_cs_list (l)) |
| 2880 | 1131 { |
| 1132 } | |
| 2376 | 1133 |
| 1134 octave_value::octave_value (octave_value::magic_colon) | |
| 2825 | 1135 : rep (new octave_magic_colon ()) |
| 1136 { | |
| 1137 } | |
| 2376 | 1138 |
|
9728
70925b11ba46
again allow the obsolete syntax for cellfun
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
1139 octave_value::octave_value (octave_base_value *new_rep, bool borrow) |
| 2825 | 1140 : rep (new_rep) |
| 1141 { | |
|
9728
70925b11ba46
again allow the obsolete syntax for cellfun
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
1142 if (borrow) |
|
70925b11ba46
again allow the obsolete syntax for cellfun
Jaroslav Hajek <highegg@gmail.com>
parents:
9725
diff
changeset
|
1143 rep->count++; |
| 2825 | 1144 } |
| 2376 | 1145 |
| 7336 | 1146 octave_value::octave_value (octave_base_value *new_rep, int xcount) |
| 1147 : rep (new_rep) | |
| 1148 { | |
| 1149 rep->count = xcount; | |
| 1150 } | |
| 1151 | |
| 5759 | 1152 octave_base_value * |
| 3933 | 1153 octave_value::clone (void) const |
| 2880 | 1154 { |
|
10325
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
1155 return rep->clone (); |
| 2880 | 1156 } |
| 1157 | |
| 2409 | 1158 void |
| 1159 octave_value::maybe_mutate (void) | |
| 1160 { | |
| 5759 | 1161 octave_base_value *tmp = rep->try_narrowing_conversion (); |
| 2409 | 1162 |
| 1163 if (tmp && tmp != rep) | |
| 1164 { | |
| 1165 if (--rep->count == 0) | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1166 delete rep; |
| 2409 | 1167 |
| 1168 rep = tmp; | |
| 1169 } | |
| 1170 } | |
| 1171 | |
| 4247 | 1172 octave_value |
| 4271 | 1173 octave_value::single_subsref (const std::string& type, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1174 const octave_value_list& idx) |
| 4247 | 1175 { |
| 1176 std::list<octave_value_list> i; | |
| 1177 | |
| 1178 i.push_back (idx); | |
| 1179 | |
| 1180 return rep->subsref (type, i); | |
| 1181 } | |
| 1182 | |
| 2974 | 1183 octave_value_list |
| 4247 | 1184 octave_value::subsref (const std::string& type, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1185 const std::list<octave_value_list>& idx, int nargout) |
| 3933 | 1186 { |
|
7651
443a8f5a50fd
require both subsref variants to be defined in octave_value subclasses
John W. Eaton <jwe@octave.org>
parents:
7503
diff
changeset
|
1187 if (nargout == 1) |
| 3933 | 1188 return rep->subsref (type, idx); |
| 1189 else | |
| 1190 return rep->subsref (type, idx, nargout); | |
| 1191 } | |
| 1192 | |
| 1193 octave_value | |
| 4247 | 1194 octave_value::next_subsref (const std::string& type, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1195 const std::list<octave_value_list>& idx, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1196 size_t skip) |
| 3933 | 1197 { |
| 4582 | 1198 if (! error_state && idx.size () > skip) |
| 3933 | 1199 { |
| 4219 | 1200 std::list<octave_value_list> new_idx (idx); |
| 4233 | 1201 for (size_t i = 0; i < skip; i++) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1202 new_idx.erase (new_idx.begin ()); |
| 3933 | 1203 return subsref (type.substr (skip), new_idx); |
| 1204 } | |
| 1205 else | |
| 1206 return *this; | |
| 1207 } | |
| 1208 | |
| 1209 octave_value_list | |
| 4994 | 1210 octave_value::next_subsref (int nargout, const std::string& type, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1211 const std::list<octave_value_list>& idx, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1212 size_t skip) |
| 4994 | 1213 { |
| 1214 if (! error_state && idx.size () > skip) | |
| 1215 { | |
| 1216 std::list<octave_value_list> new_idx (idx); | |
| 1217 for (size_t i = 0; i < skip; i++) | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1218 new_idx.erase (new_idx.begin ()); |
| 4994 | 1219 return subsref (type.substr (skip), new_idx, nargout); |
| 1220 } | |
| 1221 else | |
| 1222 return *this; | |
| 1223 } | |
| 1224 | |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1225 octave_value |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1226 octave_value::next_subsref (bool auto_add, const std::string& type, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1227 const std::list<octave_value_list>& idx, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1228 size_t skip) |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1229 { |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1230 if (! error_state && idx.size () > skip) |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1231 { |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1232 std::list<octave_value_list> new_idx (idx); |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1233 for (size_t i = 0; i < skip; i++) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1234 new_idx.erase (new_idx.begin ()); |
|
8551
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1235 return subsref (type.substr (skip), new_idx, auto_add); |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1236 } |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1237 else |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1238 return *this; |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1239 } |
|
906f976d35a8
further improve struct&cell indexing & indexed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
8531
diff
changeset
|
1240 |
| 4994 | 1241 octave_value_list |
| 3544 | 1242 octave_value::do_multi_index_op (int nargout, const octave_value_list& idx) |
| 2974 | 1243 { |
| 3544 | 1244 return rep->do_multi_index_op (nargout, idx); |
| 2974 | 1245 } |
| 1246 | |
| 3933 | 1247 #if 0 |
| 3204 | 1248 static void |
| 3933 | 1249 gripe_assign_failed (const std::string& on, const std::string& tn1, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1250 const std::string& tn2) |
| 3204 | 1251 { |
| 1252 error ("assignment failed for `%s %s %s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1253 tn1.c_str (), on.c_str (), tn2.c_str ()); |
| 3204 | 1254 } |
| 3933 | 1255 #endif |
| 3204 | 1256 |
| 1257 static void | |
| 3933 | 1258 gripe_assign_failed_or_no_method (const std::string& on, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1259 const std::string& tn1, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1260 const std::string& tn2) |
| 3204 | 1261 { |
| 1262 error ("assignment failed, or no method for `%s %s %s'", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1263 tn1.c_str (), on.c_str (), tn2.c_str ()); |
| 3204 | 1264 } |
| 1265 | |
| 3933 | 1266 octave_value |
| 4247 | 1267 octave_value::subsasgn (const std::string& type, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1268 const std::list<octave_value_list>& idx, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1269 const octave_value& rhs) |
| 3933 | 1270 { |
| 1271 return rep->subsasgn (type, idx, rhs); | |
| 1272 } | |
| 1273 | |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1274 octave_value& |
| 4247 | 1275 octave_value::assign (assign_op op, const std::string& type, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1276 const std::list<octave_value_list>& idx, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1277 const octave_value& rhs) |
| 3933 | 1278 { |
| 1279 octave_value retval; | |
| 1280 | |
| 1281 make_unique (); | |
| 1282 | |
| 1283 octave_value t_rhs = rhs; | |
| 1284 | |
| 1285 if (op != op_asn_eq) | |
| 1286 { | |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1287 if (is_defined ()) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1288 { |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1289 octave_value t = subsref (type, idx); |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1290 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1291 if (! error_state) |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1292 { |
|
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1293 binary_op binop = op_eq_to_binary_op (op); |
|
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1294 |
|
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1295 if (! error_state) |
|
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1296 t_rhs = do_binary_op (binop, t, rhs); |
|
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1297 } |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1298 } |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1299 else |
|
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1300 error ("in computed assignment A(index) OP= X, A must be defined first"); |
| 3933 | 1301 } |
| 1302 | |
| 1303 if (! error_state) | |
| 1304 { | |
| 7336 | 1305 if (type[0] == '.' && ! (is_map () || is_object ())) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1306 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1307 octave_value tmp = Octave_map (); |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1308 *this = tmp.subsasgn (type, idx, t_rhs); |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1309 } |
| 3933 | 1310 else |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1311 *this = subsasgn (type, idx, t_rhs); |
|
9693
1c19877799d3
improve error reports for computed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9690
diff
changeset
|
1312 |
|
1c19877799d3
improve error reports for computed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9690
diff
changeset
|
1313 if (error_state) |
|
1c19877799d3
improve error reports for computed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9690
diff
changeset
|
1314 gripe_assign_failed_or_no_method (assign_op_as_string (op_asn_eq), |
|
1c19877799d3
improve error reports for computed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9690
diff
changeset
|
1315 type_name (), rhs.type_name ()); |
| 3933 | 1316 } |
| 1317 | |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1318 return *this; |
| 3933 | 1319 } |
| 1320 | |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1321 octave_value& |
| 3203 | 1322 octave_value::assign (assign_op op, const octave_value& rhs) |
| 2880 | 1323 { |
| 3533 | 1324 if (op == op_asn_eq) |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1325 // Regularize a null matrix if stored into a variable. |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1326 operator = (rhs.storable_value ()); |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1327 else if (is_defined ()) |
| 3203 | 1328 { |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1329 octave_value_typeinfo::assign_op_fcn f = 0; |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1330 |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1331 // Only attempt to operate in-place if this variable is unshared. |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1332 if (rep->count == 1) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1333 { |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1334 int tthis = this->type_id (); |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1335 int trhs = rhs.type_id (); |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1336 |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1337 f = octave_value_typeinfo::lookup_assign_op (op, tthis, trhs); |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1338 } |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1339 |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1340 if (f) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1341 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1342 try |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1343 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1344 f (*rep, octave_value_list (), *rhs.rep); |
|
9608
1c76e806c2a7
possibly mutate after in-place computed assignment
Jaroslav Hajek <highegg@gmail.com>
parents:
9607
diff
changeset
|
1345 maybe_mutate (); // Usually unnecessary, but may be needed (complex arrays). |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1346 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1347 catch (octave_execution_exception) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1348 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1349 gripe_library_execution_error (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1350 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1351 } |
|
9546
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1352 else |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1353 { |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1354 |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1355 binary_op binop = op_eq_to_binary_op (op); |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1356 |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1357 if (! error_state) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1358 { |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1359 octave_value t = do_binary_op (binop, *this, rhs); |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1360 |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1361 if (! error_state) |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1362 operator = (t); |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1363 } |
|
1beb23d2b892
optimize op= in common cases
Jaroslav Hajek <highegg@gmail.com>
parents:
9479
diff
changeset
|
1364 } |
| 3204 | 1365 } |
|
10544
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1366 else |
|
9961fc022d9d
fix assignment to non-existing variables and octave_value::assign
Jaroslav Hajek <highegg@gmail.com>
parents:
10521
diff
changeset
|
1367 error ("in computed assignment A OP= X, A must be defined first"); |
| 3204 | 1368 |
| 3933 | 1369 return *this; |
| 2376 | 1370 } |
| 1371 | |
| 5275 | 1372 octave_idx_type |
| 4563 | 1373 octave_value::length (void) const |
| 1374 { | |
| 1375 int retval = 0; | |
| 1376 | |
| 1377 dim_vector dv = dims (); | |
| 4584 | 1378 |
| 4563 | 1379 for (int i = 0; i < dv.length (); i++) |
| 1380 { | |
| 1381 if (dv(i) < 0) | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1382 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1383 retval = -1; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1384 break; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1385 } |
| 4563 | 1386 |
| 4584 | 1387 if (dv(i) == 0) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1388 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1389 retval = 0; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1390 break; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1391 } |
| 4584 | 1392 |
| 4563 | 1393 if (dv(i) > retval) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1394 retval = dv(i); |
| 4563 | 1395 } |
| 1396 | |
| 1397 return retval; | |
| 1398 } | |
| 1399 | |
|
8346
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1400 bool |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1401 octave_value::is_equal (const octave_value& test) const |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1402 { |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1403 bool retval = false; |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1404 |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1405 // If there is no op_eq for these types, we can't compare values. |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1406 |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1407 if (rows () == test.rows () && columns () == test.columns ()) |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1408 { |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1409 octave_value tmp = do_binary_op (octave_value::op_eq, *this, test); |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1410 |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1411 // Empty array also means a match. |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1412 if (! error_state && tmp.is_defined ()) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1413 retval = tmp.is_true () || tmp.is_empty (); |
|
8346
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1414 } |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1415 |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1416 return retval; |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1417 } |
|
8302788f09db
fix empty matrix handling in switch statement
Jaroslav Hajek <highegg@gmail.com>
parents:
8345
diff
changeset
|
1418 |
| 3351 | 1419 Cell |
| 1420 octave_value::cell_value (void) const | |
| 1421 { | |
| 1422 return rep->cell_value (); | |
| 1423 } | |
| 1424 | |
|
8017
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1425 // Define the idx_type_value function here instead of in ov.h to avoid |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1426 // needing definitions for the SIZEOF_X macros in ov.h. |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1427 |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1428 octave_idx_type |
|
8024
dc36eb214129
ov.cc (octave_value::idx_type_value): don't include default argument value in definition
John W. Eaton <jwe@octave.org>
parents:
8017
diff
changeset
|
1429 octave_value::idx_type_value (bool req_int, bool frc_str_conv) const |
|
8017
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1430 { |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1431 #if SIZEOF_OCTAVE_IDX_TYPE == SIZEOF_LONG |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1432 return long_value (req_int, frc_str_conv); |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1433 #elif SIZEOF_OCTAVE_IDX_TYPE == SIZEOF_INT |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1434 return int_value (req_int, frc_str_conv); |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1435 #else |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1436 #error "no octave_value extractor for octave_idx_type" |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1437 #endif |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1438 } |
|
260294a5520f
octave_value::idx_type_value: move definition to ov.cc from ov.h
John W. Eaton <jwe@octave.org>
parents:
8011
diff
changeset
|
1439 |
| 2376 | 1440 Octave_map |
| 1441 octave_value::map_value (void) const | |
| 1442 { | |
| 1443 return rep->map_value (); | |
| 1444 } | |
| 1445 | |
| 2974 | 1446 octave_function * |
|
7761
5adeea5de26c
symbol table reporting functions
John W. Eaton <jwe@octave.org>
parents:
7719
diff
changeset
|
1447 octave_value::function_value (bool silent) const |
|
5adeea5de26c
symbol table reporting functions
John W. Eaton <jwe@octave.org>
parents:
7719
diff
changeset
|
1448 { |
|
5adeea5de26c
symbol table reporting functions
John W. Eaton <jwe@octave.org>
parents:
7719
diff
changeset
|
1449 return rep->function_value (silent); |
|
5adeea5de26c
symbol table reporting functions
John W. Eaton <jwe@octave.org>
parents:
7719
diff
changeset
|
1450 } |
|
5adeea5de26c
symbol table reporting functions
John W. Eaton <jwe@octave.org>
parents:
7719
diff
changeset
|
1451 |
| 4700 | 1452 octave_user_function * |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10033
diff
changeset
|
1453 octave_value::user_function_value (bool silent) const |
| 4700 | 1454 { |
| 1455 return rep->user_function_value (silent); | |
| 1456 } | |
| 1457 | |
|
7719
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1458 octave_user_script * |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10033
diff
changeset
|
1459 octave_value::user_script_value (bool silent) const |
|
7719
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1460 { |
|
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1461 return rep->user_script_value (silent); |
|
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1462 } |
|
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1463 |
|
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1464 octave_user_code * |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10033
diff
changeset
|
1465 octave_value::user_code_value (bool silent) const |
|
7719
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1466 { |
|
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1467 return rep->user_code_value (silent); |
|
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1468 } |
|
87eda1f8faaa
octave_user_code: new base class for octave_user_script and octave_user_function
John W. Eaton <jwe@octave.org>
parents:
7651
diff
changeset
|
1469 |
| 4346 | 1470 octave_fcn_handle * |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10033
diff
changeset
|
1471 octave_value::fcn_handle_value (bool silent) const |
| 4343 | 1472 { |
| 1473 return rep->fcn_handle_value (silent); | |
| 1474 } | |
| 1475 | |
| 4933 | 1476 octave_fcn_inline * |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10033
diff
changeset
|
1477 octave_value::fcn_inline_value (bool silent) const |
| 4933 | 1478 { |
| 1479 return rep->fcn_inline_value (silent); | |
| 1480 } | |
| 1481 | |
| 2880 | 1482 octave_value_list |
| 1483 octave_value::list_value (void) const | |
| 1484 { | |
| 1485 return rep->list_value (); | |
| 1486 } | |
| 1487 | |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1488 static dim_vector |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1489 make_vector_dims (const dim_vector& dv, bool force_vector_conversion, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1490 const std::string& my_type, const std::string& wanted_type) |
| 3419 | 1491 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1492 dim_vector retval (dv); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1493 retval.chop_trailing_singletons (); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1494 octave_idx_type nel = dv.numel (); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1495 |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1496 if (retval.length () > 2 || (retval(0) != 1 && retval(1) != 1)) |
| 3419 | 1497 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1498 if (!force_vector_conversion) |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1499 gripe_implicit_conversion ("Octave:array-as-vector", |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1500 my_type.c_str (), wanted_type.c_str ()); |
|
10350
12884915a8e4
merge MArray classes & improve Array interface
Jaroslav Hajek <highegg@gmail.com>
parents:
10325
diff
changeset
|
1501 retval = dim_vector (nel, 1); |
| 3419 | 1502 } |
| 1503 | |
| 1504 return retval; | |
| 1505 } | |
| 1506 | |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1507 ColumnVector |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1508 octave_value::column_vector_value (bool force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1509 bool frc_vec_conv) const |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1510 { |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1511 return ColumnVector (vector_value (force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1512 frc_vec_conv)); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1513 } |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1514 |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1515 ComplexColumnVector |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1516 octave_value::complex_column_vector_value (bool force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1517 bool frc_vec_conv) const |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1518 { |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1519 return ComplexColumnVector (complex_vector_value (force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1520 frc_vec_conv)); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1521 } |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1522 |
| 3419 | 1523 RowVector |
| 1524 octave_value::row_vector_value (bool force_string_conv, | |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1525 bool frc_vec_conv) const |
| 3419 | 1526 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1527 return RowVector (vector_value (force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1528 frc_vec_conv)); |
| 3419 | 1529 } |
| 1530 | |
| 1531 ComplexRowVector | |
| 1532 octave_value::complex_row_vector_value (bool force_string_conv, | |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1533 bool frc_vec_conv) const |
| 3419 | 1534 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1535 return ComplexRowVector (complex_vector_value (force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1536 frc_vec_conv)); |
| 3419 | 1537 } |
| 1538 | |
| 1539 Array<double> | |
| 2376 | 1540 octave_value::vector_value (bool force_string_conv, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1541 bool force_vector_conversion) const |
| 2376 | 1542 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1543 Array<double> retval = array_value (force_string_conv); |
| 2376 | 1544 |
| 1545 if (error_state) | |
| 1546 return retval; | |
| 1547 else | |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1548 return retval.reshape (make_vector_dims (retval.dims (), |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1549 force_vector_conversion, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1550 type_name (), "real vector")); |
| 2376 | 1551 } |
| 1552 | |
|
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1553 template <class T> |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1554 static Array<int> |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1555 convert_to_int_array (const Array<octave_int<T> >& A) |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1556 { |
| 7999 | 1557 Array<int> retval (A.dims ()); |
|
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1558 octave_idx_type n = A.numel (); |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1559 |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1560 for (octave_idx_type i = 0; i < n; i++) |
| 7999 | 1561 retval.xelem (i) = octave_int<int> (A.xelem (i)); |
|
8039
cd90e2842080
Add additional integer math and conversion warnings, set their default state to be off and add the intwarning function
David Bateman <dbateman@free.fr>
parents:
8024
diff
changeset
|
1562 |
| 7999 | 1563 return retval; |
|
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1564 } |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1565 |
| 4044 | 1566 Array<int> |
| 1567 octave_value::int_vector_value (bool force_string_conv, bool require_int, | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1568 bool force_vector_conversion) const |
| 4044 | 1569 { |
| 1570 Array<int> retval; | |
| 1571 | |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1572 if (is_integer_type ()) |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1573 { |
|
7997
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1574 if (is_int32_type ()) |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1575 retval = convert_to_int_array (int32_array_value ()); |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1576 else if (is_int64_type ()) |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1577 retval = convert_to_int_array (int64_array_value ()); |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1578 else if (is_int16_type ()) |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1579 retval = convert_to_int_array (int16_array_value ()); |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1580 else if (is_int8_type ()) |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1581 retval = convert_to_int_array (int8_array_value ()); |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1582 else if (is_uint32_type ()) |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1583 retval = convert_to_int_array (uint32_array_value ()); |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1584 else if (is_uint64_type ()) |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1585 retval = convert_to_int_array (uint64_array_value ()); |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1586 else if (is_uint16_type ()) |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1587 retval = convert_to_int_array (uint16_array_value ()); |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1588 else if (is_uint8_type ()) |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1589 retval = convert_to_int_array (uint8_array_value ()); |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1590 else |
|
2b8952e133c9
implement checked conversions between integers
Jaroslav Hajek <highegg@gmail.com>
parents:
7892
diff
changeset
|
1591 retval = array_value (force_string_conv); |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1592 } |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1593 else |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1594 { |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1595 const NDArray a = array_value (force_string_conv); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1596 if (! error_state) |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1597 { |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1598 if (require_int) |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1599 { |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1600 retval.resize (a.dims ()); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1601 for (octave_idx_type i = 0; i < a.numel (); i++) |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1602 { |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1603 double ai = a.elem (i); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1604 int v = static_cast<int> (ai); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1605 if (ai == v) |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1606 retval.xelem (i) = v; |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1607 else |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1608 { |
|
9753
892e2aa7bc75
improve error messages by auto-prepending current function name
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
1609 error_with_cfn ("conversion to integer value failed"); |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1610 break; |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1611 } |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1612 } |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1613 } |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1614 else |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1615 retval = Array<int> (a); |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1616 } |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1617 } |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1618 |
| 4044 | 1619 |
| 1620 if (error_state) | |
| 1621 return retval; | |
| 1622 else | |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1623 return retval.reshape (make_vector_dims (retval.dims (), |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1624 force_vector_conversion, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1625 type_name (), "integer vector")); |
| 4044 | 1626 } |
| 1627 | |
| 8811 | 1628 template <class T> |
| 1629 static Array<octave_idx_type> | |
| 1630 convert_to_octave_idx_type_array (const Array<octave_int<T> >& A) | |
| 1631 { | |
| 1632 Array<octave_idx_type> retval (A.dims ()); | |
| 1633 octave_idx_type n = A.numel (); | |
| 1634 | |
| 1635 for (octave_idx_type i = 0; i < n; i++) | |
| 1636 retval.xelem (i) = octave_int<octave_idx_type> (A.xelem (i)); | |
| 1637 | |
| 1638 return retval; | |
| 1639 } | |
| 1640 | |
| 1641 Array<octave_idx_type> | |
|
9479
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1642 octave_value::octave_idx_type_vector_value (bool require_int, |
|
d9716e3ee0dd
supply optimized compiled sub2ind & ind2sub
Jaroslav Hajek <highegg@gmail.com>
parents:
9368
diff
changeset
|
1643 bool force_string_conv, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1644 bool force_vector_conversion) const |
| 8811 | 1645 { |
| 1646 Array<octave_idx_type> retval; | |
| 1647 | |
| 1648 if (is_integer_type ()) | |
| 1649 { | |
| 1650 if (is_int32_type ()) | |
| 1651 retval = convert_to_octave_idx_type_array (int32_array_value ()); | |
| 1652 else if (is_int64_type ()) | |
| 1653 retval = convert_to_octave_idx_type_array (int64_array_value ()); | |
| 1654 else if (is_int16_type ()) | |
| 1655 retval = convert_to_octave_idx_type_array (int16_array_value ()); | |
| 1656 else if (is_int8_type ()) | |
| 1657 retval = convert_to_octave_idx_type_array (int8_array_value ()); | |
| 1658 else if (is_uint32_type ()) | |
| 1659 retval = convert_to_octave_idx_type_array (uint32_array_value ()); | |
| 1660 else if (is_uint64_type ()) | |
| 1661 retval = convert_to_octave_idx_type_array (uint64_array_value ()); | |
| 1662 else if (is_uint16_type ()) | |
| 1663 retval = convert_to_octave_idx_type_array (uint16_array_value ()); | |
| 1664 else if (is_uint8_type ()) | |
| 1665 retval = convert_to_octave_idx_type_array (uint8_array_value ()); | |
| 1666 else | |
| 1667 retval = array_value (force_string_conv); | |
| 1668 } | |
| 1669 else | |
| 1670 { | |
| 1671 const NDArray a = array_value (force_string_conv); | |
| 1672 if (! error_state) | |
| 1673 { | |
| 1674 if (require_int) | |
| 1675 { | |
| 1676 retval.resize (a.dims ()); | |
| 1677 for (octave_idx_type i = 0; i < a.numel (); i++) | |
| 1678 { | |
| 1679 double ai = a.elem (i); | |
| 1680 octave_idx_type v = static_cast<octave_idx_type> (ai); | |
| 1681 if (ai == v) | |
| 1682 retval.xelem (i) = v; | |
| 1683 else | |
| 1684 { | |
|
9753
892e2aa7bc75
improve error messages by auto-prepending current function name
Jaroslav Hajek <highegg@gmail.com>
parents:
9732
diff
changeset
|
1685 error_with_cfn ("conversion to integer value failed"); |
| 8811 | 1686 break; |
| 1687 } | |
| 1688 } | |
| 1689 } | |
| 1690 else | |
| 1691 retval = Array<octave_idx_type> (a); | |
| 1692 } | |
| 1693 } | |
| 1694 | |
| 1695 | |
| 1696 if (error_state) | |
| 1697 return retval; | |
| 1698 else | |
| 1699 return retval.reshape (make_vector_dims (retval.dims (), | |
| 1700 force_vector_conversion, | |
| 1701 type_name (), "integer vector")); | |
| 1702 } | |
| 1703 | |
| 3419 | 1704 Array<Complex> |
| 2376 | 1705 octave_value::complex_vector_value (bool force_string_conv, |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1706 bool force_vector_conversion) const |
| 2376 | 1707 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1708 Array<Complex> retval = complex_array_value (force_string_conv); |
| 2376 | 1709 |
| 1710 if (error_state) | |
| 1711 return retval; | |
| 1712 else | |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1713 return retval.reshape (make_vector_dims (retval.dims (), |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1714 force_vector_conversion, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1715 type_name (), "complex vector")); |
| 2376 | 1716 } |
| 1717 | |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1718 FloatColumnVector |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1719 octave_value::float_column_vector_value (bool force_string_conv, |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1720 bool frc_vec_conv) const |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1721 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1722 return FloatColumnVector (float_vector_value (force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1723 frc_vec_conv)); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1724 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1725 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1726 FloatComplexColumnVector |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1727 octave_value::float_complex_column_vector_value (bool force_string_conv, |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1728 bool frc_vec_conv) const |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1729 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1730 return FloatComplexColumnVector (float_complex_vector_value (force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1731 frc_vec_conv)); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1732 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1733 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1734 FloatRowVector |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1735 octave_value::float_row_vector_value (bool force_string_conv, |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1736 bool frc_vec_conv) const |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1737 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1738 return FloatRowVector (float_vector_value (force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1739 frc_vec_conv)); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1740 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1741 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1742 FloatComplexRowVector |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1743 octave_value::float_complex_row_vector_value (bool force_string_conv, |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1744 bool frc_vec_conv) const |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1745 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1746 return FloatComplexRowVector (float_complex_vector_value (force_string_conv, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1747 frc_vec_conv)); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1748 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1749 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1750 Array<float> |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1751 octave_value::float_vector_value (bool force_string_conv, |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1752 bool force_vector_conversion) const |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1753 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1754 Array<float> retval = float_array_value (force_string_conv); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1755 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1756 if (error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1757 return retval; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1758 else |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1759 return retval.reshape (make_vector_dims (retval.dims (), |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1760 force_vector_conversion, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1761 type_name (), "real vector")); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1762 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1763 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1764 Array<FloatComplex> |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1765 octave_value::float_complex_vector_value (bool force_string_conv, |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1766 bool force_vector_conversion) const |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1767 { |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1768 Array<FloatComplex> retval = float_complex_array_value (force_string_conv); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1769 |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1770 if (error_state) |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1771 return retval; |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1772 else |
|
7892
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1773 return retval.reshape (make_vector_dims (retval.dims (), |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1774 force_vector_conversion, |
|
7ca2735d74c2
simplify & cleanup octave_value::XXX_vector_value functions
Jaroslav Hajek <highegg@gmail.com>
parents:
7885
diff
changeset
|
1775 type_name (), "complex vector")); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1776 } |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
1777 |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1778 octave_value |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1779 octave_value::storable_value (void) const |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1780 { |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1781 octave_value retval = *this; |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1782 if (is_null_value ()) |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1783 retval = octave_value (rep->empty_clone ()); |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1784 else |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1785 retval.maybe_economize (); |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1786 |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1787 return retval; |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1788 } |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1789 |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1790 void |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1791 octave_value::make_storable_value (void) |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1792 { |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1793 if (is_null_value ()) |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1794 { |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1795 octave_base_value *rc = rep->empty_clone (); |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1796 if (--rep->count == 0) |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1797 delete rep; |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1798 rep = rc; |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1799 } |
|
8523
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1800 else |
|
ad3afaaa19c1
implement non-copying contiguous range indexing
Jaroslav Hajek <highegg@gmail.com>
parents:
8367
diff
changeset
|
1801 maybe_economize (); |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1802 } |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
1803 |
| 4944 | 1804 int |
| 1805 octave_value::write (octave_stream& os, int block_size, | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1806 oct_data_conv::data_type output_type, int skip, |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1807 oct_mach_info::float_format flt_fmt) const |
| 4944 | 1808 { |
| 1809 return rep->write (os, block_size, output_type, skip, flt_fmt); | |
| 1810 } | |
| 1811 | |
| 2413 | 1812 static void |
| 3933 | 1813 gripe_binary_op (const std::string& on, const std::string& tn1, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1814 const std::string& tn2) |
| 2376 | 1815 { |
| 2903 | 1816 error ("binary operator `%s' not implemented for `%s' by `%s' operations", |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1817 on.c_str (), tn1.c_str (), tn2.c_str ()); |
| 2376 | 1818 } |
| 1819 | |
| 3203 | 1820 static void |
| 3523 | 1821 gripe_binary_op_conv (const std::string& on) |
| 3203 | 1822 { |
| 1823 error ("type conversion failed for binary operator `%s'", on.c_str ()); | |
| 1824 } | |
| 1825 | |
| 2376 | 1826 octave_value |
| 3933 | 1827 do_binary_op (octave_value::binary_op op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1828 const octave_value& v1, const octave_value& v2) |
| 2376 | 1829 { |
| 1830 octave_value retval; | |
| 1831 | |
| 1832 int t1 = v1.type_id (); | |
| 1833 int t2 = v2.type_id (); | |
| 1834 | |
| 7336 | 1835 if (t1 == octave_class::static_type_id () |
| 1836 || t2 == octave_class::static_type_id ()) | |
| 1837 { | |
| 1838 octave_value_typeinfo::binary_class_op_fcn f | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1839 = octave_value_typeinfo::lookup_binary_class_op (op); |
| 2376 | 1840 |
| 7336 | 1841 if (f) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1842 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1843 try |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1844 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1845 retval = f (v1, v2); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1846 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1847 catch (octave_execution_exception) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1848 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1849 gripe_library_execution_error (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1850 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1851 } |
| 7336 | 1852 else |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1853 gripe_binary_op (octave_value::binary_op_as_string (op), |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1854 v1.class_name (), v2.class_name ()); |
| 7336 | 1855 } |
| 2376 | 1856 else |
| 1857 { | |
| 7336 | 1858 // FIXME -- we need to handle overloading operators for built-in |
| 1859 // classes (double, char, int8, etc.) | |
| 2376 | 1860 |
| 7336 | 1861 octave_value_typeinfo::binary_op_fcn f |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1862 = octave_value_typeinfo::lookup_binary_op (op, t1, t2); |
| 7336 | 1863 |
| 1864 if (f) | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1865 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1866 try |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1867 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1868 retval = f (*v1.rep, *v2.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1869 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1870 catch (octave_execution_exception) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1871 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1872 gripe_library_execution_error (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1873 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1874 } |
| 7336 | 1875 else |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1876 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1877 octave_value tv1; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1878 octave_base_value::type_conv_info cf1 = v1.numeric_conversion_function (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1879 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1880 octave_value tv2; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1881 octave_base_value::type_conv_info cf2 = v2.numeric_conversion_function (); |
|
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1882 |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1883 // Try biased (one-sided) conversions first. |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1884 if (cf2.type_id () >= 0 && |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1885 octave_value_typeinfo::lookup_binary_op (op, t1, cf2.type_id ())) |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1886 cf1 = 0; |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1887 else if (cf1.type_id () >= 0 && |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1888 octave_value_typeinfo::lookup_binary_op (op, cf1.type_id (), t2)) |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1889 cf2 = 0; |
| 7336 | 1890 |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1891 if (cf1) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1892 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1893 octave_base_value *tmp = cf1 (*v1.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1894 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1895 if (tmp) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1896 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1897 tv1 = octave_value (tmp); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1898 t1 = tv1.type_id (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1899 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1900 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1901 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1902 gripe_binary_op_conv (octave_value::binary_op_as_string (op)); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1903 return retval; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1904 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1905 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1906 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1907 tv1 = v1; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1908 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1909 if (cf2) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1910 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1911 octave_base_value *tmp = cf2 (*v2.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1912 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1913 if (tmp) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1914 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1915 tv2 = octave_value (tmp); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1916 t2 = tv2.type_id (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1917 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1918 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1919 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1920 gripe_binary_op_conv (octave_value::binary_op_as_string (op)); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1921 return retval; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1922 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1923 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1924 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1925 tv2 = v2; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1926 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1927 if (cf1 || cf2) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1928 { |
|
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1929 retval = do_binary_op (op, tv1, tv2); |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1930 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1931 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1932 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1933 //demote double -> single and try again |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1934 cf1 = tv1.numeric_demotion_function (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1935 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1936 cf2 = tv2.numeric_demotion_function (); |
|
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1937 |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1938 // Try biased (one-sided) conversions first. |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1939 if (cf2.type_id () >= 0 |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1940 && octave_value_typeinfo::lookup_binary_op (op, t1, cf2.type_id ())) |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1941 cf1 = 0; |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1942 else if (cf1.type_id () >= 0 |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1943 && octave_value_typeinfo::lookup_binary_op (op, cf1.type_id (), t2)) |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1944 cf2 = 0; |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
1945 |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1946 if (cf1) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1947 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1948 octave_base_value *tmp = cf1 (*tv1.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1949 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1950 if (tmp) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1951 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1952 tv1 = octave_value (tmp); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1953 t1 = tv1.type_id (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1954 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1955 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1956 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1957 gripe_binary_op_conv (octave_value::binary_op_as_string (op)); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1958 return retval; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1959 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1960 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1961 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1962 if (cf2) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1963 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1964 octave_base_value *tmp = cf2 (*tv2.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1965 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1966 if (tmp) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1967 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1968 tv2 = octave_value (tmp); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1969 t2 = tv2.type_id (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1970 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1971 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1972 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1973 gripe_binary_op_conv (octave_value::binary_op_as_string (op)); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1974 return retval; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1975 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1976 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1977 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1978 if (cf1 || cf2) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1979 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1980 f = octave_value_typeinfo::lookup_binary_op (op, t1, t2); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1981 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1982 if (f) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1983 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1984 try |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1985 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1986 retval = f (*tv1.rep, *tv2.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1987 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1988 catch (octave_execution_exception) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1989 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1990 gripe_library_execution_error (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1991 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1992 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1993 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1994 gripe_binary_op (octave_value::binary_op_as_string (op), |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1995 v1.type_name (), v2.type_name ()); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1996 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1997 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1998 gripe_binary_op (octave_value::binary_op_as_string (op), |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
1999 v1.type_name (), v2.type_name ()); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2000 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2001 } |
| 2376 | 2002 } |
| 2003 | |
| 2004 return retval; | |
| 2005 } | |
| 2006 | |
|
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
|
2007 static 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
|
2008 decompose_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
|
2009 const octave_value& v1, const octave_value& v2) |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2010 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2011 octave_value retval; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2012 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2013 switch (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
|
2014 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2015 case octave_value::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
|
2016 retval = do_binary_op (octave_value::op_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
|
2017 do_unary_op (octave_value::op_transpose, v1), |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2018 v2); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2019 break; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2020 case octave_value::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
|
2021 retval = do_binary_op (octave_value::op_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
|
2022 v1, |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2023 do_unary_op (octave_value::op_transpose, v2)); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2024 break; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2025 case octave_value::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
|
2026 retval = do_binary_op (octave_value::op_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
|
2027 do_unary_op (octave_value::op_hermitian, v1), |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2028 v2); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2029 break; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2030 case octave_value::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
|
2031 retval = do_binary_op (octave_value::op_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
|
2032 v1, |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2033 do_unary_op (octave_value::op_hermitian, v2)); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2034 break; |
|
9661
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2035 case octave_value::op_trans_ldiv: |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2036 retval = do_binary_op (octave_value::op_ldiv, |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2037 do_unary_op (octave_value::op_transpose, v1), |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2038 v2); |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2039 break; |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2040 case octave_value::op_herm_ldiv: |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2041 retval = do_binary_op (octave_value::op_ldiv, |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2042 do_unary_op (octave_value::op_hermitian, v1), |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2043 v2); |
|
afcf852256d2
optimize / and '\ for triangular matrices
Jaroslav Hajek <highegg@gmail.com>
parents:
9608
diff
changeset
|
2044 break; |
|
8982
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2045 case octave_value::op_el_not_and: |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2046 retval = do_binary_op (octave_value::op_el_and, |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2047 do_unary_op (octave_value::op_not, v1), |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2048 v2); |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2049 break; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2050 case octave_value::op_el_not_or: |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2051 retval = do_binary_op (octave_value::op_el_or, |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2052 do_unary_op (octave_value::op_not, v1), |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2053 v2); |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2054 break; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2055 case octave_value::op_el_and_not: |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2056 retval = do_binary_op (octave_value::op_el_and, |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2057 v1, |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2058 do_unary_op (octave_value::op_not, v2)); |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2059 break; |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2060 case octave_value::op_el_or_not: |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2061 retval = do_binary_op (octave_value::op_el_or, |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2062 v1, |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2063 do_unary_op (octave_value::op_not, v2)); |
|
dc6bda6f9994
implement compound logical ops
Jaroslav Hajek <highegg@gmail.com>
parents:
8960
diff
changeset
|
2064 break; |
|
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
|
2065 default: |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2066 error ("invalid compound operator"); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2067 break; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2068 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2069 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2070 return retval; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2071 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2072 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2073 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
|
2074 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
|
2075 const octave_value& v1, const octave_value& v2) |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2076 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2077 octave_value retval; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2078 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2079 int t1 = v1.type_id (); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2080 int t2 = v2.type_id (); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2081 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2082 if (t1 == octave_class::static_type_id () |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2083 || t2 == octave_class::static_type_id ()) |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2084 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2085 octave_value_typeinfo::binary_class_op_fcn f |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2086 = octave_value_typeinfo::lookup_binary_class_op (op); |
|
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
|
2087 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2088 if (f) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2089 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2090 try |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2091 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2092 retval = f (v1, v2); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2093 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2094 catch (octave_execution_exception) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2095 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2096 gripe_library_execution_error (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2097 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2098 } |
|
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
|
2099 else |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2100 retval = decompose_binary_op (op, v1, v2); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2101 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2102 else |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2103 { |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2104 octave_value_typeinfo::binary_op_fcn f |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2105 = octave_value_typeinfo::lookup_binary_op (op, t1, t2); |
|
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
|
2106 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2107 if (f) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2108 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2109 try |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2110 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2111 retval = f (*v1.rep, *v2.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2112 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2113 catch (octave_execution_exception) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2114 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2115 gripe_library_execution_error (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2116 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2117 } |
|
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
|
2118 else |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2119 retval = decompose_binary_op (op, v1, v2); |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2120 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2121 |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2122 return retval; |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2123 } |
|
5861b95e9879
support for compound operators, implement trans_mul, mul_trans, herm_mul and mul_herm
Jaroslav Hajek <highegg@gmail.com>
parents:
7789
diff
changeset
|
2124 |
| 4915 | 2125 static void |
| 2126 gripe_cat_op (const std::string& tn1, const std::string& tn2) | |
| 2127 { | |
| 2128 error ("concatenation operator not implemented for `%s' by `%s' operations", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2129 tn1.c_str (), tn2.c_str ()); |
| 4915 | 2130 } |
| 2131 | |
| 2132 static void | |
| 2133 gripe_cat_op_conv (void) | |
| 2134 { | |
| 2135 error ("type conversion failed for concatenation operator"); | |
| 2136 } | |
| 2137 | |
| 2138 octave_value | |
| 2139 do_cat_op (const octave_value& v1, const octave_value& v2, | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2140 const Array<octave_idx_type>& ra_idx) |
| 4915 | 2141 { |
| 2142 octave_value retval; | |
| 2143 | |
|
7814
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7800
diff
changeset
|
2144 // Can't rapid return for concatenation with an empty object here as |
|
87865ed7405f
Second set of single precision test code and fix of resulting bugs
David Bateman <dbateman@free.fr>
parents:
7800
diff
changeset
|
2145 // something like cat(1,[],single([]) must return the correct type. |
| 5164 | 2146 |
| 4915 | 2147 int t1 = v1.type_id (); |
| 2148 int t2 = v2.type_id (); | |
| 2149 | |
| 5759 | 2150 octave_value_typeinfo::cat_op_fcn f |
| 2151 = octave_value_typeinfo::lookup_cat_op (t1, t2); | |
| 4915 | 2152 |
| 2153 if (f) | |
|
7487
1e01db14700b
catch octave_execution_exception for built-in and mex functions
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
2154 { |
|
1e01db14700b
catch octave_execution_exception for built-in and mex functions
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
2155 try |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2156 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2157 retval = f (*v1.rep, *v2.rep, ra_idx); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2158 } |
|
7487
1e01db14700b
catch octave_execution_exception for built-in and mex functions
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
2159 catch (octave_execution_exception) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2160 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2161 gripe_library_execution_error (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2162 } |
|
7487
1e01db14700b
catch octave_execution_exception for built-in and mex functions
John W. Eaton <jwe@octave.org>
parents:
7433
diff
changeset
|
2163 } |
| 4915 | 2164 else |
| 2165 { | |
| 2166 octave_value tv1; | |
|
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2167 octave_base_value::type_conv_info cf1 = v1.numeric_conversion_function (); |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2168 |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2169 octave_value tv2; |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2170 octave_base_value::type_conv_info cf2 = v2.numeric_conversion_function (); |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2171 |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2172 // Try biased (one-sided) conversions first. |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2173 if (cf2.type_id () >= 0 |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2174 && octave_value_typeinfo::lookup_cat_op (t1, cf2.type_id ())) |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2175 cf1 = 0; |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2176 else if (cf1.type_id () >= 0 |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2177 && octave_value_typeinfo::lookup_cat_op (cf1.type_id (), t2)) |
|
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2178 cf2 = 0; |
| 4915 | 2179 |
| 2180 if (cf1) | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2181 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2182 octave_base_value *tmp = cf1 (*v1.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2183 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2184 if (tmp) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2185 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2186 tv1 = octave_value (tmp); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2187 t1 = tv1.type_id (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2188 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2189 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2190 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2191 gripe_cat_op_conv (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2192 return retval; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2193 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2194 } |
| 4915 | 2195 else |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2196 tv1 = v1; |
| 4915 | 2197 |
| 2198 if (cf2) | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2199 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2200 octave_base_value *tmp = cf2 (*v2.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2201 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2202 if (tmp) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2203 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2204 tv2 = octave_value (tmp); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2205 t2 = tv2.type_id (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2206 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2207 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2208 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2209 gripe_cat_op_conv (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2210 return retval; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2211 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2212 } |
| 4915 | 2213 else |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2214 tv2 = v2; |
| 4915 | 2215 |
| 2216 if (cf1 || cf2) | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2217 { |
|
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2218 retval = do_cat_op (tv1, tv2, ra_idx); |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2219 } |
| 4915 | 2220 else |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2221 gripe_cat_op (v1.type_name (), v2.type_name ()); |
| 4915 | 2222 } |
| 2223 | |
| 2224 return retval; | |
| 2225 } | |
| 2226 | |
| 3933 | 2227 void |
| 2228 octave_value::print_info (std::ostream& os, const std::string& prefix) const | |
| 2229 { | |
| 2230 os << prefix << "type_name: " << type_name () << "\n" | |
| 2231 << prefix << "count: " << get_count () << "\n" | |
| 2232 << prefix << "rep info: "; | |
| 2233 | |
| 2234 rep->print_info (os, prefix + " "); | |
| 2235 } | |
| 2236 | |
| 3203 | 2237 static void |
| 3523 | 2238 gripe_unary_op (const std::string& on, const std::string& tn) |
| 3203 | 2239 { |
| 2240 error ("unary operator `%s' not implemented for `%s' operands", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2241 on.c_str (), tn.c_str ()); |
| 3203 | 2242 } |
| 2243 | |
| 2244 static void | |
| 3523 | 2245 gripe_unary_op_conv (const std::string& on) |
| 3203 | 2246 { |
| 2247 error ("type conversion failed for unary operator `%s'", on.c_str ()); | |
| 2248 } | |
| 2249 | |
| 2250 octave_value | |
| 2251 do_unary_op (octave_value::unary_op op, const octave_value& v) | |
| 2252 { | |
| 2253 octave_value retval; | |
| 2254 | |
| 2255 int t = v.type_id (); | |
| 2256 | |
| 7336 | 2257 if (t == octave_class::static_type_id ()) |
| 2258 { | |
| 2259 octave_value_typeinfo::unary_class_op_fcn f | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2260 = octave_value_typeinfo::lookup_unary_class_op (op); |
| 3203 | 2261 |
| 7336 | 2262 if (f) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2263 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2264 try |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2265 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2266 retval = f (v); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2267 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2268 catch (octave_execution_exception) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2269 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2270 gripe_library_execution_error (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2271 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2272 } |
| 7336 | 2273 else |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2274 gripe_unary_op (octave_value::unary_op_as_string (op), |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2275 v.class_name ()); |
| 7336 | 2276 } |
| 3203 | 2277 else |
| 2278 { | |
| 7336 | 2279 // FIXME -- we need to handle overloading operators for built-in |
| 2280 // classes (double, char, int8, etc.) | |
| 2281 | |
| 2282 octave_value_typeinfo::unary_op_fcn f | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2283 = octave_value_typeinfo::lookup_unary_op (op, t); |
| 3203 | 2284 |
| 7336 | 2285 if (f) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2286 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2287 try |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2288 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2289 retval = f (*v.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2290 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2291 catch (octave_execution_exception) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2292 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2293 gripe_library_execution_error (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2294 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2295 } |
| 7336 | 2296 else |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2297 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2298 octave_value tv; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2299 octave_base_value::type_conv_fcn cf |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2300 = v.numeric_conversion_function (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2301 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2302 if (cf) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2303 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2304 octave_base_value *tmp = cf (*v.rep); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2305 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2306 if (tmp) |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2307 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2308 tv = octave_value (tmp); |
|
8345
c777f3ce02d8
smarter conversion lookup
Jaroslav Hajek <highegg@gmail.com>
parents:
8150
diff
changeset
|
2309 retval = do_unary_op (op, tv); |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2310 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2311 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2312 gripe_unary_op_conv (octave_value::unary_op_as_string (op)); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2313 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2314 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2315 gripe_unary_op (octave_value::unary_op_as_string (op), |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2316 v.type_name ()); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2317 } |
| 3203 | 2318 } |
| 2319 | |
| 2320 return retval; | |
| 2321 } | |
| 2322 | |
| 2323 static void | |
| 3933 | 2324 gripe_unary_op_conversion_failed (const std::string& op, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2325 const std::string& tn) |
| 3203 | 2326 { |
| 2327 error ("operator %s: type conversion for `%s' failed", | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2328 op.c_str (), tn.c_str ()); |
| 3203 | 2329 } |
| 2330 | |
|
10614
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2331 octave_value& |
| 3933 | 2332 octave_value::do_non_const_unary_op (unary_op op) |
| 3203 | 2333 { |
|
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2334 if (op == op_incr || op == op_decr) |
| 3203 | 2335 { |
|
10614
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2336 // We want the gripe just here, because in the other branch this should |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2337 // not happen, and if it did anyway (internal error), the message would |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2338 // be confusing. |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2339 if (is_undefined ()) |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2340 { |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2341 std::string op_str = unary_op_as_string (op); |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2342 error ("in x%s or %sx, x must be defined first", |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2343 op_str.c_str (), op_str.c_str ()); |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2344 return *this; |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2345 } |
|
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2346 |
|
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2347 // Genuine. |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2348 int t = type_id (); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2349 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2350 octave_value_typeinfo::non_const_unary_op_fcn f |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2351 = octave_value_typeinfo::lookup_non_const_unary_op (op, t); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2352 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2353 if (f) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2354 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2355 make_unique (); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2356 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2357 try |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2358 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2359 f (*rep); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2360 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2361 catch (octave_execution_exception) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2362 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2363 gripe_library_execution_error (); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2364 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2365 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2366 else |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2367 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2368 octave_base_value::type_conv_fcn cf = numeric_conversion_function (); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2369 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2370 if (cf) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2371 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2372 octave_base_value *tmp = cf (*rep); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2373 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2374 if (tmp) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2375 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2376 octave_base_value *old_rep = rep; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2377 rep = tmp; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2378 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2379 t = type_id (); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2380 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2381 f = octave_value_typeinfo::lookup_non_const_unary_op (op, t); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2382 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2383 if (f) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2384 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2385 try |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2386 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2387 f (*rep); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2388 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2389 catch (octave_execution_exception) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2390 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2391 gripe_library_execution_error (); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2392 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2393 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2394 if (old_rep && --old_rep->count == 0) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2395 delete old_rep; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2396 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2397 else |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2398 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2399 if (old_rep) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2400 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2401 if (--rep->count == 0) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2402 delete rep; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2403 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2404 rep = old_rep; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2405 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2406 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2407 gripe_unary_op (octave_value::unary_op_as_string (op), |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2408 type_name ()); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2409 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2410 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2411 else |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2412 gripe_unary_op_conversion_failed |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2413 (octave_value::unary_op_as_string (op), type_name ()); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2414 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2415 else |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2416 gripe_unary_op (octave_value::unary_op_as_string (op), type_name ()); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2417 } |
| 3203 | 2418 } |
| 2419 else | |
| 2420 { | |
|
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2421 // Non-genuine. |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2422 int t = type_id (); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2423 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2424 octave_value_typeinfo::non_const_unary_op_fcn f = 0; |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2425 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2426 // Only attempt to operate in-place if this variable is unshared. |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2427 if (rep->count == 1) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2428 f = octave_value_typeinfo::lookup_non_const_unary_op (op, t); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2429 |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2430 if (f) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2431 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2432 try |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2433 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2434 f (*rep); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2435 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2436 catch (octave_execution_exception) |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2437 { |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2438 gripe_library_execution_error (); |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2439 } |
|
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2440 } |
| 3203 | 2441 else |
|
9607
1be3c73ed7b5
reuse temporary arrays in nested expressions
Jaroslav Hajek <highegg@gmail.com>
parents:
9546
diff
changeset
|
2442 *this = do_unary_op (op, *this); |
| 3203 | 2443 } |
| 3933 | 2444 |
| 2445 return *this; | |
| 3203 | 2446 } |
| 2447 | |
|
10614
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2448 octave_value& |
| 4247 | 2449 octave_value::do_non_const_unary_op (unary_op op, const std::string& type, |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2450 const std::list<octave_value_list>& idx) |
| 3933 | 2451 { |
| 2452 if (idx.empty ()) | |
|
10614
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2453 do_non_const_unary_op (op); |
| 3933 | 2454 else |
| 2455 { | |
| 5775 | 2456 // FIXME -- only do the following stuff if we can't find a |
| 3933 | 2457 // specific function to call to handle the op= operation for the |
| 2458 // types we have. | |
| 3205 | 2459 |
| 3933 | 2460 assign_op assop = unary_op_to_assign_op (op); |
| 2461 | |
|
10614
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2462 assign (assop, type, idx, 1.0); |
| 3933 | 2463 } |
| 2464 | |
|
10614
d1194069e58c
optimize code handling ++,--
Jaroslav Hajek <highegg@gmail.com>
parents:
10544
diff
changeset
|
2465 return *this; |
| 3205 | 2466 } |
| 2467 | |
| 2468 octave_value::assign_op | |
| 2469 octave_value::unary_op_to_assign_op (unary_op op) | |
| 2470 { | |
| 2471 assign_op binop = unknown_assign_op; | |
| 2472 | |
| 2473 switch (op) | |
| 2474 { | |
| 3533 | 2475 case op_incr: |
| 2476 binop = op_add_eq; | |
| 3205 | 2477 break; |
| 2478 | |
| 3533 | 2479 case op_decr: |
| 2480 binop = op_sub_eq; | |
| 3205 | 2481 break; |
| 2482 | |
| 2483 default: | |
| 2484 { | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2485 std::string on = unary_op_as_string (op); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2486 error ("operator %s: no assign operator found", on.c_str ()); |
| 3205 | 2487 } |
| 2488 } | |
| 2489 | |
| 2490 return binop; | |
| 2491 } | |
| 2492 | |
| 3204 | 2493 octave_value::binary_op |
| 2494 octave_value::op_eq_to_binary_op (assign_op op) | |
| 2495 { | |
| 2496 binary_op binop = unknown_binary_op; | |
| 2497 | |
| 2498 switch (op) | |
| 2499 { | |
| 3533 | 2500 case op_add_eq: |
| 2501 binop = op_add; | |
| 3204 | 2502 break; |
| 2503 | |
| 3533 | 2504 case op_sub_eq: |
| 2505 binop = op_sub; | |
| 3204 | 2506 break; |
| 2507 | |
| 3533 | 2508 case op_mul_eq: |
| 2509 binop = op_mul; | |
| 3204 | 2510 break; |
| 2511 | |
| 3533 | 2512 case op_div_eq: |
| 2513 binop = op_div; | |
| 3204 | 2514 break; |
| 2515 | |
| 3533 | 2516 case op_ldiv_eq: |
| 2517 binop = op_ldiv; | |
| 3204 | 2518 break; |
| 2519 | |
| 4018 | 2520 case op_pow_eq: |
| 2521 binop = op_pow; | |
| 2522 break; | |
| 2523 | |
| 3533 | 2524 case op_lshift_eq: |
| 2525 binop = op_lshift; | |
| 3204 | 2526 break; |
| 2527 | |
| 3533 | 2528 case op_rshift_eq: |
| 2529 binop = op_rshift; | |
| 3204 | 2530 break; |
| 2531 | |
| 3533 | 2532 case op_el_mul_eq: |
| 2533 binop = op_el_mul; | |
| 3204 | 2534 break; |
| 2535 | |
| 3533 | 2536 case op_el_div_eq: |
| 2537 binop = op_el_div; | |
| 3204 | 2538 break; |
| 2539 | |
| 3533 | 2540 case op_el_ldiv_eq: |
| 2541 binop = op_el_ldiv; | |
| 3204 | 2542 break; |
| 2543 | |
| 4018 | 2544 case op_el_pow_eq: |
| 2545 binop = op_el_pow; | |
| 2546 break; | |
| 2547 | |
| 3533 | 2548 case op_el_and_eq: |
| 2549 binop = op_el_and; | |
| 3204 | 2550 break; |
| 2551 | |
| 3533 | 2552 case op_el_or_eq: |
| 2553 binop = op_el_or; | |
| 3204 | 2554 break; |
| 2555 | |
| 2556 default: | |
| 2557 { | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2558 std::string on = assign_op_as_string (op); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2559 error ("operator %s: no binary operator found", on.c_str ()); |
| 3204 | 2560 } |
| 2561 } | |
| 2562 | |
| 2563 return binop; | |
| 2564 } | |
| 2565 | |
| 3933 | 2566 octave_value |
| 2567 octave_value::empty_conv (const std::string& type, const octave_value& rhs) | |
| 2568 { | |
| 2569 octave_value retval; | |
| 2570 | |
| 2571 if (type.length () > 0) | |
| 2572 { | |
| 2573 switch (type[0]) | |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2574 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2575 case '(': |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2576 { |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2577 if (type.length () > 1 && type[1] == '.') |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2578 retval = Octave_map (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2579 else |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2580 retval = octave_value (rhs.empty_clone ()); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2581 } |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2582 break; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2583 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2584 case '{': |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2585 retval = Cell (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2586 break; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2587 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2588 case '.': |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2589 retval = Octave_map (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2590 break; |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2591 |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2592 default: |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2593 panic_impossible (); |
|
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2594 } |
| 3933 | 2595 } |
| 2596 else | |
| 2597 retval = octave_value (rhs.empty_clone ()); | |
| 2598 | |
| 2599 return retval; | |
| 2600 } | |
| 2601 | |
| 2376 | 2602 void |
| 2603 install_types (void) | |
| 2604 { | |
| 2605 octave_base_value::register_type (); | |
| 3928 | 2606 octave_cell::register_type (); |
| 2376 | 2607 octave_scalar::register_type (); |
| 2608 octave_complex::register_type (); | |
| 2609 octave_matrix::register_type (); | |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
2610 octave_diag_matrix::register_type (); |
| 2376 | 2611 octave_complex_matrix::register_type (); |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
2612 octave_complex_diag_matrix::register_type (); |
| 2376 | 2613 octave_range::register_type (); |
| 2825 | 2614 octave_bool::register_type (); |
| 2615 octave_bool_matrix::register_type (); | |
| 2376 | 2616 octave_char_matrix_str::register_type (); |
| 5279 | 2617 octave_char_matrix_sq_str::register_type (); |
| 4901 | 2618 octave_int8_scalar::register_type (); |
| 2619 octave_int16_scalar::register_type (); | |
| 2620 octave_int32_scalar::register_type (); | |
| 2621 octave_int64_scalar::register_type (); | |
| 2622 octave_uint8_scalar::register_type (); | |
| 2623 octave_uint16_scalar::register_type (); | |
| 2624 octave_uint32_scalar::register_type (); | |
| 2625 octave_uint64_scalar::register_type (); | |
| 2626 octave_int8_matrix::register_type (); | |
| 2627 octave_int16_matrix::register_type (); | |
| 2628 octave_int32_matrix::register_type (); | |
| 2629 octave_int64_matrix::register_type (); | |
| 2630 octave_uint8_matrix::register_type (); | |
| 2631 octave_uint16_matrix::register_type (); | |
| 2632 octave_uint32_matrix::register_type (); | |
| 2633 octave_uint64_matrix::register_type (); | |
| 5164 | 2634 octave_sparse_bool_matrix::register_type (); |
| 2635 octave_sparse_matrix::register_type (); | |
| 2636 octave_sparse_complex_matrix::register_type (); | |
| 2376 | 2637 octave_struct::register_type (); |
| 7336 | 2638 octave_class::register_type (); |
| 3977 | 2639 octave_cs_list::register_type (); |
| 2376 | 2640 octave_magic_colon::register_type (); |
| 2974 | 2641 octave_builtin::register_type (); |
| 2642 octave_user_function::register_type (); | |
| 4649 | 2643 octave_dld_function::register_type (); |
| 4643 | 2644 octave_fcn_handle::register_type (); |
| 4966 | 2645 octave_fcn_inline::register_type (); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
2646 octave_float_scalar::register_type (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
2647 octave_float_complex::register_type (); |
|
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
2648 octave_float_matrix::register_type (); |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
2649 octave_float_diag_matrix::register_type (); |
|
7789
82be108cc558
First attempt at single precision tyeps
David Bateman <dbateman@free.fr>
parents:
7761
diff
changeset
|
2650 octave_float_complex_matrix::register_type (); |
|
8366
8b1a2555c4e2
implement diagonal matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8346
diff
changeset
|
2651 octave_float_complex_diag_matrix::register_type (); |
|
8367
445d27d79f4e
support permutation matrix objects
Jaroslav Hajek <highegg@gmail.com>
parents:
8366
diff
changeset
|
2652 octave_perm_matrix::register_type (); |
|
8150
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
2653 octave_null_matrix::register_type (); |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
2654 octave_null_str::register_type (); |
|
283989f2da9b
make null assignment matlab compatible
Jaroslav Hajek <highegg@gmail.com>
parents:
8039
diff
changeset
|
2655 octave_null_sq_str::register_type (); |
|
10325
8b3cfc1288e2
implement lazy index conversions
Jaroslav Hajek <highegg@gmail.com>
parents:
10315
diff
changeset
|
2656 octave_lazy_index::register_type (); |
| 2376 | 2657 } |
| 2658 | |
| 4970 | 2659 #if 0 |
| 2660 DEFUN (cast, args, , | |
| 2661 "-*- texinfo -*-\n\ | |
| 2662 @deftypefn {Built-in Function} {} cast (@var{val}, @var{type})\n\ | |
| 2663 Convert @var{val} to the new data type @var{type}.\n\ | |
| 5642 | 2664 @seealso{class, typeinfo}\n\ |
| 2665 @end deftypefn") | |
| 4970 | 2666 { |
| 2667 octave_value retval; | |
| 2668 | |
| 2669 if (args.length () == 2) | |
| 2670 error ("cast: not implemented"); | |
| 2671 else | |
| 5823 | 2672 print_usage (); |
| 4970 | 2673 |
| 2674 return retval; | |
| 2675 } | |
| 2676 #endif | |
| 2677 | |
| 4791 | 2678 DEFUN (sizeof, args, , |
| 2679 "-*- texinfo -*-\n\ | |
| 2680 @deftypefn {Built-in Function} {} sizeof (@var{val})\n\ | |
| 2681 Return the size of @var{val} in bytes\n\ | |
| 2682 @end deftypefn") | |
| 2683 { | |
| 2684 octave_value retval; | |
| 2685 | |
| 2686 if (args.length () == 1) | |
| 2687 retval = args(0).byte_size (); | |
| 2688 else | |
| 5823 | 2689 print_usage (); |
| 4791 | 2690 |
| 2691 return retval; | |
| 2692 } | |
| 2693 | |
| 6153 | 2694 DEFUN (subsref, args, nargout, |
| 2695 "-*- texinfo -*-\n\ | |
| 2696 @deftypefn {Built-in Function} {} subsref (@var{val}, @var{idx})\n\ | |
| 2697 Perform the subscripted element selection operation according to\n\ | |
| 2698 the subscript specified by @var{idx}.\n\ | |
| 2699 \n\ | |
| 2700 The subscript @var{idx} is expected to be a structure array with\n\ | |
| 2701 fields @samp{type} and @samp{subs}. Valid values for @samp{type}\n\ | |
| 6550 | 2702 are @samp{\"()\"}, @samp{\"@{@}\"}, and @samp{\".\"}.\n\ |
| 6153 | 2703 The @samp{subs} field may be either @samp{\":\"} or a cell array\n\ |
| 2704 of index values.\n\ | |
| 6631 | 2705 \n\ |
| 2706 The following example shows how to extract the two first columns of\n\ | |
| 2707 a matrix\n\ | |
| 2708 \n\ | |
| 2709 @example\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8992
diff
changeset
|
2710 @group\n\ |
| 6631 | 2711 val = magic(3)\n\ |
| 2712 @result{} val = [ 8 1 6\n\ | |
| 2713 3 5 7\n\ | |
| 2714 4 9 2 ]\n\ | |
| 2715 idx.type = \"()\";\n\ | |
| 2716 idx.subs = @{\":\", 1:2@};\n\ | |
| 2717 subsref(val, idx)\n\ | |
| 2718 @result{} [ 8 1 \n\ | |
| 2719 3 5 \n\ | |
| 2720 4 9 ]\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8992
diff
changeset
|
2721 @end group\n\ |
| 6631 | 2722 @end example\n\ |
| 2723 \n\ | |
| 2724 @noindent\n\ | |
| 2725 Note that this is the same as writing @code{val(:,1:2)}.\n\ | |
| 6157 | 2726 @seealso{subsasgn, substruct}\n\ |
| 6153 | 2727 @end deftypefn") |
| 2728 { | |
| 2729 octave_value_list retval; | |
| 2730 | |
| 2731 if (args.length () == 2) | |
| 2732 { | |
| 2733 std::string type; | |
| 2734 std::list<octave_value_list> idx; | |
| 2735 | |
| 2736 decode_subscripts ("subsref", args(1), type, idx); | |
| 2737 | |
| 2738 if (! error_state) | |
|
10075
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10033
diff
changeset
|
2739 { |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10033
diff
changeset
|
2740 octave_value tmp = args(0); |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10033
diff
changeset
|
2741 retval = tmp.subsref (type, idx, nargout); |
|
84b0725f4b09
return class types by reference in const Array element access functions
Jaroslav Hajek <highegg@gmail.com>
parents:
10033
diff
changeset
|
2742 } |
| 6153 | 2743 } |
| 2744 else | |
| 2745 print_usage (); | |
| 2746 | |
| 2747 return retval; | |
| 2748 } | |
| 2749 | |
| 2750 DEFUN (subsasgn, args, , | |
| 2751 "-*- texinfo -*-\n\ | |
| 2752 @deftypefn {Built-in Function} {} subsasgn (@var{val}, @var{idx}, @var{rhs})\n\ | |
| 2753 Perform the subscripted assignment operation according to\n\ | |
| 2754 the subscript specified by @var{idx}.\n\ | |
| 2755 \n\ | |
| 2756 The subscript @var{idx} is expected to be a structure array with\n\ | |
| 2757 fields @samp{type} and @samp{subs}. Valid values for @samp{type}\n\ | |
| 6248 | 2758 are @samp{\"()\"}, @samp{\"@{@}\"}, and @samp{\".\"}.\n\ |
| 6153 | 2759 The @samp{subs} field may be either @samp{\":\"} or a cell array\n\ |
| 2760 of index values.\n\ | |
| 6631 | 2761 \n\ |
| 2762 The following example shows how to set the two first columns of a\n\ | |
| 2763 3-by-3 matrix to zero.\n\ | |
| 2764 \n\ | |
| 2765 @example\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8992
diff
changeset
|
2766 @group\n\ |
| 6631 | 2767 val = magic(3);\n\ |
| 2768 idx.type = \"()\";\n\ | |
| 2769 idx.subs = @{\":\", 1:2@};\n\ | |
| 2770 subsasgn (val, idx, 0)\n\ | |
| 2771 @result{} [ 0 0 6\n\ | |
| 2772 0 0 7\n\ | |
| 2773 0 0 2 ]\n\ | |
|
9064
7c02ec148a3c
Check grammar on all .cc files
Rik <rdrider0-list@yahoo.com>
parents:
8992
diff
changeset
|
2774 @end group\n\ |
| 6631 | 2775 @end example\n\ |
| 2776 \n\ | |
| 2777 Note that this is the same as writing @code{val(:,1:2) = 0}.\n\ | |
| 6157 | 2778 @seealso{subsref, substruct}\n\ |
| 6153 | 2779 @end deftypefn") |
| 2780 { | |
| 2781 octave_value retval; | |
| 2782 | |
| 2783 if (args.length () == 3) | |
| 2784 { | |
| 2785 std::string type; | |
| 2786 std::list<octave_value_list> idx; | |
| 2787 | |
| 2788 decode_subscripts ("subsasgn", args(1), type, idx); | |
| 2789 | |
|
9368
ff612fdaee95
properly unshare variable in subsasgn
Jaroslav Hajek <highegg@gmail.com>
parents:
9351
diff
changeset
|
2790 octave_value arg0 = args(0); |
|
ff612fdaee95
properly unshare variable in subsasgn
Jaroslav Hajek <highegg@gmail.com>
parents:
9351
diff
changeset
|
2791 |
|
ff612fdaee95
properly unshare variable in subsasgn
Jaroslav Hajek <highegg@gmail.com>
parents:
9351
diff
changeset
|
2792 arg0.make_unique (); |
|
ff612fdaee95
properly unshare variable in subsasgn
Jaroslav Hajek <highegg@gmail.com>
parents:
9351
diff
changeset
|
2793 |
| 6153 | 2794 if (! error_state) |
|
10315
57a59eae83cc
untabify src C++ source files
John W. Eaton <jwe@octave.org>
parents:
10232
diff
changeset
|
2795 retval = arg0.subsasgn (type, idx, args(2)); |
| 6153 | 2796 } |
| 2797 else | |
| 2798 print_usage (); | |
| 2799 | |
| 2800 return retval; | |
| 2801 } |