GNU Octave  9.1.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
ov.h
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (C) 1996-2024 The Octave Project Developers
4 //
5 // See the file COPYRIGHT.md in the top-level directory of this
6 // distribution or <https://octave.org/copyright/>.
7 //
8 // This file is part of Octave.
9 //
10 // Octave is free software: you can redistribute it and/or modify it
11 // under the terms of the GNU General Public License as published by
12 // the Free Software Foundation, either version 3 of the License, or
13 // (at your option) any later version.
14 //
15 // Octave is distributed in the hope that it will be useful, but
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU General Public License for more details.
19 //
20 // You should have received a copy of the GNU General Public License
21 // along with Octave; see the file COPYING. If not, see
22 // <https://www.gnu.org/licenses/>.
23 //
24 ////////////////////////////////////////////////////////////////////////
25 
26 #if ! defined (octave_ov_h)
27 #define octave_ov_h 1
28 
29 #include "octave-config.h"
30 
31 #include <cstdlib>
32 
33 #include <iosfwd>
34 #include <string>
35 #include <list>
36 #include <memory>
37 #include <map>
38 
39 #include "data-conv.h"
40 #include "idx-vector.h"
41 #include "mach-info.h"
42 #include "mx-base.h"
43 #include "oct-sort.h"
44 #include "oct-time.h"
45 #include "str-vec.h"
46 
47 OCTAVE_BEGIN_NAMESPACE(octave)
48 
49 class stack_frame;
50 class type_info;
51 class scope_stack_frame;
52 class base_value_stack_frame;
53 
54 OCTAVE_END_NAMESPACE(octave)
55 
56 class Cell;
57 class float_format;
58 class mxArray;
59 class octave_map;
60 class octave_scalar_map;
61 class octave_function;
62 class octave_user_function;
63 class octave_fcn_handle;
64 class octave_value_list;
65 class octave_fcn_cache;
66 
67 #include "mxtypes.h"
68 
69 #include "oct-stream.h"
70 #include "ov-base.h"
71 
72 class
73 OCTINTERP_API
74 octave_value
75 {
76 public:
77 
78  enum unary_op
79  {
80  op_not, // not
81  op_uplus, // uplus
82  op_uminus, // uminus
83  op_transpose, // transpose
84  op_hermitian, // ctranspose
85  op_incr,
86  op_decr,
87  num_unary_ops,
88  unknown_unary_op
89  };
90 
91  enum binary_op
92  {
93  op_add, // plus
94  op_sub, // minus
95  op_mul, // mtimes
96  op_div, // mrdivide
97  op_pow, // mpower
98  op_ldiv, // mldivide
99  op_lt, // lt
100  op_le, // le
101  op_eq, // eq
102  op_ge, // ge
103  op_gt, // gt
104  op_ne, // ne
105  op_el_mul, // times
106  op_el_div, // rdivide
107  op_el_pow, // power
108  op_el_ldiv, // ldivide
109  op_el_and, // and
110  op_el_or, // or
111  op_struct_ref,
112  num_binary_ops,
113  unknown_binary_op
114  };
115 
116  enum compound_binary_op
117  {
118  // ** compound operations **
119  op_trans_mul,
120  op_mul_trans,
121  op_herm_mul,
122  op_mul_herm,
123  op_trans_ldiv,
124  op_herm_ldiv,
125  op_el_not_and,
126  op_el_not_or,
127  op_el_and_not,
128  op_el_or_not,
129  num_compound_binary_ops,
130  unknown_compound_binary_op
131  };
132 
133  enum assign_op
134  {
135  op_asn_eq,
136  op_add_eq,
137  op_sub_eq,
138  op_mul_eq,
139  op_div_eq,
140  op_ldiv_eq,
141  op_pow_eq,
142  op_el_mul_eq,
143  op_el_div_eq,
144  op_el_ldiv_eq,
145  op_el_pow_eq,
146  op_el_and_eq,
147  op_el_or_eq,
148  num_assign_ops,
149  unknown_assign_op
150  };
151 
152  static OCTINTERP_API binary_op assign_op_to_binary_op (assign_op);
153 
154  static OCTINTERP_API assign_op binary_op_to_assign_op (binary_op);
155 
156  static OCTINTERP_API std::string unary_op_as_string (unary_op);
157  static OCTINTERP_API std::string unary_op_fcn_name (unary_op);
158 
159  static OCTINTERP_API std::string binary_op_as_string (binary_op);
160  static OCTINTERP_API std::string binary_op_fcn_name (binary_op);
161 
162  static OCTINTERP_API std::string binary_op_fcn_name (compound_binary_op);
163 
164  static OCTINTERP_API std::string assign_op_as_string (assign_op);
165 
166  static OCTINTERP_API octave_value
167  empty_conv (const std::string& type,
168  const octave_value& rhs = octave_value ());
169 
170  enum magic_colon { magic_colon_t };
171 
172  octave_value ()
173  : m_rep (nil_rep ())
174  {
175  m_rep->m_count++;
176  }
177 
178  OCTINTERP_API octave_value (short int i);
179  OCTINTERP_API octave_value (unsigned short int i);
180  OCTINTERP_API octave_value (int i);
181  OCTINTERP_API octave_value (unsigned int i);
182  OCTINTERP_API octave_value (long int i);
183  OCTINTERP_API octave_value (unsigned long int i);
184 
185  // FIXME: These are kluges. They turn into doubles internally, which will
186  // break for very large values. We just use them to store things like
187  // 64-bit ino_t, etc, and hope that those values are never actually larger
188  // than can be represented exactly in a double.
189 
190 #if defined (OCTAVE_HAVE_LONG_LONG_INT)
191  OCTINTERP_API octave_value (long long int i);
192 #endif
193 #if defined (OCTAVE_HAVE_UNSIGNED_LONG_LONG_INT)
194  OCTINTERP_API octave_value (unsigned long long int i);
195 #endif
196 
197  OCTINTERP_API octave_value (octave::sys::time t);
198  OCTINTERP_API octave_value (double d);
199  OCTINTERP_API octave_value (float d);
200  OCTINTERP_API octave_value (const Array<octave_value>& a,
201  bool is_cs_list = false);
202  OCTINTERP_API octave_value (const Cell& c, bool is_cs_list = false);
203  OCTINTERP_API octave_value (const Matrix& m,
204  const MatrixType& t = MatrixType ());
205  OCTINTERP_API octave_value (const FloatMatrix& m,
206  const MatrixType& t = MatrixType ());
207  OCTINTERP_API octave_value (const NDArray& nda);
208  OCTINTERP_API octave_value (const FloatNDArray& nda);
209  OCTINTERP_API octave_value (const Array<double>& m);
210  OCTINTERP_API octave_value (const Array<float>& m);
211  OCTINTERP_API octave_value (const DiagMatrix& d);
212  OCTINTERP_API octave_value (const DiagArray2<double>& d);
213  OCTINTERP_API octave_value (const DiagArray2<float>& d);
214  OCTINTERP_API octave_value (const DiagArray2<Complex>& d);
215  OCTINTERP_API octave_value (const DiagArray2<FloatComplex>& d);
216  OCTINTERP_API octave_value (const FloatDiagMatrix& d);
217  OCTINTERP_API octave_value (const RowVector& v);
218  OCTINTERP_API octave_value (const FloatRowVector& v);
219  OCTINTERP_API octave_value (const ColumnVector& v);
220  OCTINTERP_API octave_value (const FloatColumnVector& v);
221  OCTINTERP_API octave_value (const Complex& C);
222  OCTINTERP_API octave_value (const FloatComplex& C);
223  OCTINTERP_API octave_value (const ComplexMatrix& m,
224  const MatrixType& t = MatrixType ());
225  OCTINTERP_API octave_value (const FloatComplexMatrix& m,
226  const MatrixType& t = MatrixType ());
227  OCTINTERP_API octave_value (const ComplexNDArray& cnda);
228  OCTINTERP_API octave_value (const FloatComplexNDArray& cnda);
229  OCTINTERP_API octave_value (const Array<Complex>& m);
230  OCTINTERP_API octave_value (const Array<FloatComplex>& m);
231  OCTINTERP_API octave_value (const ComplexDiagMatrix& d);
232  OCTINTERP_API octave_value (const FloatComplexDiagMatrix& d);
233  OCTINTERP_API octave_value (const ComplexRowVector& v);
234  OCTINTERP_API octave_value (const FloatComplexRowVector& v);
235  OCTINTERP_API octave_value (const ComplexColumnVector& v);
236  OCTINTERP_API octave_value (const FloatComplexColumnVector& v);
237  OCTINTERP_API octave_value (const PermMatrix& p);
238  OCTINTERP_API octave_value (bool b);
239  OCTINTERP_API octave_value (const boolMatrix& bm,
240  const MatrixType& t = MatrixType ());
241  OCTINTERP_API octave_value (const boolNDArray& bnda);
242  OCTINTERP_API octave_value (const Array<bool>& bnda);
243  OCTINTERP_API octave_value (char c, char type = '\'');
244  OCTINTERP_API octave_value (const char *s, char type = '\'');
245  OCTINTERP_API octave_value (const std::string& s, char type = '\'');
246  OCTINTERP_API octave_value (const string_vector& s, char type = '\'');
247  OCTINTERP_API octave_value (const charMatrix& chm, char type = '\'');
248  OCTINTERP_API octave_value (const charNDArray& chnda, char type = '\'');
249  OCTINTERP_API octave_value (const Array<char>& chnda, char type = '\'');
250 
251  OCTINTERP_API octave_value (const SparseMatrix& m,
252  const MatrixType& t = MatrixType ());
253  OCTINTERP_API octave_value (const Sparse<double>& m,
254  const MatrixType& t = MatrixType ());
255  OCTINTERP_API octave_value (const SparseComplexMatrix& m,
256  const MatrixType& t = MatrixType ());
257  OCTINTERP_API octave_value (const Sparse<Complex>& m,
258  const MatrixType& t = MatrixType ());
259  OCTINTERP_API octave_value (const SparseBoolMatrix& bm,
260  const MatrixType& t = MatrixType ());
261  OCTINTERP_API octave_value (const Sparse<bool>& m,
262  const MatrixType& t = MatrixType ());
263  OCTINTERP_API octave_value (const octave_int8& i);
264  OCTINTERP_API octave_value (const octave_int16& i);
265  OCTINTERP_API octave_value (const octave_int32& i);
266  OCTINTERP_API octave_value (const octave_int64& i);
267  OCTINTERP_API octave_value (const octave_uint8& i);
268  OCTINTERP_API octave_value (const octave_uint16& i);
269  OCTINTERP_API octave_value (const octave_uint32& i);
270  OCTINTERP_API octave_value (const octave_uint64& i);
271  OCTINTERP_API octave_value (const int8NDArray& inda);
272  OCTINTERP_API octave_value (const Array<octave_int8>& inda);
273  OCTINTERP_API octave_value (const int16NDArray& inda);
274  OCTINTERP_API octave_value (const Array<octave_int16>& inda);
275  OCTINTERP_API octave_value (const int32NDArray& inda);
276  OCTINTERP_API octave_value (const Array<octave_int32>& inda);
277  OCTINTERP_API octave_value (const int64NDArray& inda);
278  OCTINTERP_API octave_value (const Array<octave_int64>& inda);
279  OCTINTERP_API octave_value (const uint8NDArray& inda);
280  OCTINTERP_API octave_value (const Array<octave_uint8>& inda);
281  OCTINTERP_API octave_value (const uint16NDArray& inda);
282  OCTINTERP_API octave_value (const Array<octave_uint16>& inda);
283  OCTINTERP_API octave_value (const uint32NDArray& inda);
284  OCTINTERP_API octave_value (const Array<octave_uint32>& inda);
285  OCTINTERP_API octave_value (const uint64NDArray& inda);
286  OCTINTERP_API octave_value (const Array<octave_uint64>& inda);
287  OCTINTERP_API octave_value (const Array<octave_idx_type>& inda,
288  bool zero_based = false,
289  bool cache_index = false);
290  OCTINTERP_API octave_value (const Array<std::string>& cellstr);
291  OCTINTERP_API octave_value (const octave::idx_vector& idx, bool lazy = true);
292 
293  OCTINTERP_API octave_value (const octave::range<double>& r,
294  bool force_range = false);
295 
296  // For now, enable only range<double>.
297 
298  OCTINTERP_API octave_value (const octave_map& m);
299  OCTINTERP_API octave_value (const octave_scalar_map& m);
300  OCTINTERP_API octave_value (const std::map<std::string, octave_value>&);
301  OCTINTERP_API octave_value (const octave_map& m, const std::string& id,
302  const std::list<std::string>& plist);
303  OCTINTERP_API octave_value (const octave_scalar_map& m, const std::string& id,
304  const std::list<std::string>& plist);
305 
306  // This one is explicit because it can cause some trouble to
307  // accidentally create a cs-list when one was not intended.
308  explicit OCTINTERP_API octave_value (const octave_value_list& m);
309 
310  OCTINTERP_API octave_value (octave_value::magic_colon);
311 
312  octave_value (octave_base_value *new_rep, bool borrow = false)
313  : m_rep (new_rep)
314  {
315  if (borrow)
316  m_rep->m_count++;
317  }
318 
319  // Copy constructor.
320 
321  octave_value (const octave_value& a)
322  : m_rep (a.m_rep)
323  {
324  m_rep->m_count++;
325  }
326 
327  octave_value (octave_value&& a)
328  : m_rep (a.m_rep)
329  {
330  a.m_rep = nullptr;
331  }
332 
333  // This should only be called for derived types.
334 
335  OCTINTERP_API octave_base_value * clone () const;
336 
337  octave_base_value * empty_clone () const
338  { return m_rep->empty_clone (); }
339 
340  // Delete the representation of this constant if the count drops to zero.
341 
342  ~octave_value ()
343  {
344  // Because we define a move constructor and a move assignment
345  // operator, rep may be a nullptr here. We should only need to
346  // protect the move assignment operator in a similar way.
347 
348  if (m_rep && --m_rep->m_count == 0 && m_rep != nil_rep ())
349  delete m_rep;
350  }
351 
352  void make_unique ()
353  {
354  if (m_rep->m_count > 1)
355  {
356  octave_base_value *r = m_rep->unique_clone ();
357 
358  if (--m_rep->m_count == 0 && m_rep != nil_rep ())
359  delete m_rep;
360 
361  m_rep = r;
362  }
363  }
364 
365  // This uniquifies the value if it is referenced by more than a certain
366  // number of shallow copies. This is useful for optimizations where we
367  // know a certain copy, typically within a cell array, to be obsolete.
368  void make_unique (int obsolete_copies)
369  {
370  if (m_rep->m_count > obsolete_copies + 1)
371  {
372  octave_base_value *r = m_rep->unique_clone ();
373 
374  if (--m_rep->m_count == 0 && m_rep != nil_rep ())
375  delete m_rep;
376 
377  m_rep = r;
378  }
379  }
380 
381  // Convert any nested function handles in this object to use weak
382  // references to their enclosing stack frame context. Used to break
383  // shared_ptr reference cycles for handles to nested functions
384  // (closures).
385  void break_closure_cycles (const std::shared_ptr<octave::stack_frame>&);
386 
387  // Simple assignment.
388 
389  octave_value& operator = (const octave_value& a)
390  {
391  if (m_rep != a.m_rep)
392  {
393  if (--m_rep->m_count == 0 && m_rep != nil_rep ())
394  delete m_rep;
395 
396  m_rep = a.m_rep;
397  m_rep->m_count++;
398  }
399 
400  return *this;
401  }
402 
403  octave_value& operator = (octave_value&& a)
404  {
405  // Because we define a move constructor and a move assignment
406  // operator, rep may be a nullptr here. We should only need to
407  // protect the destructor in a similar way.
408 
409  if (this != &a)
410  {
411  if (m_rep && --m_rep->m_count == 0 && m_rep != nil_rep ())
412  delete m_rep;
413 
414  m_rep = a.m_rep;
415  a.m_rep = nullptr;
416  }
417 
418  return *this;
419  }
420 
421  octave_idx_type get_count () const { return m_rep->m_count; }
422 
423  octave_base_value::type_conv_info numeric_conversion_function () const
424  { return m_rep->numeric_conversion_function (); }
425 
426  octave_base_value::type_conv_info numeric_demotion_function () const
427  { return m_rep->numeric_demotion_function (); }
428 
429  OCTINTERP_API void maybe_mutate ();
430 
431  octave_value squeeze () const
432  { return m_rep->squeeze (); }
433 
434  // The result of full().
435  octave_value full_value () const
436  { return m_rep->full_value (); }
437 
438  // Type conversions.
439 
440  // Returns a copy of a scalar (double), or makes a scalar
441  // for other types.
442  octave_value as_double_or_copy () const
443  { return m_rep->as_double_or_copy (); }
444 
445  octave_value as_double () const { return m_rep->as_double (); }
446  octave_value as_single () const { return m_rep->as_single (); }
447 
448  octave_value as_int8 () const { return m_rep->as_int8 (); }
449  octave_value as_int16 () const { return m_rep->as_int16 (); }
450  octave_value as_int32 () const { return m_rep->as_int32 (); }
451  octave_value as_int64 () const { return m_rep->as_int64 (); }
452 
453  octave_value as_uint8 () const { return m_rep->as_uint8 (); }
454  octave_value as_uint16 () const { return m_rep->as_uint16 (); }
455  octave_value as_uint32 () const { return m_rep->as_uint32 (); }
456  octave_value as_uint64 () const { return m_rep->as_uint64 (); }
457 
458  octave_base_value * try_narrowing_conversion ()
459  { return m_rep->try_narrowing_conversion (); }
460 
461  // Close to dims (), but can be overloaded for classes.
462  Matrix size ()
463  { return m_rep->size (); }
464 
465  // FIXME: should this function be deprecated and removed? It supports
466  // an undocumented feature of Matlab.
467  octave_idx_type xnumel (const octave_value_list& idx)
468  { return m_rep->xnumel (idx); }
469 
470  // FIXME: Do we really need all these different versions of subsref
471  // and related functions?
472 
473  OCTINTERP_API octave_value
474  single_subsref (const std::string& type, const octave_value_list& idx);
475 
476  octave_value subsref (const std::string& type,
477  const std::list<octave_value_list>& idx)
478  { return m_rep->subsref (type, idx); }
479 
480  octave_value subsref (const std::string& type,
481  const std::list<octave_value_list>& idx,
482  bool auto_add)
483  { return m_rep->subsref (type, idx, auto_add); }
484 
485  OCTINTERP_API octave_value_list
486  subsref (const std::string& type, const std::list<octave_value_list>& idx,
487  int nargout);
488 
489  octave_value_list
490  simple_subsref (char type, octave_value_list& idx, int nargout);
491 
492  OCTINTERP_API octave_value
493  next_subsref (const std::string& type,
494  const std::list<octave_value_list>& idx, std::size_t skip = 1);
495 
496  OCTINTERP_API octave_value_list
497  next_subsref (int nargout, const std::string& type,
498  const std::list<octave_value_list>& idx, std::size_t skip = 1);
499 
500  OCTINTERP_API octave_value
501  next_subsref (bool auto_add, const std::string& type,
502  const std::list<octave_value_list>& idx, std::size_t skip = 1);
503 
504  octave_value index_op (const octave_value_list& idx, bool resize_ok = false)
505  {
506  return m_rep->do_index_op (idx, resize_ok);
507  }
508 
509  OCTINTERP_API octave_idx_type
510  end_index (octave_idx_type index_position,
511  octave_idx_type num_indices) const;
512 
513  OCTINTERP_API octave_value
514  subsasgn (const std::string& type, const std::list<octave_value_list>& idx,
515  const octave_value& rhs);
516 
517  octave_value
518  simple_subsasgn (char type, octave_value_list& idx, const octave_value& rhs)
519  {
520  return m_rep->simple_subsasgn (type, idx, rhs);
521  }
522 
523  OCTINTERP_API octave_value
524  undef_subsasgn (const std::string& type,
525  const std::list<octave_value_list>& idx,
526  const octave_value& rhs);
527 
528  OCTINTERP_API octave_value&
529  assign (assign_op op, const std::string& type,
530  const std::list<octave_value_list>& idx, const octave_value& rhs);
531 
532  OCTINTERP_API octave_value& assign (assign_op, const octave_value& rhs);
533 
534  octave::idx_vector index_vector (bool require_integers = false) const
535  {
536  return m_rep->index_vector (require_integers);
537  }
538 
539  // Size.
540 
541  dim_vector dims () const { return m_rep->dims (); }
542 
543  OCTINTERP_API std::string get_dims_str () const;
544 
545  octave_idx_type rows () const { return m_rep->rows (); }
546 
547  octave_idx_type columns () const { return m_rep->columns (); }
548 
549  OCTINTERP_API octave_idx_type length () const;
550 
551  int ndims () const { return m_rep->ndims (); }
552 
553  bool all_zero_dims () const { return dims ().all_zero (); }
554 
555  // Are the dimensions of this constant zero by zero?
556  bool is_zero_by_zero () const
557  { return (ndims () == 2 && rows () == 0 && columns () == 0); }
558 
559  octave_idx_type numel () const
560  { return m_rep->numel (); }
561 
562  std::size_t byte_size () const
563  { return m_rep->byte_size (); }
564 
565  octave_idx_type nnz () const { return m_rep->nnz (); }
566 
567  octave_idx_type nzmax () const { return m_rep->nzmax (); }
568 
569  octave_idx_type nfields () const { return m_rep->nfields (); }
570 
571  octave_value reshape (const dim_vector& dv) const
572  { return m_rep->reshape (dv); }
573 
574  octave_value permute (const Array<int>& vec, bool inv = false) const
575  { return m_rep->permute (vec, inv); }
576 
577  octave_value ipermute (const Array<int>& vec) const
578  { return m_rep->permute (vec, true); }
579 
580  octave_value resize (const dim_vector& dv, bool fill = false) const
581  { return m_rep->resize (dv, fill);}
582 
583  MatrixType matrix_type () const
584  { return m_rep->matrix_type (); }
585 
586  MatrixType matrix_type (const MatrixType& typ) const
587  { return m_rep->matrix_type (typ); }
588 
589  // Does this constant have a type? Both of these are provided since it is
590  // sometimes more natural to write is_undefined() instead of ! is_defined().
591 
592  bool is_defined () const
593  { return m_rep->is_defined (); }
594 
595  bool is_undefined () const
596  { return ! is_defined (); }
597 
598  bool is_legacy_object () const
599  { return m_rep->is_legacy_object (); }
600 
601  bool isempty () const
602  { return m_rep->isempty (); }
603 
604  bool iscell () const
605  { return m_rep->iscell (); }
606 
607  bool iscellstr () const
608  { return m_rep->iscellstr (); }
609 
610  bool is_real_scalar () const
611  { return m_rep->is_real_scalar (); }
612 
613  bool is_real_matrix () const
614  { return m_rep->is_real_matrix (); }
615 
616  bool is_complex_scalar () const
617  { return m_rep->is_complex_scalar (); }
618 
619  bool is_complex_matrix () const
620  { return m_rep->is_complex_matrix (); }
621 
622  bool is_bool_scalar () const
623  { return m_rep->is_bool_scalar (); }
624 
625  bool is_bool_matrix () const
626  { return m_rep->is_bool_matrix (); }
627 
628  bool is_char_matrix () const
629  { return m_rep->is_char_matrix (); }
630 
631  bool is_diag_matrix () const
632  { return m_rep->is_diag_matrix (); }
633 
634  bool is_perm_matrix () const
635  { return m_rep->is_perm_matrix (); }
636 
637  bool is_string () const
638  { return m_rep->is_string (); }
639 
640  bool is_sq_string () const
641  { return m_rep->is_sq_string (); }
642 
643  bool is_dq_string () const
644  { return m_rep->is_string () && ! m_rep->is_sq_string (); }
645 
646  bool is_range () const
647  { return m_rep->is_range (); }
648 
649  bool isstruct () const
650  { return m_rep->isstruct (); }
651 
652  bool is_classdef_meta () const
653  { return m_rep->is_classdef_meta (); }
654 
655  bool is_classdef_object () const
656  { return m_rep->is_classdef_object (); }
657 
658  bool is_classdef_superclass_ref () const
659  { return m_rep->is_classdef_superclass_ref (); }
660 
661  bool is_package () const
662  { return m_rep->is_package (); }
663 
664  bool isobject () const
665  { return m_rep->isobject (); }
666 
667  bool isjava () const
668  { return m_rep->isjava (); }
669 
670  bool is_cs_list () const
671  { return m_rep->is_cs_list (); }
672 
673  bool is_magic_colon () const
674  { return m_rep->is_magic_colon (); }
675 
676  bool is_magic_int () const
677  { return m_rep->is_magic_int (); }
678 
679  bool isnull () const
680  { return m_rep->isnull (); }
681 
682  // Are any or all of the elements in this constant nonzero?
683 
684  octave_value all (int dim = 0) const
685  { return m_rep->all (dim); }
686 
687  octave_value any (int dim = 0) const
688  { return m_rep->any (dim); }
689 
690  builtin_type_t builtin_type () const
691  { return m_rep->builtin_type (); }
692 
693  // Floating point types.
694 
695  bool is_double_type () const
696  { return m_rep->is_double_type (); }
697 
698  bool is_single_type () const
699  { return m_rep->is_single_type (); }
700 
701  bool isfloat () const
702  { return m_rep->isfloat (); }
703 
704  // Integer types.
705 
706  bool is_int8_type () const
707  { return m_rep->is_int8_type (); }
708 
709  bool is_int16_type () const
710  { return m_rep->is_int16_type (); }
711 
712  bool is_int32_type () const
713  { return m_rep->is_int32_type (); }
714 
715  bool is_int64_type () const
716  { return m_rep->is_int64_type (); }
717 
718  bool is_uint8_type () const
719  { return m_rep->is_uint8_type (); }
720 
721  bool is_uint16_type () const
722  { return m_rep->is_uint16_type (); }
723 
724  bool is_uint32_type () const
725  { return m_rep->is_uint32_type (); }
726 
727  bool is_uint64_type () const
728  { return m_rep->is_uint64_type (); }
729 
730  bool isinteger () const
731  { return m_rep->isinteger (); }
732 
733  // Other type stuff.
734 
735  bool islogical () const
736  { return m_rep->islogical (); }
737 
738  bool isreal () const
739  { return m_rep->isreal (); }
740 
741  bool iscomplex () const
742  { return m_rep->iscomplex (); }
743 
744  bool is_scalar_type () const
745  { return m_rep->is_scalar_type (); }
746 
747  bool is_matrix_type () const
748  { return m_rep->is_matrix_type (); }
749 
750  bool isnumeric () const
751  { return m_rep->isnumeric (); }
752 
753  bool issparse () const
754  { return m_rep->issparse (); }
755 
756  // Does this constant correspond to a truth value?
757 
758  bool is_true () const
759  { return m_rep->is_true (); }
760 
761  // Do two constants match (in a switch statement)?
762 
763  bool is_equal (const octave_value&) const;
764 
765  bool is_constant () const
766  { return m_rep->is_constant (); }
767 
768  bool is_function_handle () const
769  { return m_rep->is_function_handle (); }
770 
771  bool is_anonymous_function () const
772  { return m_rep->is_anonymous_function (); }
773 
774  bool is_inline_function () const
775  { return m_rep->is_inline_function (); }
776 
777  bool is_function () const
778  { return m_rep->is_function (); }
779 
780  bool is_user_script () const
781  { return m_rep->is_user_script (); }
782 
783  bool is_user_function () const
784  { return m_rep->is_user_function (); }
785 
786  bool is_user_code () const
787  { return m_rep->is_user_code (); }
788 
789  bool is_builtin_function () const
790  { return m_rep->is_builtin_function (); }
791 
792  bool is_dld_function () const
793  { return m_rep->is_dld_function (); }
794 
795  bool is_mex_function () const
796  { return m_rep->is_mex_function (); }
797 
798  void erase_subfunctions () { m_rep->erase_subfunctions (); }
799 
800  // Values.
801 
802  octave_value eval () { return *this; }
803 
804  short int
805  short_value (bool req_int = false, bool frc_str_conv = false) const
806  { return m_rep->short_value (req_int, frc_str_conv); }
807 
808  unsigned short int
809  ushort_value (bool req_int = false, bool frc_str_conv = false) const
810  { return m_rep->ushort_value (req_int, frc_str_conv); }
811 
812  int int_value (bool req_int = false, bool frc_str_conv = false) const
813  { return m_rep->int_value (req_int, frc_str_conv); }
814 
815  unsigned int
816  uint_value (bool req_int = false, bool frc_str_conv = false) const
817  { return m_rep->uint_value (req_int, frc_str_conv); }
818 
819  int nint_value (bool frc_str_conv = false) const
820  { return m_rep->nint_value (frc_str_conv); }
821 
822  long int
823  long_value (bool req_int = false, bool frc_str_conv = false) const
824  { return m_rep->long_value (req_int, frc_str_conv); }
825 
826  unsigned long int
827  ulong_value (bool req_int = false, bool frc_str_conv = false) const
828  { return m_rep->ulong_value (req_int, frc_str_conv); }
829 
830  int64_t
831  int64_value (bool req_int = false, bool frc_str_conv = false) const
832  { return m_rep->int64_value (req_int, frc_str_conv); }
833 
834  uint64_t
835  uint64_value (bool req_int = false, bool frc_str_conv = false) const
836  { return m_rep->uint64_value (req_int, frc_str_conv); }
837 
838  octave_idx_type
839  idx_type_value (bool req_int = false, bool frc_str_conv = false) const;
840 
841  double double_value (bool frc_str_conv = false) const
842  { return m_rep->double_value (frc_str_conv); }
843 
844  float float_value (bool frc_str_conv = false) const
845  { return m_rep->float_value (frc_str_conv); }
846 
847  double scalar_value (bool frc_str_conv = false) const
848  { return m_rep->scalar_value (frc_str_conv); }
849 
850  float float_scalar_value (bool frc_str_conv = false) const
851  { return m_rep->float_scalar_value (frc_str_conv); }
852 
853  Matrix matrix_value (bool frc_str_conv = false) const
854  { return m_rep->matrix_value (frc_str_conv); }
855 
856  FloatMatrix float_matrix_value (bool frc_str_conv = false) const
857  { return m_rep->float_matrix_value (frc_str_conv); }
858 
859  NDArray array_value (bool frc_str_conv = false) const
860  { return m_rep->array_value (frc_str_conv); }
861 
862  FloatNDArray float_array_value (bool frc_str_conv = false) const
863  { return m_rep->float_array_value (frc_str_conv); }
864 
865  Complex complex_value (bool frc_str_conv = false) const
866  { return m_rep->complex_value (frc_str_conv); }
867 
868  FloatComplex float_complex_value (bool frc_str_conv = false) const
869  { return m_rep->float_complex_value (frc_str_conv); }
870 
871  ComplexMatrix complex_matrix_value (bool frc_str_conv = false) const
872  { return m_rep->complex_matrix_value (frc_str_conv); }
873 
874  FloatComplexMatrix
875  float_complex_matrix_value (bool frc_str_conv = false) const
876  { return m_rep->float_complex_matrix_value (frc_str_conv); }
877 
878  ComplexNDArray complex_array_value (bool frc_str_conv = false) const
879  { return m_rep->complex_array_value (frc_str_conv); }
880 
881  FloatComplexNDArray
882  float_complex_array_value (bool frc_str_conv = false) const
883  { return m_rep->float_complex_array_value (frc_str_conv); }
884 
885  bool bool_value (bool warn = false) const
886  { return m_rep->bool_value (warn); }
887 
888  boolMatrix bool_matrix_value (bool warn = false) const
889  { return m_rep->bool_matrix_value (warn); }
890 
891  boolNDArray bool_array_value (bool warn = false) const
892  { return m_rep->bool_array_value (warn); }
893 
894  charMatrix char_matrix_value (bool frc_str_conv = false) const
895  { return m_rep->char_matrix_value (frc_str_conv); }
896 
897  charNDArray char_array_value (bool frc_str_conv = false) const
898  { return m_rep->char_array_value (frc_str_conv); }
899 
900  SparseMatrix sparse_matrix_value (bool frc_str_conv = false) const
901  { return m_rep->sparse_matrix_value (frc_str_conv); }
902 
903  SparseComplexMatrix
904  sparse_complex_matrix_value (bool frc_str_conv = false) const
905  { return m_rep->sparse_complex_matrix_value (frc_str_conv); }
906 
907  SparseBoolMatrix sparse_bool_matrix_value (bool warn = false) const
908  { return m_rep->sparse_bool_matrix_value (warn); }
909 
910  DiagMatrix diag_matrix_value (bool force = false) const
911  { return m_rep->diag_matrix_value (force); }
912 
913  FloatDiagMatrix float_diag_matrix_value (bool force = false) const
914  { return m_rep->float_diag_matrix_value (force); }
915 
916  ComplexDiagMatrix complex_diag_matrix_value (bool force = false) const
917  { return m_rep->complex_diag_matrix_value (force); }
918 
919  FloatComplexDiagMatrix
920  float_complex_diag_matrix_value (bool force = false) const
921  { return m_rep->float_complex_diag_matrix_value (force); }
922 
923  PermMatrix perm_matrix_value () const
924  { return m_rep->perm_matrix_value (); }
925 
926  octave_int8 int8_scalar_value () const
927  { return m_rep->int8_scalar_value (); }
928 
929  octave_int16 int16_scalar_value () const
930  { return m_rep->int16_scalar_value (); }
931 
932  octave_int32 int32_scalar_value () const
933  { return m_rep->int32_scalar_value (); }
934 
935  octave_int64 int64_scalar_value () const
936  { return m_rep->int64_scalar_value (); }
937 
938  octave_uint8 uint8_scalar_value () const
939  { return m_rep->uint8_scalar_value (); }
940 
941  octave_uint16 uint16_scalar_value () const
942  { return m_rep->uint16_scalar_value (); }
943 
944  octave_uint32 uint32_scalar_value () const
945  { return m_rep->uint32_scalar_value (); }
946 
947  octave_uint64 uint64_scalar_value () const
948  { return m_rep->uint64_scalar_value (); }
949 
950  int8NDArray int8_array_value () const
951  { return m_rep->int8_array_value (); }
952 
953  int16NDArray int16_array_value () const
954  { return m_rep->int16_array_value (); }
955 
956  int32NDArray int32_array_value () const
957  { return m_rep->int32_array_value (); }
958 
959  int64NDArray int64_array_value () const
960  { return m_rep->int64_array_value (); }
961 
962  uint8NDArray uint8_array_value () const
963  { return m_rep->uint8_array_value (); }
964 
965  uint16NDArray uint16_array_value () const
966  { return m_rep->uint16_array_value (); }
967 
968  uint32NDArray uint32_array_value () const
969  { return m_rep->uint32_array_value (); }
970 
971  uint64NDArray uint64_array_value () const
972  { return m_rep->uint64_array_value (); }
973 
974  std::string string_value (bool force = false) const
975  { return m_rep->string_value (force); }
976 
977  string_vector string_vector_value (bool pad = false) const
978  { return m_rep->string_vector_value (pad); }
979 
980  Cell cell_value () const;
981 
982  Array<std::string> cellstr_value () const
983  { return m_rep->cellstr_value (); }
984 
985  octave::range<double> range_value () const
986  { return m_rep->range_value (); }
987 
988  // For now, enable only range<double>.
989 
990  OCTINTERP_API octave_map map_value () const;
991 
992  OCTINTERP_API octave_scalar_map scalar_map_value () const;
993 
994  string_vector map_keys () const
995  { return m_rep->map_keys (); }
996 
997  bool isfield (const std::string& field_name) const
998  { return m_rep->isfield (field_name); }
999 
1000  std::size_t nparents () const
1001  { return m_rep->nparents (); }
1002 
1003  std::list<std::string> parent_class_name_list () const
1004  { return m_rep->parent_class_name_list (); }
1005 
1006  string_vector parent_class_names () const
1007  { return m_rep->parent_class_names (); }
1008 
1009  octave_base_value *
1010  find_parent_class (const std::string& parent_class_name)
1011  { return m_rep->find_parent_class (parent_class_name); }
1012 
1013  bool is_instance_of (const std::string& cls_name) const
1014  { return m_rep->is_instance_of (cls_name); }
1015 
1016  OCTINTERP_API octave_classdef *
1017  classdef_object_value (bool silent = false) const;
1018 
1019  OCTINTERP_API octave_function *
1020  function_value (bool silent = false) const;
1021 
1022  OCTINTERP_API octave_user_function *
1023  user_function_value (bool silent = false) const;
1024 
1025  OCTINTERP_API octave_user_script *
1026  user_script_value (bool silent = false) const;
1027 
1028  OCTINTERP_API octave_user_code * user_code_value (bool silent = false) const;
1029 
1030  OCTINTERP_API octave_fcn_handle *
1031  fcn_handle_value (bool silent = false) const;
1032 
1033  OCTINTERP_API octave_value_list list_value () const;
1034 
1035  OCTINTERP_API ColumnVector
1036  column_vector_value (bool frc_str_conv = false,
1037  bool frc_vec_conv = false) const;
1038 
1039  OCTINTERP_API ComplexColumnVector
1040  complex_column_vector_value (bool frc_str_conv = false,
1041  bool frc_vec_conv = false) const;
1042 
1043  OCTINTERP_API RowVector
1044  row_vector_value (bool frc_str_conv = false,
1045  bool frc_vec_conv = false) const;
1046 
1047  OCTINTERP_API ComplexRowVector
1048  complex_row_vector_value (bool frc_str_conv = false,
1049  bool frc_vec_conv = false) const;
1050 
1051  OCTINTERP_API FloatColumnVector
1052  float_column_vector_value (bool frc_str_conv = false,
1053  bool frc_vec_conv = false) const;
1054 
1055  OCTINTERP_API FloatComplexColumnVector
1056  float_complex_column_vector_value (bool frc_str_conv = false,
1057  bool frc_vec_conv = false) const;
1058 
1059  OCTINTERP_API FloatRowVector
1060  float_row_vector_value (bool frc_str_conv = false,
1061  bool frc_vec_conv = false) const;
1062 
1063  OCTINTERP_API FloatComplexRowVector
1064  float_complex_row_vector_value (bool frc_str_conv = false,
1065  bool frc_vec_conv = false) const;
1066 
1067  OCTINTERP_API Array<int>
1068  int_vector_value (bool req_int = false,
1069  bool frc_str_conv = false,
1070  bool frc_vec_conv = false) const;
1071 
1072  OCTINTERP_API Array<octave_idx_type>
1073  octave_idx_type_vector_value (bool req_int = false,
1074  bool frc_str_conv = false,
1075  bool frc_vec_conv = false) const;
1076 
1077  OCTINTERP_API Array<double>
1078  vector_value (bool frc_str_conv = false,
1079  bool frc_vec_conv = false) const;
1080 
1081  OCTINTERP_API Array<Complex>
1082  complex_vector_value (bool frc_str_conv = false,
1083  bool frc_vec_conv = false) const;
1084 
1085  OCTINTERP_API Array<float>
1086  float_vector_value (bool frc_str_conv = false,
1087  bool frc_vec_conv = false) const;
1088 
1089  OCTINTERP_API Array<FloatComplex>
1090  float_complex_vector_value (bool frc_str_conv = false,
1091  bool frc_vec_conv = false) const;
1092 
1093  // Extract values of specific types without any implicit type conversions.
1094  // Throw an error if an object is the wrong type for the requested value
1095  // extraction.
1096  //
1097  // These functions are intended to provide a simple way to extract values of
1098  // specific types and display error messages that are more meaningful than
1099  // the generic "error: wrong type argument 'cell'" message.
1100 
1101  OCTINTERP_API short int xshort_value (const char *fmt, ...) const;
1102 
1103  OCTINTERP_API unsigned short int xushort_value (const char *fmt, ...) const;
1104 
1105  OCTINTERP_API int xint_value (const char *fmt, ...) const;
1106 
1107  OCTINTERP_API unsigned int xuint_value (const char *fmt, ...) const;
1108 
1109  OCTINTERP_API int xnint_value (const char *fmt, ...) const;
1110 
1111  OCTINTERP_API long int xlong_value (const char *fmt, ...) const;
1112 
1113  OCTINTERP_API unsigned long int xulong_value (const char *fmt, ...) const;
1114 
1115  OCTINTERP_API int64_t xint64_value (const char *fmt, ...) const;
1116 
1117  OCTINTERP_API uint64_t xuint64_value (const char *fmt, ...) const;
1118 
1119  OCTINTERP_API octave_idx_type xidx_type_value (const char *fmt, ...) const;
1120 
1121  OCTINTERP_API double xdouble_value (const char *fmt, ...) const;
1122 
1123  OCTINTERP_API float xfloat_value (const char *fmt, ...) const;
1124 
1125  OCTINTERP_API double xscalar_value (const char *fmt, ...) const;
1126 
1127  OCTINTERP_API float xfloat_scalar_value (const char *fmt, ...) const;
1128 
1129  OCTINTERP_API Matrix xmatrix_value (const char *fmt, ...) const;
1130 
1131  OCTINTERP_API FloatMatrix xfloat_matrix_value (const char *fmt, ...) const;
1132 
1133  OCTINTERP_API NDArray xarray_value (const char *fmt, ...) const;
1134 
1135  OCTINTERP_API FloatNDArray xfloat_array_value (const char *fmt, ...) const;
1136 
1137  OCTINTERP_API Complex xcomplex_value (const char *fmt, ...) const;
1138 
1139  OCTINTERP_API FloatComplex xfloat_complex_value (const char *fmt, ...) const;
1140 
1141  OCTINTERP_API ComplexMatrix
1142  xcomplex_matrix_value (const char *fmt, ...) const;
1143 
1144  OCTINTERP_API FloatComplexMatrix
1145  xfloat_complex_matrix_value (const char *fmt, ...) const;
1146 
1147  OCTINTERP_API ComplexNDArray
1148  xcomplex_array_value (const char *fmt, ...) const;
1149 
1150  OCTINTERP_API FloatComplexNDArray
1151  xfloat_complex_array_value (const char *fmt, ...) const;
1152 
1153  OCTINTERP_API bool xbool_value (const char *fmt, ...) const;
1154 
1155  OCTINTERP_API boolMatrix xbool_matrix_value (const char *fmt, ...) const;
1156 
1157  OCTINTERP_API boolNDArray xbool_array_value (const char *fmt, ...) const;
1158 
1159  OCTINTERP_API charMatrix xchar_matrix_value (const char *fmt, ...) const;
1160 
1161  OCTINTERP_API charNDArray xchar_array_value (const char *fmt, ...) const;
1162 
1163  OCTINTERP_API SparseMatrix xsparse_matrix_value (const char *fmt, ...) const;
1164 
1165  OCTINTERP_API SparseComplexMatrix
1166  xsparse_complex_matrix_value (const char *fmt, ...) const;
1167 
1168  OCTINTERP_API SparseBoolMatrix
1169  xsparse_bool_matrix_value (const char *fmt, ...) const;
1170 
1171  OCTINTERP_API DiagMatrix xdiag_matrix_value (const char *fmt, ...) const;
1172 
1173  OCTINTERP_API FloatDiagMatrix
1174  xfloat_diag_matrix_value (const char *fmt, ...) const;
1175 
1176  OCTINTERP_API ComplexDiagMatrix
1177  xcomplex_diag_matrix_value (const char *fmt, ...) const;
1178 
1179  OCTINTERP_API FloatComplexDiagMatrix
1180  xfloat_complex_diag_matrix_value (const char *fmt, ...) const;
1181 
1182  OCTINTERP_API PermMatrix xperm_matrix_value (const char *fmt, ...) const;
1183 
1184  OCTINTERP_API octave_int8 xint8_scalar_value (const char *fmt, ...) const;
1185 
1186  OCTINTERP_API octave_int16 xint16_scalar_value (const char *fmt, ...) const;
1187 
1188  OCTINTERP_API octave_int32 xint32_scalar_value (const char *fmt, ...) const;
1189 
1190  OCTINTERP_API octave_int64 xint64_scalar_value (const char *fmt, ...) const;
1191 
1192  OCTINTERP_API octave_uint8 xuint8_scalar_value (const char *fmt, ...) const;
1193 
1194  OCTINTERP_API octave_uint16 xuint16_scalar_value (const char *fmt, ...) const;
1195 
1196  OCTINTERP_API octave_uint32 xuint32_scalar_value (const char *fmt, ...) const;
1197 
1198  OCTINTERP_API octave_uint64 xuint64_scalar_value (const char *fmt, ...) const;
1199 
1200  OCTINTERP_API int8NDArray xint8_array_value (const char *fmt, ...) const;
1201 
1202  OCTINTERP_API int16NDArray xint16_array_value (const char *fmt, ...) const;
1203 
1204  OCTINTERP_API int32NDArray xint32_array_value (const char *fmt, ...) const;
1205 
1206  OCTINTERP_API int64NDArray xint64_array_value (const char *fmt, ...) const;
1207 
1208  OCTINTERP_API uint8NDArray xuint8_array_value (const char *fmt, ...) const;
1209 
1210  OCTINTERP_API uint16NDArray xuint16_array_value (const char *fmt, ...) const;
1211 
1212  OCTINTERP_API uint32NDArray xuint32_array_value (const char *fmt, ...) const;
1213 
1214  OCTINTERP_API uint64NDArray xuint64_array_value (const char *fmt, ...) const;
1215 
1216  OCTINTERP_API std::string xstring_value (const char *fmt, ...) const;
1217 
1218  OCTINTERP_API string_vector xstring_vector_value (const char *fmt, ...) const;
1219 
1220  OCTINTERP_API Cell xcell_value (const char *fmt, ...) const;
1221 
1222  OCTINTERP_API Array<std::string> xcellstr_value (const char *fmt, ...) const;
1223 
1224  OCTINTERP_API octave::range<double>
1225  xrange_value (const char *fmt, ...) const;
1226 
1227  // For now, enable only range<double>.
1228 
1229  OCTINTERP_API octave_map xmap_value (const char *fmt, ...) const;
1230 
1231  OCTINTERP_API octave_scalar_map
1232  xscalar_map_value (const char *fmt, ...) const;
1233 
1234  OCTINTERP_API ColumnVector xcolumn_vector_value (const char *fmt, ...) const;
1235 
1236  OCTINTERP_API ComplexColumnVector
1237  xcomplex_column_vector_value (const char *fmt, ...) const;
1238 
1239  OCTINTERP_API RowVector xrow_vector_value (const char *fmt, ...) const;
1240 
1241  OCTINTERP_API ComplexRowVector
1242  xcomplex_row_vector_value (const char *fmt, ...) const;
1243 
1244  OCTINTERP_API FloatColumnVector
1245  xfloat_column_vector_value (const char *fmt, ...) const;
1246 
1247  OCTINTERP_API FloatComplexColumnVector
1248  xfloat_complex_column_vector_value (const char *fmt, ...) const;
1249 
1250  OCTINTERP_API FloatRowVector
1251  xfloat_row_vector_value (const char *fmt, ...) const;
1252 
1253  OCTINTERP_API FloatComplexRowVector
1254  xfloat_complex_row_vector_value (const char *fmt, ...) const;
1255 
1256  OCTINTERP_API Array<int> xint_vector_value (const char *fmt, ...) const;
1257 
1258  OCTINTERP_API Array<octave_idx_type>
1259  xoctave_idx_type_vector_value (const char *fmt, ...) const;
1260 
1261  OCTINTERP_API Array<double> xvector_value (const char *fmt, ...) const;
1262 
1263  OCTINTERP_API Array<Complex>
1264  xcomplex_vector_value (const char *fmt, ...) const;
1265 
1266  OCTINTERP_API Array<float> xfloat_vector_value (const char *fmt, ...) const;
1267 
1268  OCTINTERP_API Array<FloatComplex>
1269  xfloat_complex_vector_value (const char *fmt, ...) const;
1270 
1271  OCTINTERP_API octave_function * xfunction_value (const char *fmt, ...) const;
1272 
1273  OCTINTERP_API octave_user_function *
1274  xuser_function_value (const char *fmt, ...) const;
1275 
1276  OCTINTERP_API octave_user_script *
1277  xuser_script_value (const char *fmt, ...) const;
1278 
1279  OCTINTERP_API octave_user_code *
1280  xuser_code_value (const char *fmt, ...) const;
1281 
1282  OCTINTERP_API octave_fcn_handle *
1283  xfcn_handle_value (const char *fmt, ...) const;
1284 
1285  OCTINTERP_API octave_value_list xlist_value (const char *fmt, ...) const;
1286 
1287  // Possibly economize a lazy-indexed value.
1288 
1289  void maybe_economize ()
1290  { m_rep->maybe_economize (); }
1291 
1292  // The following two hook conversions are called on any octave_value prior to
1293  // storing it to a "permanent" location, like a named variable, a cell or a
1294  // struct component, or a return value of a function.
1295 
1296  OCTINTERP_API octave_value storable_value () const;
1297 
1298  // Ditto, but in place, i.e., equivalent to *this = this->storable_value (),
1299  // but possibly more efficient.
1300 
1301  OCTINTERP_API void make_storable_value ();
1302 
1303  // FIXME: These should probably be private.
1304  // Conversions. If a user of this class wants a certain kind of constant,
1305  // he should simply ask for it, and we should convert it if possible.
1306 
1307  octave_value convert_to_str (bool pad = false, bool force = false,
1308  char type = '\'') const
1309  { return m_rep->convert_to_str (pad, force, type); }
1310 
1311  octave_value
1312  convert_to_str_internal (bool pad, bool force, char type) const
1313  { return m_rep->convert_to_str_internal (pad, force, type); }
1314 
1315  void convert_to_row_or_column_vector ()
1316  { m_rep->convert_to_row_or_column_vector (); }
1317 
1318  bool print_as_scalar () const
1319  { return m_rep->print_as_scalar (); }
1320 
1321  void print (std::ostream& os, bool pr_as_read_syntax = false)
1322  { m_rep->print (os, pr_as_read_syntax); }
1323 
1324  void print_raw (std::ostream& os, bool pr_as_read_syntax = false) const
1325  { m_rep->print_raw (os, pr_as_read_syntax); }
1326 
1327  bool print_name_tag (std::ostream& os, const std::string& name) const
1328  { return m_rep->print_name_tag (os, name); }
1329 
1330  void print_with_name (std::ostream& os, const std::string& name) const
1331  { m_rep->print_with_name (os, name, true); }
1332 
1333  void short_disp (std::ostream& os) const { m_rep->short_disp (os); }
1334 
1335  OCTINTERP_API float_display_format get_edit_display_format () const;
1336 
1337  std::string edit_display (const float_display_format& fmt,
1338  octave_idx_type i, octave_idx_type j) const
1339  {
1340  return m_rep->edit_display (fmt, i, j);
1341  }
1342 
1343  int type_id () const { return m_rep->type_id (); }
1344 
1345  std::string type_name () const { return m_rep->type_name (); }
1346 
1347  std::string class_name () const { return m_rep->class_name (); }
1348 
1349  // Unary operations that are member functions. There are also some
1350  // non-member functions for unary and binary operations declared
1351  // below, outside of the octave_value class declaration.
1352 
1353  OCTINTERP_API octave_value& non_const_unary_op (unary_op op);
1354 
1355  OCTINTERP_API octave_value&
1356  non_const_unary_op (unary_op op, const std::string& type,
1357  const std::list<octave_value_list>& idx);
1358 
1359  const octave_base_value& get_rep () const { return *m_rep; }
1360 
1361  bool is_copy_of (const octave_value& val) const { return m_rep == val.m_rep; }
1362 
1363  OCTINTERP_API void
1364  print_info (std::ostream& os, const std::string& prefix = "") const;
1365 
1366  bool save_ascii (std::ostream& os) { return m_rep->save_ascii (os); }
1367 
1368  OCTINTERP_API bool load_ascii (std::istream& is);
1369 
1370  bool save_binary (std::ostream& os, bool save_as_floats)
1371  { return m_rep->save_binary (os, save_as_floats); }
1372 
1373  OCTINTERP_API bool load_binary (std::istream& is, bool swap,
1374  octave::mach_info::float_format fmt);
1375 
1376  bool save_hdf5 (octave_hdf5_id loc_id, const char *name,
1377  bool save_as_floats)
1378  { return m_rep->save_hdf5 (loc_id, name, save_as_floats); }
1379 
1380  OCTINTERP_API bool load_hdf5 (octave_hdf5_id loc_id, const char *name);
1381 
1382  OCTINTERP_API int
1383  write (octave::stream& os, int block_size,
1384  oct_data_conv::data_type output_type, int skip,
1385  octave::mach_info::float_format flt_fmt) const;
1386 
1387  octave_base_value * internal_rep () const { return m_rep; }
1388 
1389  // These functions exist to support the MEX interface.
1390  // You should not use them anywhere else.
1391 
1392  OCTINTERP_API const void *
1393  mex_get_data (mxClassID class_id = mxUNKNOWN_CLASS,
1394  mxComplexity complexity = mxREAL) const;
1395 
1396  const octave_idx_type * mex_get_ir () const
1397  {
1398  return m_rep->mex_get_ir ();
1399  }
1400 
1401  const octave_idx_type *
1402  mex_get_jc () const
1403  {
1404  return m_rep->mex_get_jc ();
1405  }
1406 
1407  mxArray * as_mxArray (bool interleaved = false) const
1408  { return m_rep->as_mxArray (interleaved); }
1409 
1410  octave_value diag (octave_idx_type k = 0) const
1411  { return m_rep->diag (k); }
1412 
1413  octave_value diag (octave_idx_type m, octave_idx_type n) const
1414  { return m_rep->diag (m, n); }
1415 
1416  octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const
1417  { return m_rep->sort (dim, mode); }
1418  octave_value sort (Array<octave_idx_type>& sidx, octave_idx_type dim = 0,
1419  sortmode mode = ASCENDING) const
1420  { return m_rep->sort (sidx, dim, mode); }
1421 
1422  sortmode issorted (sortmode mode = UNSORTED) const
1423  { return m_rep->issorted (mode); }
1424 
1425  Array<octave_idx_type> sort_rows_idx (sortmode mode = ASCENDING) const
1426  { return m_rep->sort_rows_idx (mode); }
1427 
1428  sortmode is_sorted_rows (sortmode mode = UNSORTED) const
1429  { return m_rep->is_sorted_rows (mode); }
1430 
1431  void lock () { m_rep->lock (); }
1432 
1433  void unlock () { m_rep->unlock (); }
1434 
1435  bool islocked () const { return m_rep->islocked (); }
1436 
1437  void call_object_destructor () { return m_rep->call_object_destructor (); }
1438 
1439  octave_value dump () const { return m_rep->dump (); }
1440 
1441 #define MAPPER_FORWARD(F) \
1442  octave_value F () const \
1443  { \
1444  return m_rep->map (octave_base_value::umap_ ## F); \
1445  }
1446 
1447  MAPPER_FORWARD (abs)
1448  MAPPER_FORWARD (acos)
1449  MAPPER_FORWARD (acosh)
1450  MAPPER_FORWARD (angle)
1451  MAPPER_FORWARD (arg)
1452  MAPPER_FORWARD (asin)
1453  MAPPER_FORWARD (asinh)
1454  MAPPER_FORWARD (atan)
1455  MAPPER_FORWARD (atanh)
1456  MAPPER_FORWARD (cbrt)
1457  MAPPER_FORWARD (ceil)
1458  MAPPER_FORWARD (conj)
1459  MAPPER_FORWARD (cos)
1460  MAPPER_FORWARD (cosh)
1461  MAPPER_FORWARD (erf)
1462  MAPPER_FORWARD (erfinv)
1463  MAPPER_FORWARD (erfcinv)
1464  MAPPER_FORWARD (erfc)
1465  MAPPER_FORWARD (erfcx)
1466  MAPPER_FORWARD (erfi)
1467  MAPPER_FORWARD (dawson)
1468  MAPPER_FORWARD (exp)
1469  MAPPER_FORWARD (expm1)
1470  MAPPER_FORWARD (isfinite)
1471  MAPPER_FORWARD (fix)
1472  MAPPER_FORWARD (floor)
1473  MAPPER_FORWARD (gamma)
1474  MAPPER_FORWARD (imag)
1475  MAPPER_FORWARD (isinf)
1476  MAPPER_FORWARD (isna)
1477  MAPPER_FORWARD (isnan)
1478  MAPPER_FORWARD (lgamma)
1479  MAPPER_FORWARD (log)
1480  MAPPER_FORWARD (log2)
1481  MAPPER_FORWARD (log10)
1482  MAPPER_FORWARD (log1p)
1483  MAPPER_FORWARD (real)
1484  MAPPER_FORWARD (round)
1485  MAPPER_FORWARD (roundb)
1486  MAPPER_FORWARD (signum)
1487  MAPPER_FORWARD (sin)
1488  MAPPER_FORWARD (sinh)
1489  MAPPER_FORWARD (sqrt)
1490  MAPPER_FORWARD (tan)
1491  MAPPER_FORWARD (tanh)
1492 
1493  // These functions are prefixed with X to avoid potential macro conflicts.
1494 
1495  MAPPER_FORWARD (xisalnum)
1496  MAPPER_FORWARD (xisalpha)
1497  MAPPER_FORWARD (xisascii)
1498  MAPPER_FORWARD (xiscntrl)
1499  MAPPER_FORWARD (xisdigit)
1500  MAPPER_FORWARD (xisgraph)
1501  MAPPER_FORWARD (xislower)
1502  MAPPER_FORWARD (xisprint)
1503  MAPPER_FORWARD (xispunct)
1504  MAPPER_FORWARD (xisspace)
1505  MAPPER_FORWARD (xisupper)
1506  MAPPER_FORWARD (xisxdigit)
1507  MAPPER_FORWARD (xsignbit)
1508  MAPPER_FORWARD (xtolower)
1509  MAPPER_FORWARD (xtoupper)
1510 
1511 #undef MAPPER_FORWARD
1512 
1513  octave_value map (octave_base_value::unary_mapper_t umap) const
1514  { return m_rep->map (umap); }
1515 
1516  //! Extract the n-th element, aka 'val(n)'.
1517  //!
1518  //! @return Result is undefined if 'val' is not an array type
1519  //! or @p n is out of range.
1520  //!
1521  //! @warning Function calls should never error.
1522 
1523  octave_value
1524  fast_elem_extract (octave_idx_type n) const
1525  { return m_rep->fast_elem_extract (n); }
1526 
1527  //! Assign the n-th element, aka 'val(n) = x'.
1528  //!
1529  //! @returns false if 'val' is not an array type,
1530  //! @p x is not a matching scalar type,
1531  //! or @p n is out of range.
1532  //!
1533  //! @warning Function calls should never error.
1534 
1535  bool
1536  fast_elem_insert (octave_idx_type n, const octave_value& x)
1537  {
1538  make_unique ();
1539  return m_rep->fast_elem_insert (n, x);
1540  }
1541 
1542 protected:
1543 
1544  //! The real representation.
1545  octave_base_value *m_rep;
1546 
1547  static OCTINTERP_API octave_base_value * nil_rep ();
1548 
1549 private:
1550 
1551  OCTINTERP_API assign_op unary_op_to_assign_op (unary_op op);
1552 
1553  OCTINTERP_API binary_op op_eq_to_binary_op (assign_op op);
1554 
1555  // This declaration protects against constructing octave_value from
1556  // const octave_base_value* which actually silently calls octave_value (bool).
1557  OCTINTERP_API octave_value (const octave_base_value *);
1558 
1559 };
1560 
1561 // Non-member unary and binary operations on octave_value objects.
1562 
1563 OCTAVE_BEGIN_NAMESPACE(octave)
1564 
1565 extern OCTINTERP_API octave_value
1566 unary_op (type_info& ti, octave_value::unary_op op,
1567  const octave_value& a);
1568 
1569 extern OCTINTERP_API octave_value
1570 unary_op (octave_value::unary_op op, const octave_value& a);
1571 
1572 extern OCTINTERP_API octave_value
1573 binary_op (type_info& ti, octave_value::binary_op op,
1574  const octave_value& a, const octave_value& b);
1575 
1576 extern OCTINTERP_API octave_value
1577 binary_op (type_info& ti, octave_value::compound_binary_op op,
1578  const octave_value& a, const octave_value& b);
1579 
1580 extern OCTINTERP_API octave_value
1581 binary_op (octave_value::binary_op op, const octave_value& a,
1582  const octave_value& b);
1583 
1584 extern OCTINTERP_API octave_value
1585 binary_op (octave_value::compound_binary_op op, const octave_value& a,
1586  const octave_value& b);
1587 
1588 extern OCTINTERP_API octave_value
1589 cat_op (type_info& ti, const octave_value& a,
1590  const octave_value& b, const Array<octave_idx_type>& ra_idx);
1591 
1592 extern OCTINTERP_API octave_value
1593 cat_op (const octave_value& a, const octave_value& b,
1594  const Array<octave_idx_type>& ra_idx);
1595 
1596 extern OCTINTERP_API octave_value
1597 colon_op (const octave_value& base, const octave_value& increment,
1598  const octave_value& limit, bool is_for_cmd_expr = false);
1599 
1600 inline octave_value
1601 colon_op (const octave_value& base, const octave_value& limit,
1602  bool is_for_cmd_expr = false)
1603 {
1604  // Note, we need to pass an undefined octave_value object instead of
1605  // octave_value (1.0) so that we can properly detect the
1606  // two-argument case and correctly pass just two arguments to any
1607  // user-defined function that is provided if either base or limit is
1608  // an object.
1609 
1610  return colon_op (base, octave_value (), limit, is_for_cmd_expr);
1611 }
1612 
1613 OCTAVE_END_NAMESPACE(octave)
1614 
1615 #define OV_UNOP_FN(name) \
1616  inline octave_value \
1617  name (const octave_value& a) \
1618  { \
1619  return octave::unary_op (octave_value::name, a); \
1620  }
1621 
1622 #define OV_UNOP_OP(name, op) \
1623  inline octave_value \
1624  operator op (const octave_value& a) \
1625  { \
1626  return name (a); \
1627  }
1628 
1629 #define OV_UNOP_FN_OP(name, op) \
1630  OV_UNOP_FN (name) \
1631  OV_UNOP_OP (name, op)
1632 
1633 OV_UNOP_FN_OP (op_not, !)
1634 OV_UNOP_FN_OP (op_uplus, +)
1635 OV_UNOP_FN_OP (op_uminus, -)
1636 
1637 OV_UNOP_FN (op_transpose)
1638 OV_UNOP_FN (op_hermitian)
1639 
1640 // No simple way to define these for prefix and suffix ops?
1641 //
1642 // incr
1643 // decr
1644 
1645 #define OV_BINOP_FN(name) \
1646  inline octave_value \
1647  name (const octave_value& a1, const octave_value& a2) \
1648  { \
1649  return octave::binary_op (octave_value::name, a1, a2); \
1650  }
1651 
1652 #define OV_BINOP_OP(name, op) \
1653  inline octave_value \
1654  operator op (const octave_value& a1, const octave_value& a2) \
1655  { \
1656  return name (a1, a2); \
1657  }
1658 
1659 #define OV_BINOP_FN_OP(name, op) \
1660  OV_BINOP_FN (name) \
1661  OV_BINOP_OP (name, op)
1662 
1663 OV_BINOP_FN_OP (op_add, +)
1664 OV_BINOP_FN_OP (op_sub, -)
1665 OV_BINOP_FN_OP (op_mul, *)
1666 OV_BINOP_FN_OP (op_div, /)
1667 
1668 OV_BINOP_FN (op_pow)
1669 OV_BINOP_FN (op_ldiv)
1670 
1671 OV_BINOP_FN_OP (op_lt, <)
1672 OV_BINOP_FN_OP (op_le, <=)
1673 OV_BINOP_FN_OP (op_eq, ==)
1674 OV_BINOP_FN_OP (op_ge, >=)
1675 OV_BINOP_FN_OP (op_gt, >)
1676 OV_BINOP_FN_OP (op_ne, !=)
1677 
1678 OV_BINOP_FN (op_el_mul)
1679 OV_BINOP_FN (op_el_div)
1680 OV_BINOP_FN (op_el_pow)
1681 OV_BINOP_FN (op_el_ldiv)
1682 OV_BINOP_FN (op_el_and)
1683 OV_BINOP_FN (op_el_or)
1684 
1685 OV_BINOP_FN (op_struct_ref)
1686 
1687 #define OV_COMP_BINOP_FN(name) \
1688  inline octave_value \
1689  name (const octave_value& a1, const octave_value& a2) \
1690  { \
1691  return octave::binary_op (octave_value::name, a1, a2); \
1692  }
1693 
1694 OV_COMP_BINOP_FN (op_trans_mul)
1695 OV_COMP_BINOP_FN (op_mul_trans)
1696 OV_COMP_BINOP_FN (op_herm_mul)
1697 OV_COMP_BINOP_FN (op_mul_herm)
1698 
1699 extern OCTINTERP_API void install_types (octave::type_info&);
1700 
1701 // Templated value extractors.
1702 // FIXME: would be more consistent to use panic_impossible(), rather than
1703 // assert(), but including "error.h" leads to compilation errors.
1704 template <typename Value>
1705 inline Value octave_value_extract (const octave_value&)
1706 { assert (false); }
1707 
1708 #define DEF_VALUE_EXTRACTOR(VALUE,MPREFIX) \
1709  template <> \
1710  inline VALUE octave_value_extract<VALUE> (const octave_value& v) \
1711  { \
1712  return v.MPREFIX ## _value (); \
1713  }
1714 
1715 DEF_VALUE_EXTRACTOR (double, scalar)
1716 DEF_VALUE_EXTRACTOR (float, float_scalar)
1717 DEF_VALUE_EXTRACTOR (Complex, complex)
1718 DEF_VALUE_EXTRACTOR (FloatComplex, float_complex)
1719 DEF_VALUE_EXTRACTOR (bool, bool)
1720 
1721 DEF_VALUE_EXTRACTOR (octave_int8, int8_scalar)
1722 DEF_VALUE_EXTRACTOR (octave_int16, int16_scalar)
1723 DEF_VALUE_EXTRACTOR (octave_int32, int32_scalar)
1724 DEF_VALUE_EXTRACTOR (octave_int64, int64_scalar)
1725 DEF_VALUE_EXTRACTOR (octave_uint8, uint8_scalar)
1726 DEF_VALUE_EXTRACTOR (octave_uint16, uint16_scalar)
1727 DEF_VALUE_EXTRACTOR (octave_uint32, uint32_scalar)
1728 DEF_VALUE_EXTRACTOR (octave_uint64, uint64_scalar)
1729 
1730 DEF_VALUE_EXTRACTOR (NDArray, array)
1731 DEF_VALUE_EXTRACTOR (FloatNDArray, float_array)
1732 DEF_VALUE_EXTRACTOR (ComplexNDArray, complex_array)
1733 DEF_VALUE_EXTRACTOR (FloatComplexNDArray, float_complex_array)
1734 DEF_VALUE_EXTRACTOR (boolNDArray, bool_array)
1735 
1736 DEF_VALUE_EXTRACTOR (charNDArray, char_array)
1737 DEF_VALUE_EXTRACTOR (int8NDArray, int8_array)
1738 DEF_VALUE_EXTRACTOR (int16NDArray, int16_array)
1739 DEF_VALUE_EXTRACTOR (int32NDArray, int32_array)
1740 DEF_VALUE_EXTRACTOR (int64NDArray, int64_array)
1741 DEF_VALUE_EXTRACTOR (uint8NDArray, uint8_array)
1742 DEF_VALUE_EXTRACTOR (uint16NDArray, uint16_array)
1743 DEF_VALUE_EXTRACTOR (uint32NDArray, uint32_array)
1744 DEF_VALUE_EXTRACTOR (uint64NDArray, uint64_array)
1745 
1746 DEF_VALUE_EXTRACTOR (Matrix, matrix)
1747 DEF_VALUE_EXTRACTOR (FloatMatrix, float_matrix)
1748 DEF_VALUE_EXTRACTOR (ComplexMatrix, complex_matrix)
1749 DEF_VALUE_EXTRACTOR (FloatComplexMatrix, float_complex_matrix)
1750 DEF_VALUE_EXTRACTOR (boolMatrix, bool_matrix)
1751 
1752 DEF_VALUE_EXTRACTOR (ColumnVector, column_vector)
1753 DEF_VALUE_EXTRACTOR (FloatColumnVector, float_column_vector)
1754 DEF_VALUE_EXTRACTOR (ComplexColumnVector, complex_column_vector)
1755 DEF_VALUE_EXTRACTOR (FloatComplexColumnVector, float_complex_column_vector)
1756 
1757 DEF_VALUE_EXTRACTOR (RowVector, row_vector)
1758 DEF_VALUE_EXTRACTOR (FloatRowVector, float_row_vector)
1759 DEF_VALUE_EXTRACTOR (ComplexRowVector, complex_row_vector)
1760 DEF_VALUE_EXTRACTOR (FloatComplexRowVector, float_complex_row_vector)
1761 
1762 DEF_VALUE_EXTRACTOR (DiagMatrix, diag_matrix)
1763 DEF_VALUE_EXTRACTOR (FloatDiagMatrix, float_diag_matrix)
1764 DEF_VALUE_EXTRACTOR (ComplexDiagMatrix, complex_diag_matrix)
1765 DEF_VALUE_EXTRACTOR (FloatComplexDiagMatrix, float_complex_diag_matrix)
1766 DEF_VALUE_EXTRACTOR (PermMatrix, perm_matrix)
1767 
1768 DEF_VALUE_EXTRACTOR (SparseMatrix, sparse_matrix)
1769 DEF_VALUE_EXTRACTOR (SparseComplexMatrix, sparse_complex_matrix)
1770 DEF_VALUE_EXTRACTOR (SparseBoolMatrix, sparse_bool_matrix)
1771 #undef DEF_VALUE_EXTRACTOR
1772 
1773 #define DEF_DUMMY_VALUE_EXTRACTOR(VALUE,DEFVAL) \
1774  template <> \
1775  inline VALUE octave_value_extract<VALUE> (const octave_value&) \
1776  { \
1777  assert (false); \
1778  return DEFVAL; \
1779  }
1780 
1781 DEF_DUMMY_VALUE_EXTRACTOR (char, 0)
1782 DEF_DUMMY_VALUE_EXTRACTOR (octave_value, octave_value ())
1783 #undef DEF_DUMMY_VALUE_EXTRACTOR
1784 
1785 #endif
conj
ComplexColumnVector conj(const ComplexColumnVector &a)
Definition: CColVector.cc:217
C
#define C(a, b)
Definition: Faddeeva.cc:259
Array::size
size_type size(const size_type d) const
Size of the specified dimension.
Definition: Array.h:492
Array::sort_rows_idx
Array< octave_idx_type > sort_rows_idx(sortmode mode=ASCENDING) const
Sort by rows returns only indices.
Definition: Array-base.cc:2079
Cell
Definition: Cell.h:43
Matrix
Definition: dMatrix.h:42
Sparse
Definition: Sparse.h:49
dim_vector
Vector representing the dimensions (size) of an Array.
Definition: dim-vector.h:94
float_display_format
Definition: pr-flt-fmt.h:211
float_format
Definition: pr-flt-fmt.h:50
oct_data_conv::data_type
data_type
Definition: data-conv.h:41
octave_base_value::type_conv_info
Definition: ov-base.h:252
octave_base_value
Definition: ov-base.h:245
octave_base_value::m_count
octave::refcount< octave_idx_type > m_count
Definition: ov-base.h:933
octave_base_value::try_narrowing_conversion
virtual octave_base_value * try_narrowing_conversion()
Definition: ov-base.h:323
octave_base_value::find_parent_class
virtual octave_base_value * find_parent_class(const std::string &)
Definition: ov-base.h:693
octave_base_value::empty_clone
virtual octave_base_value * empty_clone() const
Definition: ov-base.cc:121
octave_base_value::unary_mapper_t
unary_mapper_t
Definition: ov-base.h:815
octave_classdef
Definition: ov-classdef.h:48
octave_fcn_handle
Definition: ov-fcn-handle.h:188
octave_function
Definition: ov-fcn.h:54
octave_idx_type
octave_int
Definition: oct-inttypes.h:785
octave_map
Definition: oct-map.h:268
octave_scalar_map
Definition: oct-map.h:165
octave_user_code
Definition: ov-usr-fcn.h:58
octave_user_function
Definition: ov-usr-fcn.h:204
octave_user_script
Definition: ov-usr-fcn.h:151
octave_value_list
Definition: ovl.h:44
octave_value
Definition: ov.h:75
octave_value::octave_value
octave_value(octave_value &&a)
Definition: ov.h:327
octave_value::is_function_handle
bool is_function_handle() const
Definition: ov.h:768
octave_value::is_classdef_object
bool is_classdef_object() const
Definition: ov.h:655
octave_value::xstring_vector_value
string_vector xstring_vector_value(const char *fmt,...) const
octave_value::isfield
bool isfield(const std::string &field_name) const
Definition: ov.h:997
octave_value::octave_value
octave_value(const octave_uint64 &i)
octave_value::octave_value
octave_value(const Sparse< Complex > &m, const MatrixType &t=MatrixType())
octave_value::as_uint64
octave_value as_uint64() const
Definition: ov.h:456
octave_value::xsparse_matrix_value
SparseMatrix xsparse_matrix_value(const char *fmt,...) const
octave_value::internal_rep
octave_base_value * internal_rep() const
Definition: ov.h:1387
octave_value::xcolumn_vector_value
ColumnVector xcolumn_vector_value(const char *fmt,...) const
octave_value::isfloat
bool isfloat() const
Definition: ov.h:701
octave_value::sort
octave_value sort(Array< octave_idx_type > &sidx, octave_idx_type dim=0, sortmode mode=ASCENDING) const
Definition: ov.h:1418
octave_value::list_value
octave_value_list list_value() const
octave_value::xint8_scalar_value
octave_int8 xint8_scalar_value(const char *fmt,...) const
octave_value::all_zero_dims
bool all_zero_dims() const
Definition: ov.h:553
octave_value::make_unique
void make_unique(int obsolete_copies)
Definition: ov.h:368
octave_value::is_magic_int
bool is_magic_int() const
Definition: ov.h:676
octave_value::xrow_vector_value
RowVector xrow_vector_value(const char *fmt,...) const
octave_value::uint64_value
uint64_t uint64_value(bool req_int=false, bool frc_str_conv=false) const
Definition: ov.h:835
octave_value::int8_scalar_value
octave_int8 int8_scalar_value() const
Definition: ov.h:926
octave_value::is_diag_matrix
bool is_diag_matrix() const
Definition: ov.h:631
octave_value::is_undefined
bool is_undefined() const
Definition: ov.h:595
octave_value::is_uint32_type
bool is_uint32_type() const
Definition: ov.h:724
octave_value::octave_value
octave_value(octave_base_value *new_rep, bool borrow=false)
Definition: ov.h:312
octave_value::print_raw
void print_raw(std::ostream &os, bool pr_as_read_syntax=false) const
Definition: ov.h:1324
octave_value::isinteger
bool isinteger() const
Definition: ov.h:730
octave_value::xint64_array_value
int64NDArray xint64_array_value(const char *fmt,...) const
octave_value::bool_array_value
boolNDArray bool_array_value(bool warn=false) const
Definition: ov.h:891
octave_value::sparse_matrix_value
SparseMatrix sparse_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:900
octave_value::simple_subsasgn
octave_value simple_subsasgn(char type, octave_value_list &idx, const octave_value &rhs)
Definition: ov.h:518
octave_value::complex_row_vector_value
ComplexRowVector complex_row_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::uint64_scalar_value
octave_uint64 uint64_scalar_value() const
Definition: ov.h:947
octave_value::call_object_destructor
void call_object_destructor()
Definition: ov.h:1437
octave_value::xint8_array_value
int8NDArray xint8_array_value(const char *fmt,...) const
octave_value::xcell_value
Cell xcell_value(const char *fmt,...) const
octave_value::class_name
std::string class_name() const
Definition: ov.h:1347
octave_value::bool_value
bool bool_value(bool warn=false) const
Definition: ov.h:885
octave_value::xnint_value
int xnint_value(const char *fmt,...) const
octave_value::clone
octave_base_value * clone() const
octave_value::convert_to_str_internal
octave_value convert_to_str_internal(bool pad, bool force, char type) const
Definition: ov.h:1312
octave_value::is_inline_function
bool is_inline_function() const
Definition: ov.h:774
octave_value::subsref
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx)
Definition: ov.h:476
octave_value::uint16_scalar_value
octave_uint16 uint16_scalar_value() const
Definition: ov.h:941
octave_value::is_real_scalar
bool is_real_scalar() const
Definition: ov.h:610
octave_value::char_matrix_value
charMatrix char_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:894
octave_value::octave_value
octave_value(const Sparse< bool > &m, const MatrixType &t=MatrixType())
octave_value::xfloat_complex_array_value
FloatComplexNDArray xfloat_complex_array_value(const char *fmt,...) const
octave_value::as_int32
octave_value as_int32() const
Definition: ov.h:450
octave_value::int32_array_value
int32NDArray int32_array_value() const
Definition: ov.h:956
octave_value::uint16_array_value
uint16NDArray uint16_array_value() const
Definition: ov.h:965
octave_value::diag_matrix_value
DiagMatrix diag_matrix_value(bool force=false) const
Definition: ov.h:910
octave_value::xuint32_array_value
uint32NDArray xuint32_array_value(const char *fmt,...) const
octave_value::xmap_value
octave_map xmap_value(const char *fmt,...) const
octave_value::index_op
octave_value index_op(const octave_value_list &idx, bool resize_ok=false)
Definition: ov.h:504
octave_value::fast_elem_insert
bool fast_elem_insert(octave_idx_type n, const octave_value &x)
Assign the n-th element, aka 'val(n) = x'.
Definition: ov.h:1536
octave_value::octave_value
octave_value(const octave_int16 &i)
octave_value::xfloat_complex_diag_matrix_value
FloatComplexDiagMatrix xfloat_complex_diag_matrix_value(const char *fmt,...) const
octave_value::xulong_value
unsigned long int xulong_value(const char *fmt,...) const
octave_value::is_true
bool is_true() const
Definition: ov.h:758
octave_value::xint16_array_value
int16NDArray xint16_array_value(const char *fmt,...) const
octave_value::as_int8
octave_value as_int8() const
Definition: ov.h:448
octave_value::octave_value
octave_value(const Array< octave_uint8 > &inda)
octave_value::xuser_code_value
octave_user_code * xuser_code_value(const char *fmt,...) const
octave_value::is_instance_of
bool is_instance_of(const std::string &cls_name) const
Definition: ov.h:1013
octave_value::octave_value
octave_value(const uint8NDArray &inda)
octave_value::int16_array_value
int16NDArray int16_array_value() const
Definition: ov.h:953
octave_value::xfunction_value
octave_function * xfunction_value(const char *fmt,...) const
octave_value::maybe_economize
void maybe_economize()
Definition: ov.h:1289
octave_value::xlist_value
octave_value_list xlist_value(const char *fmt,...) const
octave_value::cell_value
Cell cell_value() const
octave_value::user_function_value
octave_user_function * user_function_value(bool silent=false) const
octave_value::int_value
int int_value(bool req_int=false, bool frc_str_conv=false) const
Definition: ov.h:812
octave_value::print_with_name
void print_with_name(std::ostream &os, const std::string &name) const
Definition: ov.h:1330
octave_value::is_dq_string
bool is_dq_string() const
Definition: ov.h:643
octave_value::octave_value
octave_value(const octave_map &m, const std::string &id, const std::list< std::string > &plist)
octave_value::unary_op
unary_op
Definition: ov.h:79
octave_value::op_hermitian
@ op_hermitian
Definition: ov.h:84
octave_value::num_unary_ops
@ num_unary_ops
Definition: ov.h:87
octave_value::op_uminus
@ op_uminus
Definition: ov.h:82
octave_value::op_not
@ op_not
Definition: ov.h:80
octave_value::op_transpose
@ op_transpose
Definition: ov.h:83
octave_value::op_uplus
@ op_uplus
Definition: ov.h:81
octave_value::op_incr
@ op_incr
Definition: ov.h:85
octave_value::op_decr
@ op_decr
Definition: ov.h:86
octave_value::octave_value
octave_value(const octave::range< double > &r, bool force_range=false)
octave_value::xcellstr_value
Array< std::string > xcellstr_value(const char *fmt,...) const
octave_value::int8_array_value
int8NDArray int8_array_value() const
Definition: ov.h:950
octave_value::get_dims_str
std::string get_dims_str() const
octave_value::int64_scalar_value
octave_int64 int64_scalar_value() const
Definition: ov.h:935
octave_value::octave_value
octave_value(const char *s, char type='\'')
octave_value::ndims
int ndims() const
Definition: ov.h:551
octave_value::octave_value
octave_value()
Definition: ov.h:172
octave_value::make_unique
void make_unique()
Definition: ov.h:352
octave_value::rows
octave_idx_type rows() const
Definition: ov.h:545
octave_value::index_vector
octave::idx_vector index_vector(bool require_integers=false) const
Definition: ov.h:534
octave_value::eval
octave_value eval()
Definition: ov.h:802
octave_value::int64_value
int64_t int64_value(bool req_int=false, bool frc_str_conv=false) const
Definition: ov.h:831
octave_value::is_scalar_type
bool is_scalar_type() const
Definition: ov.h:744
octave_value::diag
octave_value diag(octave_idx_type m, octave_idx_type n) const
Definition: ov.h:1413
octave_value::subsref
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx, bool auto_add)
Definition: ov.h:480
octave_value::is_sq_string
bool is_sq_string() const
Definition: ov.h:640
octave_value::range_value
octave::range< double > range_value() const
Definition: ov.h:985
octave_value::short_value
short int short_value(bool req_int=false, bool frc_str_conv=false) const
Definition: ov.h:805
octave_value::scalar_map_value
octave_scalar_map scalar_map_value() const
octave_value::isreal
bool isreal() const
Definition: ov.h:738
octave_value::nzmax
octave_idx_type nzmax() const
Definition: ov.h:567
octave_value::non_const_unary_op
octave_value & non_const_unary_op(unary_op op, const std::string &type, const std::list< octave_value_list > &idx)
octave_value::is_classdef_meta
bool is_classdef_meta() const
Definition: ov.h:652
octave_value::is_string
bool is_string() const
Definition: ov.h:637
octave_value::is_constant
bool is_constant() const
Definition: ov.h:765
octave_value::permute
octave_value permute(const Array< int > &vec, bool inv=false) const
Definition: ov.h:574
octave_value::isnumeric
bool isnumeric() const
Definition: ov.h:750
octave_value::float_diag_matrix_value
FloatDiagMatrix float_diag_matrix_value(bool force=false) const
Definition: ov.h:913
octave_value::complex_matrix_value
ComplexMatrix complex_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:871
octave_value::is_int8_type
bool is_int8_type() const
Definition: ov.h:706
octave_value::is_user_script
bool is_user_script() const
Definition: ov.h:780
octave_value::short_disp
void short_disp(std::ostream &os) const
Definition: ov.h:1333
octave_value::simple_subsref
octave_value_list simple_subsref(char type, octave_value_list &idx, int nargout)
octave_value::erase_subfunctions
void erase_subfunctions()
Definition: ov.h:798
octave_value::next_subsref
octave_value_list next_subsref(int nargout, const std::string &type, const std::list< octave_value_list > &idx, std::size_t skip=1)
octave_value::isjava
bool isjava() const
Definition: ov.h:667
octave_value::lock
void lock()
Definition: ov.h:1431
octave_value::load_binary
bool load_binary(std::istream &is, bool swap, octave::mach_info::float_format fmt)
octave_value::octave_value
octave_value(octave_value::magic_colon)
octave_value::xsparse_bool_matrix_value
SparseBoolMatrix xsparse_bool_matrix_value(const char *fmt,...) const
octave_value::dump
octave_value dump() const
Definition: ov.h:1439
octave_value::xscalar_value
double xscalar_value(const char *fmt,...) const
octave_value::complex_value
Complex complex_value(bool frc_str_conv=false) const
Definition: ov.h:865
octave_value::octave_value
octave_value(const octave_uint16 &i)
octave_value::xint32_scalar_value
octave_int32 xint32_scalar_value(const char *fmt,...) const
octave_value::xfloat_scalar_value
float xfloat_scalar_value(const char *fmt,...) const
octave_value::float_complex_vector_value
Array< FloatComplex > float_complex_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::octave_value
octave_value(const uint32NDArray &inda)
octave_value::float_complex_diag_matrix_value
FloatComplexDiagMatrix float_complex_diag_matrix_value(bool force=false) const
Definition: ov.h:920
octave_value::is_perm_matrix
bool is_perm_matrix() const
Definition: ov.h:634
octave_value::undef_subsasgn
octave_value undef_subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
octave_value::as_uint8
octave_value as_uint8() const
Definition: ov.h:453
octave_value::xfloat_matrix_value
FloatMatrix xfloat_matrix_value(const char *fmt,...) const
octave_value::idx_type_value
octave_idx_type idx_type_value(bool req_int=false, bool frc_str_conv=false) const
octave_value::ushort_value
unsigned short int ushort_value(bool req_int=false, bool frc_str_conv=false) const
Definition: ov.h:809
octave_value::size
Matrix size()
Definition: ov.h:462
octave_value::xcomplex_value
Complex xcomplex_value(const char *fmt,...) const
octave_value::save_hdf5
bool save_hdf5(octave_hdf5_id loc_id, const char *name, bool save_as_floats)
Definition: ov.h:1376
octave_value::xoctave_idx_type_vector_value
Array< octave_idx_type > xoctave_idx_type_vector_value(const char *fmt,...) const
octave_value::mex_get_ir
const octave_idx_type * mex_get_ir() const
Definition: ov.h:1396
octave_value::end_index
octave_idx_type end_index(octave_idx_type index_position, octave_idx_type num_indices) const
octave_value::octave_value
octave_value(const octave_map &m)
octave_value::matrix_type
MatrixType matrix_type() const
Definition: ov.h:583
octave_value::xint_vector_value
Array< int > xint_vector_value(const char *fmt,...) const
octave_value::octave_value
octave_value(const int32NDArray &inda)
octave_value::octave_value
octave_value(const Array< octave_int64 > &inda)
octave_value::sort
octave_value sort(octave_idx_type dim=0, sortmode mode=ASCENDING) const
Definition: ov.h:1416
octave_value::octave_value
octave_value(const int8NDArray &inda)
octave_value::ipermute
octave_value ipermute(const Array< int > &vec) const
Definition: ov.h:577
octave_value::empty_conv
static octave_value empty_conv(const std::string &type, const octave_value &rhs=octave_value())
octave_value::octave_value
octave_value(const octave_int8 &i)
octave_value::as_int16
octave_value as_int16() const
Definition: ov.h:449
octave_value::type_id
int type_id() const
Definition: ov.h:1343
octave_value::xperm_matrix_value
PermMatrix xperm_matrix_value(const char *fmt,...) const
octave_value::octave_value
octave_value(const octave_int64 &i)
octave_value::xcomplex_matrix_value
ComplexMatrix xcomplex_matrix_value(const char *fmt,...) const
octave_value::mex_get_jc
const octave_idx_type * mex_get_jc() const
Definition: ov.h:1402
octave_value::compound_binary_op
compound_binary_op
Definition: ov.h:117
octave_value::op_herm_ldiv
@ op_herm_ldiv
Definition: ov.h:124
octave_value::op_el_not_or
@ op_el_not_or
Definition: ov.h:126
octave_value::op_el_not_and
@ op_el_not_and
Definition: ov.h:125
octave_value::op_el_and_not
@ op_el_and_not
Definition: ov.h:127
octave_value::op_mul_trans
@ op_mul_trans
Definition: ov.h:120
octave_value::num_compound_binary_ops
@ num_compound_binary_ops
Definition: ov.h:129
octave_value::op_mul_herm
@ op_mul_herm
Definition: ov.h:122
octave_value::op_trans_ldiv
@ op_trans_ldiv
Definition: ov.h:123
octave_value::op_el_or_not
@ op_el_or_not
Definition: ov.h:128
octave_value::op_herm_mul
@ op_herm_mul
Definition: ov.h:121
octave_value::op_trans_mul
@ op_trans_mul
Definition: ov.h:119
octave_value::xbool_value
bool xbool_value(const char *fmt,...) const
octave_value::float_complex_row_vector_value
FloatComplexRowVector float_complex_row_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::assign
octave_value & assign(assign_op, const octave_value &rhs)
octave_value::user_code_value
octave_user_code * user_code_value(bool silent=false) const
octave_value::is_complex_scalar
bool is_complex_scalar() const
Definition: ov.h:616
octave_value::is_range
bool is_range() const
Definition: ov.h:646
octave_value::complex_array_value
ComplexNDArray complex_array_value(bool frc_str_conv=false) const
Definition: ov.h:878
octave_value::is_copy_of
bool is_copy_of(const octave_value &val) const
Definition: ov.h:1361
octave_value::next_subsref
octave_value next_subsref(const std::string &type, const std::list< octave_value_list > &idx, std::size_t skip=1)
octave_value::is_mex_function
bool is_mex_function() const
Definition: ov.h:795
octave_value::parent_class_names
string_vector parent_class_names() const
Definition: ov.h:1006
octave_value::xint16_scalar_value
octave_int16 xint16_scalar_value(const char *fmt,...) const
octave_value::as_single
octave_value as_single() const
Definition: ov.h:446
octave_value::float_row_vector_value
FloatRowVector float_row_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::is_single_type
bool is_single_type() const
Definition: ov.h:698
octave_value::edit_display
std::string edit_display(const float_display_format &fmt, octave_idx_type i, octave_idx_type j) const
Definition: ov.h:1337
octave_value::xfloat_complex_matrix_value
FloatComplexMatrix xfloat_complex_matrix_value(const char *fmt,...) const
octave_value::xfloat_complex_row_vector_value
FloatComplexRowVector xfloat_complex_row_vector_value(const char *fmt,...) const
octave_value::octave_value
octave_value(const SparseMatrix &m, const MatrixType &t=MatrixType())
octave_value::is_dld_function
bool is_dld_function() const
Definition: ov.h:792
octave_value::xuint64_array_value
uint64NDArray xuint64_array_value(const char *fmt,...) const
octave_value::is_defined
bool is_defined() const
Definition: ov.h:592
octave_value::xdouble_value
double xdouble_value(const char *fmt,...) const
octave_value::save_binary
bool save_binary(std::ostream &os, bool save_as_floats)
Definition: ov.h:1370
octave_value::char_array_value
charNDArray char_array_value(bool frc_str_conv=false) const
Definition: ov.h:897
octave_value::make_storable_value
void make_storable_value()
octave_value::get_rep
const octave_base_value & get_rep() const
Definition: ov.h:1359
octave_value::isempty
bool isempty() const
Definition: ov.h:601
octave_value::uint32_scalar_value
octave_uint32 uint32_scalar_value() const
Definition: ov.h:944
octave_value::float_column_vector_value
FloatColumnVector float_column_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::is_legacy_object
bool is_legacy_object() const
Definition: ov.h:598
octave_value::save_ascii
bool save_ascii(std::ostream &os)
Definition: ov.h:1366
octave_value::map_keys
string_vector map_keys() const
Definition: ov.h:994
octave_value::float_scalar_value
float float_scalar_value(bool frc_str_conv=false) const
Definition: ov.h:850
octave_value::is_function
bool is_function() const
Definition: ov.h:777
octave_value::float_complex_value
FloatComplex float_complex_value(bool frc_str_conv=false) const
Definition: ov.h:868
octave_value::break_closure_cycles
void break_closure_cycles(const std::shared_ptr< octave::stack_frame > &)
octave_value::xfloat_complex_vector_value
Array< FloatComplex > xfloat_complex_vector_value(const char *fmt,...) const
octave_value::xrange_value
octave::range< double > xrange_value(const char *fmt,...) const
octave_value::is_equal
bool is_equal(const octave_value &) const
octave_value::nparents
std::size_t nparents() const
Definition: ov.h:1000
octave_value::xnumel
octave_idx_type xnumel(const octave_value_list &idx)
Definition: ov.h:467
octave_value::assign_op
assign_op
Definition: ov.h:134
octave_value::op_pow_eq
@ op_pow_eq
Definition: ov.h:141
octave_value::op_asn_eq
@ op_asn_eq
Definition: ov.h:135
octave_value::op_add_eq
@ op_add_eq
Definition: ov.h:136
octave_value::op_el_pow_eq
@ op_el_pow_eq
Definition: ov.h:145
octave_value::op_mul_eq
@ op_mul_eq
Definition: ov.h:138
octave_value::op_div_eq
@ op_div_eq
Definition: ov.h:139
octave_value::op_el_and_eq
@ op_el_and_eq
Definition: ov.h:146
octave_value::op_el_ldiv_eq
@ op_el_ldiv_eq
Definition: ov.h:144
octave_value::op_sub_eq
@ op_sub_eq
Definition: ov.h:137
octave_value::op_el_mul_eq
@ op_el_mul_eq
Definition: ov.h:142
octave_value::op_el_or_eq
@ op_el_or_eq
Definition: ov.h:147
octave_value::op_el_div_eq
@ op_el_div_eq
Definition: ov.h:143
octave_value::num_assign_ops
@ num_assign_ops
Definition: ov.h:148
octave_value::op_ldiv_eq
@ op_ldiv_eq
Definition: ov.h:140
octave_value::storable_value
octave_value storable_value() const
octave_value::is_uint8_type
bool is_uint8_type() const
Definition: ov.h:718
octave_value::is_uint64_type
bool is_uint64_type() const
Definition: ov.h:727
octave_value::octave_idx_type_vector_value
Array< octave_idx_type > octave_idx_type_vector_value(bool req_int=false, bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::get_edit_display_format
float_display_format get_edit_display_format() const
octave_value::numeric_demotion_function
octave_base_value::type_conv_info numeric_demotion_function() const
Definition: ov.h:426
octave_value::as_uint32
octave_value as_uint32() const
Definition: ov.h:455
octave_value::xint64_value
int64_t xint64_value(const char *fmt,...) const
octave_value::is_zero_by_zero
bool is_zero_by_zero() const
Definition: ov.h:556
octave_value::is_uint16_type
bool is_uint16_type() const
Definition: ov.h:721
octave_value::xfcn_handle_value
octave_fcn_handle * xfcn_handle_value(const char *fmt,...) const
octave_value::uint64_array_value
uint64NDArray uint64_array_value() const
Definition: ov.h:971
octave_value::xchar_matrix_value
charMatrix xchar_matrix_value(const char *fmt,...) const
octave_value::xshort_value
short int xshort_value(const char *fmt,...) const
octave_value::xuser_script_value
octave_user_script * xuser_script_value(const char *fmt,...) const
octave_value::float_value
float float_value(bool frc_str_conv=false) const
Definition: ov.h:844
octave_value::load_hdf5
bool load_hdf5(octave_hdf5_id loc_id, const char *name)
octave_value::xsparse_complex_matrix_value
SparseComplexMatrix xsparse_complex_matrix_value(const char *fmt,...) const
octave_value::xcomplex_diag_matrix_value
ComplexDiagMatrix xcomplex_diag_matrix_value(const char *fmt,...) const
octave_value::is_magic_colon
bool is_magic_colon() const
Definition: ov.h:673
octave_value::xfloat_array_value
FloatNDArray xfloat_array_value(const char *fmt,...) const
octave_value::function_value
octave_function * function_value(bool silent=false) const
octave_value::ulong_value
unsigned long int ulong_value(bool req_int=false, bool frc_str_conv=false) const
Definition: ov.h:827
octave_value::any
octave_value any(int dim=0) const
Definition: ov.h:687
octave_value::is_int16_type
bool is_int16_type() const
Definition: ov.h:709
octave_value::nfields
octave_idx_type nfields() const
Definition: ov.h:569
octave_value::issparse
bool issparse() const
Definition: ov.h:753
octave_value::is_char_matrix
bool is_char_matrix() const
Definition: ov.h:628
octave_value::octave_value
octave_value(const SparseBoolMatrix &bm, const MatrixType &t=MatrixType())
octave_value::reshape
octave_value reshape(const dim_vector &dv) const
Definition: ov.h:571
octave_value::print_as_scalar
bool print_as_scalar() const
Definition: ov.h:1318
octave_value::assign
octave_value & assign(assign_op op, const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
octave_value::xint64_scalar_value
octave_int64 xint64_scalar_value(const char *fmt,...) const
octave_value::scalar_value
double scalar_value(bool frc_str_conv=false) const
Definition: ov.h:847
octave_value::maybe_mutate
void maybe_mutate()
octave_value::iscell
bool iscell() const
Definition: ov.h:604
octave_value::float_complex_column_vector_value
FloatComplexColumnVector float_complex_column_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::subsref
octave_value_list subsref(const std::string &type, const std::list< octave_value_list > &idx, int nargout)
octave_value::octave_value
octave_value(const octave::idx_vector &idx, bool lazy=true)
octave_value::is_bool_matrix
bool is_bool_matrix() const
Definition: ov.h:625
octave_value::xcomplex_row_vector_value
ComplexRowVector xcomplex_row_vector_value(const char *fmt,...) const
octave_value::numeric_conversion_function
octave_base_value::type_conv_info numeric_conversion_function() const
Definition: ov.h:423
octave_value::numel
octave_idx_type numel() const
Definition: ov.h:559
octave_value::next_subsref
octave_value next_subsref(bool auto_add, const std::string &type, const std::list< octave_value_list > &idx, std::size_t skip=1)
octave_value::load_ascii
bool load_ascii(std::istream &is)
octave_value::map_value
octave_map map_value() const
octave_value::convert_to_row_or_column_vector
void convert_to_row_or_column_vector()
Definition: ov.h:1315
octave_value::is_real_matrix
bool is_real_matrix() const
Definition: ov.h:613
octave_value::fcn_handle_value
octave_fcn_handle * fcn_handle_value(bool silent=false) const
octave_value::bool_matrix_value
boolMatrix bool_matrix_value(bool warn=false) const
Definition: ov.h:888
octave_value::isnull
bool isnull() const
Definition: ov.h:679
octave_value::nnz
octave_idx_type nnz() const
Definition: ov.h:565
octave_value::fast_elem_extract
octave_value fast_elem_extract(octave_idx_type n) const
Extract the n-th element, aka 'val(n)'.
Definition: ov.h:1524
octave_value::octave_value
octave_value(const Array< octave_uint16 > &inda)
octave_value::octave_value
octave_value(const SparseComplexMatrix &m, const MatrixType &t=MatrixType())
octave_value::magic_colon
magic_colon
Definition: ov.h:170
octave_value::string_value
std::string string_value(bool force=false) const
Definition: ov.h:974
octave_value::octave_value
octave_value(const octave_scalar_map &m, const std::string &id, const std::list< std::string > &plist)
octave_value::complex_diag_matrix_value
ComplexDiagMatrix complex_diag_matrix_value(bool force=false) const
Definition: ov.h:916
octave_value::uint8_scalar_value
octave_uint8 uint8_scalar_value() const
Definition: ov.h:938
octave_value::nint_value
int nint_value(bool frc_str_conv=false) const
Definition: ov.h:819
octave_value::octave_value
octave_value(const Array< char > &chnda, char type='\'')
octave_value::is_int64_type
bool is_int64_type() const
Definition: ov.h:715
octave_value::xuint8_scalar_value
octave_uint8 xuint8_scalar_value(const char *fmt,...) const
octave_value::float_matrix_value
FloatMatrix float_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:856
octave_value::find_parent_class
octave_base_value * find_parent_class(const std::string &parent_class_name)
Definition: ov.h:1010
octave_value::xscalar_map_value
octave_scalar_map xscalar_map_value(const char *fmt,...) const
octave_value::islocked
bool islocked() const
Definition: ov.h:1435
octave_value::print_info
void print_info(std::ostream &os, const std::string &prefix="") const
octave_value::xidx_type_value
octave_idx_type xidx_type_value(const char *fmt,...) const
octave_value::is_matrix_type
bool is_matrix_type() const
Definition: ov.h:747
octave_value::iscomplex
bool iscomplex() const
Definition: ov.h:741
octave_value::map
octave_value map(octave_base_value::unary_mapper_t umap) const
Definition: ov.h:1513
octave_value::int16_scalar_value
octave_int16 int16_scalar_value() const
Definition: ov.h:929
octave_value::xchar_array_value
charNDArray xchar_array_value(const char *fmt,...) const
octave_value::octave_value
octave_value(const octave_uint8 &i)
octave_value::octave_value
octave_value(const Array< octave_int32 > &inda)
octave_value::empty_clone
octave_base_value * empty_clone() const
Definition: ov.h:337
octave_value::long_value
long int long_value(bool req_int=false, bool frc_str_conv=false) const
Definition: ov.h:823
octave_value::xfloat_vector_value
Array< float > xfloat_vector_value(const char *fmt,...) const
octave_value::xcomplex_array_value
ComplexNDArray xcomplex_array_value(const char *fmt,...) const
octave_value::binary_op
binary_op
Definition: ov.h:92
octave_value::op_ldiv
@ op_ldiv
Definition: ov.h:98
octave_value::op_ne
@ op_ne
Definition: ov.h:104
octave_value::op_el_or
@ op_el_or
Definition: ov.h:110
octave_value::op_el_ldiv
@ op_el_ldiv
Definition: ov.h:108
octave_value::op_pow
@ op_pow
Definition: ov.h:97
octave_value::op_ge
@ op_ge
Definition: ov.h:102
octave_value::num_binary_ops
@ num_binary_ops
Definition: ov.h:112
octave_value::op_div
@ op_div
Definition: ov.h:96
octave_value::op_el_pow
@ op_el_pow
Definition: ov.h:107
octave_value::op_mul
@ op_mul
Definition: ov.h:95
octave_value::op_add
@ op_add
Definition: ov.h:93
octave_value::op_sub
@ op_sub
Definition: ov.h:94
octave_value::op_el_mul
@ op_el_mul
Definition: ov.h:105
octave_value::op_le
@ op_le
Definition: ov.h:100
octave_value::op_struct_ref
@ op_struct_ref
Definition: ov.h:111
octave_value::op_lt
@ op_lt
Definition: ov.h:99
octave_value::op_gt
@ op_gt
Definition: ov.h:103
octave_value::op_eq
@ op_eq
Definition: ov.h:101
octave_value::op_el_and
@ op_el_and
Definition: ov.h:109
octave_value::op_el_div
@ op_el_div
Definition: ov.h:106
octave_value::string_vector_value
string_vector string_vector_value(bool pad=false) const
Definition: ov.h:977
octave_value::octave_value
octave_value(const Array< octave_int16 > &inda)
octave_value::xcomplex_column_vector_value
ComplexColumnVector xcomplex_column_vector_value(const char *fmt,...) const
octave_value::is_sorted_rows
sortmode is_sorted_rows(sortmode mode=UNSORTED) const
Definition: ov.h:1428
octave_value::is_user_function
bool is_user_function() const
Definition: ov.h:783
octave_value::xuint64_scalar_value
octave_uint64 xuint64_scalar_value(const char *fmt,...) const
octave_value::single_subsref
octave_value single_subsref(const std::string &type, const octave_value_list &idx)
octave_value::is_anonymous_function
bool is_anonymous_function() const
Definition: ov.h:771
octave_value::complex_column_vector_value
ComplexColumnVector complex_column_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::is_package
bool is_package() const
Definition: ov.h:661
octave_value::octave_value
octave_value(const Array< octave_idx_type > &inda, bool zero_based=false, bool cache_index=false)
octave_value::xuint32_scalar_value
octave_uint32 xuint32_scalar_value(const char *fmt,...) const
octave_value::classdef_object_value
octave_classdef * classdef_object_value(bool silent=false) const
octave_value::int64_array_value
int64NDArray int64_array_value() const
Definition: ov.h:959
octave_value::get_count
octave_idx_type get_count() const
Definition: ov.h:421
octave_value::sparse_bool_matrix_value
SparseBoolMatrix sparse_bool_matrix_value(bool warn=false) const
Definition: ov.h:907
octave_value::array_value
NDArray array_value(bool frc_str_conv=false) const
Definition: ov.h:859
octave_value::xcomplex_vector_value
Array< Complex > xcomplex_vector_value(const char *fmt,...) const
octave_value::xfloat_complex_value
FloatComplex xfloat_complex_value(const char *fmt,...) const
octave_value::octave_value
octave_value(const uint64NDArray &inda)
octave_value::write
int write(octave::stream &os, int block_size, oct_data_conv::data_type output_type, int skip, octave::mach_info::float_format flt_fmt) const
octave_value::non_const_unary_op
octave_value & non_const_unary_op(unary_op op)
octave_value::xuint16_array_value
uint16NDArray xuint16_array_value(const char *fmt,...) const
octave_value::vector_value
Array< double > vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::length
octave_idx_type length() const
octave_value::octave_value
octave_value(const std::map< std::string, octave_value > &)
octave_value::as_uint16
octave_value as_uint16() const
Definition: ov.h:454
octave_value::is_double_type
bool is_double_type() const
Definition: ov.h:695
octave_value::as_int64
octave_value as_int64() const
Definition: ov.h:451
octave_value::is_builtin_function
bool is_builtin_function() const
Definition: ov.h:789
octave_value::is_int32_type
bool is_int32_type() const
Definition: ov.h:712
octave_value::is_bool_scalar
bool is_bool_scalar() const
Definition: ov.h:622
octave_value::octave_value
octave_value(const octave_value_list &m)
octave_value::octave_value
octave_value(const Sparse< double > &m, const MatrixType &t=MatrixType())
octave_value::xfloat_row_vector_value
FloatRowVector xfloat_row_vector_value(const char *fmt,...) const
octave_value::octave_value
octave_value(const octave_uint32 &i)
octave_value::is_classdef_superclass_ref
bool is_classdef_superclass_ref() const
Definition: ov.h:658
octave_value::is_cs_list
bool is_cs_list() const
Definition: ov.h:670
octave_value::as_double
octave_value as_double() const
Definition: ov.h:445
octave_value::mex_get_data
const void * mex_get_data(mxClassID class_id=mxUNKNOWN_CLASS, mxComplexity complexity=mxREAL) const
octave_value::convert_to_str
octave_value convert_to_str(bool pad=false, bool force=false, char type='\'') const
Definition: ov.h:1307
octave_value::uint8_array_value
uint8NDArray uint8_array_value() const
Definition: ov.h:962
octave_value::print_name_tag
bool print_name_tag(std::ostream &os, const std::string &name) const
Definition: ov.h:1327
octave_value::full_value
octave_value full_value() const
Definition: ov.h:435
octave_value::xuint16_scalar_value
octave_uint16 xuint16_scalar_value(const char *fmt,...) const
octave_value::issorted
sortmode issorted(sortmode mode=UNSORTED) const
Definition: ov.h:1422
octave_value::type_name
std::string type_name() const
Definition: ov.h:1345
octave_value::xlong_value
long int xlong_value(const char *fmt,...) const
octave_value::all
octave_value all(int dim=0) const
Definition: ov.h:684
octave_value::is_user_code
bool is_user_code() const
Definition: ov.h:786
octave_value::float_vector_value
Array< float > float_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::m_rep
octave_base_value * m_rep
The real representation.
Definition: ov.h:1545
octave_value::xint_value
int xint_value(const char *fmt,...) const
octave_value::xstring_value
std::string xstring_value(const char *fmt,...) const
octave_value::xuint64_value
uint64_t xuint64_value(const char *fmt,...) const
octave_value::xfloat_complex_column_vector_value
FloatComplexColumnVector xfloat_complex_column_vector_value(const char *fmt,...) const
octave_value::xfloat_diag_matrix_value
FloatDiagMatrix xfloat_diag_matrix_value(const char *fmt,...) const
octave_value::xbool_array_value
boolNDArray xbool_array_value(const char *fmt,...) const
octave_value::int32_scalar_value
octave_int32 int32_scalar_value() const
Definition: ov.h:932
octave_value::xvector_value
Array< double > xvector_value(const char *fmt,...) const
octave_value::byte_size
std::size_t byte_size() const
Definition: ov.h:562
octave_value::float_complex_array_value
FloatComplexNDArray float_complex_array_value(bool frc_str_conv=false) const
Definition: ov.h:882
octave_value::octave_value
octave_value(const octave_int32 &i)
octave_value::column_vector_value
ColumnVector column_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::xint32_array_value
int32NDArray xint32_array_value(const char *fmt,...) const
octave_value::resize
octave_value resize(const dim_vector &dv, bool fill=false) const
Definition: ov.h:580
octave_value::try_narrowing_conversion
octave_base_value * try_narrowing_conversion()
Definition: ov.h:458
octave_value::~octave_value
~octave_value()
Definition: ov.h:342
octave_value::xfloat_value
float xfloat_value(const char *fmt,...) const
octave_value::parent_class_name_list
std::list< std::string > parent_class_name_list() const
Definition: ov.h:1003
octave_value::xdiag_matrix_value
DiagMatrix xdiag_matrix_value(const char *fmt,...) const
octave_value::complex_vector_value
Array< Complex > complex_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::int_vector_value
Array< int > int_vector_value(bool req_int=false, bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::iscellstr
bool iscellstr() const
Definition: ov.h:607
octave_value::float_array_value
FloatNDArray float_array_value(bool frc_str_conv=false) const
Definition: ov.h:862
octave_value::isstruct
bool isstruct() const
Definition: ov.h:649
octave_value::octave_value
octave_value(const octave_value &a)
Definition: ov.h:321
octave_value::xmatrix_value
Matrix xmatrix_value(const char *fmt,...) const
octave_value::as_mxArray
mxArray * as_mxArray(bool interleaved=false) const
Definition: ov.h:1407
octave_value::xarray_value
NDArray xarray_value(const char *fmt,...) const
octave_value::uint32_array_value
uint32NDArray uint32_array_value() const
Definition: ov.h:968
octave_value::row_vector_value
RowVector row_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value::matrix_type
MatrixType matrix_type(const MatrixType &typ) const
Definition: ov.h:586
octave_value::xfloat_column_vector_value
FloatColumnVector xfloat_column_vector_value(const char *fmt,...) const
octave_value::octave_value
octave_value(const int64NDArray &inda)
octave_value::is_complex_matrix
bool is_complex_matrix() const
Definition: ov.h:619
octave_value::octave_value
octave_value(const Array< std::string > &cellstr)
octave_value::octave_value
octave_value(const octave_scalar_map &m)
octave_value::columns
octave_idx_type columns() const
Definition: ov.h:547
octave_value::octave_value
octave_value(const uint16NDArray &inda)
octave_value::matrix_value
Matrix matrix_value(bool frc_str_conv=false) const
Definition: ov.h:853
octave_value::octave_value
octave_value(const Array< octave_int8 > &inda)
octave_value::octave_value
octave_value(const charNDArray &chnda, char type='\'')
octave_value::builtin_type
builtin_type_t builtin_type() const
Definition: ov.h:690
octave_value::float_complex_matrix_value
FloatComplexMatrix float_complex_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:875
octave_value::print
void print(std::ostream &os, bool pr_as_read_syntax=false)
Definition: ov.h:1321
octave_value::diag
octave_value diag(octave_idx_type k=0) const
Definition: ov.h:1410
octave_value::octave_value
octave_value(const Array< octave_uint32 > &inda)
octave_value::double_value
double double_value(bool frc_str_conv=false) const
Definition: ov.h:841
octave_value::uint_value
unsigned int uint_value(bool req_int=false, bool frc_str_conv=false) const
Definition: ov.h:816
octave_value::xbool_matrix_value
boolMatrix xbool_matrix_value(const char *fmt,...) const
octave_value::perm_matrix_value
PermMatrix perm_matrix_value() const
Definition: ov.h:923
octave_value::xuint_value
unsigned int xuint_value(const char *fmt,...) const
octave_value::octave_value
octave_value(const int16NDArray &inda)
octave_value::as_double_or_copy
octave_value as_double_or_copy() const
Definition: ov.h:442
octave_value::isobject
bool isobject() const
Definition: ov.h:664
octave_value::xuser_function_value
octave_user_function * xuser_function_value(const char *fmt,...) const
octave_value::sparse_complex_matrix_value
SparseComplexMatrix sparse_complex_matrix_value(bool frc_str_conv=false) const
Definition: ov.h:904
octave_value::islogical
bool islogical() const
Definition: ov.h:735
octave_value::subsasgn
octave_value subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
octave_value::xushort_value
unsigned short int xushort_value(const char *fmt,...) const
octave_value::user_script_value
octave_user_script * user_script_value(bool silent=false) const
octave_value::cellstr_value
Array< std::string > cellstr_value() const
Definition: ov.h:982
octave_value::octave_value
octave_value(const string_vector &s, char type='\'')
octave_value::dims
dim_vector dims() const
Definition: ov.h:541
octave_value::unlock
void unlock()
Definition: ov.h:1433
octave_value::sort_rows_idx
Array< octave_idx_type > sort_rows_idx(sortmode mode=ASCENDING) const
Definition: ov.h:1425
octave_value::xuint8_array_value
uint8NDArray xuint8_array_value(const char *fmt,...) const
octave_value::octave_value
octave_value(const Array< octave_uint64 > &inda)
octave_value::squeeze
octave_value squeeze() const
Definition: ov.h:431
stack_frame
Definition: stack-frame.h:109
string_vector
Definition: str-vec.h:40
type_info
Definition: ov-typeinfo.h:45
real
ColumnVector real(const ComplexColumnVector &a)
Definition: dColVector.cc:137
imag
ColumnVector imag(const ComplexColumnVector &a)
Definition: dColVector.cc:143
OCTAVE_BEGIN_NAMESPACE
OCTAVE_BEGIN_NAMESPACE(octave) static octave_value daspk_fcn
gamma
function gamma(X)
Definition: gamma.f:3
idx_vector
octave::idx_vector idx_vector
Definition: idx-vector.h:1022
log2
Complex log2(const Complex &x)
Definition: lo-mappers.cc:141
asin
Complex asin(const Complex &x)
Definition: lo-mappers.cc:107
isna
bool isna(double x)
Definition: lo-mappers.cc:47
acos
Complex acos(const Complex &x)
Definition: lo-mappers.cc:85
atan
Complex atan(const Complex &x)
Definition: lo-mappers.h:71
roundb
double roundb(double x)
Definition: lo-mappers.h:147
isfinite
bool isfinite(double x)
Definition: lo-mappers.h:192
isinf
bool isinf(double x)
Definition: lo-mappers.h:203
signum
double signum(double x)
Definition: lo-mappers.h:229
round
double round(double x)
Definition: lo-mappers.h:136
isnan
bool isnan(bool)
Definition: lo-mappers.h:178
floor
std::complex< T > floor(const std::complex< T > &x)
Definition: lo-mappers.h:130
ceil
std::complex< T > ceil(const std::complex< T > &x)
Definition: lo-mappers.h:103
fix
double fix(double x)
Definition: lo-mappers.h:118
d
F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE * d
Definition: lo-slatec-proto.h:39
x
F77_RET_T const F77_DBLE * x
Definition: lo-slatec-proto.h:38
erfinv
double erfinv(double x)
Definition: lo-specfun.cc:1823
dawson
double dawson(double x)
Definition: lo-specfun.cc:1467
erfcinv
double erfcinv(double x)
Definition: lo-specfun.cc:1697
expm1
Complex expm1(const Complex &x)
Definition: lo-specfun.cc:1835
log1p
Complex log1p(const Complex &x)
Definition: lo-specfun.cc:1919
cbrt
double cbrt(double x)
Definition: lo-specfun.h:289
asinh
double asinh(double x)
Definition: lo-specfun.h:58
atanh
double atanh(double x)
Definition: lo-specfun.h:63
acosh
double acosh(double x)
Definition: lo-specfun.h:40
lgamma
double lgamma(double x)
Definition: lo-specfun.h:336
float_format
float_format
Definition: mach-info.h:38
m
T octave_idx_type m
Definition: mx-inlines.cc:781
n
octave_idx_type n
Definition: mx-inlines.cc:761
r
T * r
Definition: mx-inlines.cc:781
mxClassID
mxClassID
Definition: mxtypes.h:57
mxUNKNOWN_CLASS
@ mxUNKNOWN_CLASS
Definition: mxtypes.h:58
mxComplexity
mxComplexity
Definition: mxtypes.h:79
mxREAL
@ mxREAL
Definition: mxtypes.h:80
Faddeeva::erfc
std::complex< double > erfc(std::complex< double > z, double relerr=0)
Faddeeva::erfcx
std::complex< double > erfcx(std::complex< double > z, double relerr=0)
Faddeeva::erfi
std::complex< double > erfi(std::complex< double > z, double relerr=0)
Faddeeva::erf
std::complex< double > erf(std::complex< double > z, double relerr=0)
Complex
std::complex< double > Complex
Definition: oct-cmplx.h:33
FloatComplex
std::complex< float > FloatComplex
Definition: oct-cmplx.h:34
octave_hdf5_id
int64_t octave_hdf5_id
Definition: oct-hdf5-types.h:45
sortmode
sortmode
Definition: oct-sort.h:97
UNSORTED
@ UNSORTED
Definition: oct-sort.h:97
ASCENDING
@ ASCENDING
Definition: oct-sort.h:97
ra_idx
const octave_base_value const Array< octave_idx_type > & ra_idx
Definition: op-int-concat.cc:170
octave_value
return octave_value(v1.char_array_value() . concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string()) ? '\'' :'"'))
builtin_type_t
builtin_type_t
Definition: ov-base.h:83
op_ne
octave_value op_ne(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1676
op_el_ldiv
octave_value op_el_ldiv(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1681
op_uplus
octave_value op_uplus(const octave_value &a)
Definition: ov.h:1634
op_add
octave_value op_add(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1663
op_gt
octave_value op_gt(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1675
op_uminus
octave_value op_uminus(const octave_value &a)
Definition: ov.h:1635
op_el_div
octave_value op_el_div(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1679
DEF_DUMMY_VALUE_EXTRACTOR
#define DEF_DUMMY_VALUE_EXTRACTOR(VALUE, DEFVAL)
Definition: ov.h:1773
op_mul_herm
octave_value op_mul_herm(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1697
op_transpose
octave_value op_transpose(const octave_value &a)
Definition: ov.h:1637
op_el_or
octave_value op_el_or(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1683
op_sub
octave_value op_sub(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1664
op_mul
octave_value op_mul(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1665
colon_op
octave_value colon_op(const octave_value &base, const octave_value &increment, const octave_value &limit, bool is_for_cmd_expr=false)
install_types
void install_types(octave::type_info &)
op_hermitian
octave_value op_hermitian(const octave_value &a)
Definition: ov.h:1638
OV_COMP_BINOP_FN
#define OV_COMP_BINOP_FN(name)
Definition: ov.h:1687
op_le
octave_value op_le(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1672
op_el_and
octave_value op_el_and(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1682
cat_op
octave_value cat_op(type_info &ti, const octave_value &a, const octave_value &b, const Array< octave_idx_type > &ra_idx)
binary_op
octave_value binary_op(type_info &ti, octave_value::binary_op op, const octave_value &a, const octave_value &b)
op_herm_mul
octave_value op_herm_mul(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1696
MAPPER_FORWARD
#define MAPPER_FORWARD(F)
Definition: ov.h:1441
op_eq
octave_value op_eq(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1673
op_el_pow
octave_value op_el_pow(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1680
OV_UNOP_FN_OP
#define OV_UNOP_FN_OP(name, op)
Definition: ov.h:1629
DEF_VALUE_EXTRACTOR
#define DEF_VALUE_EXTRACTOR(VALUE, MPREFIX)
Definition: ov.h:1708
op_struct_ref
octave_value op_struct_ref(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1685
op_not
octave_value op_not(const octave_value &a)
Definition: ov.h:1633
OV_BINOP_FN
#define OV_BINOP_FN(name)
Definition: ov.h:1645
op_ldiv
octave_value op_ldiv(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1669
OV_UNOP_FN
#define OV_UNOP_FN(name)
Definition: ov.h:1615
octave_value_extract
Value octave_value_extract(const octave_value &)
Definition: ov.h:1705
unary_op
octave_value unary_op(type_info &ti, octave_value::unary_op op, const octave_value &a)
op_pow
octave_value op_pow(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1668
op_ge
octave_value op_ge(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1674
op_el_mul
octave_value op_el_mul(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1678
op_div
octave_value op_div(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1666
op_trans_mul
octave_value op_trans_mul(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1694
op_mul_trans
octave_value op_mul_trans(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1695
OV_BINOP_FN_OP
#define OV_BINOP_FN_OP(name, op)
Definition: ov.h:1659
op_lt
octave_value op_lt(const octave_value &a1, const octave_value &a2)
Definition: ov.h:1671