d1/d0b/ov_8h_source.html

////////////////////////////////////////////////////////////////////////

//

// Copyright (C) 1996-2025 The Octave Project Developers

//

// See the file COPYRIGHT.md in the top-level directory of this

// distribution or <https://octave.org/copyright/>.

//

// This file is part of Octave.

//

// Octave is free software: you can redistribute it and/or modify it

// under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Octave is distributed in the hope that it will be useful, but

// WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Octave; see the file COPYING.  If not, see

// <https://www.gnu.org/licenses/>.

//

////////////////////////////////////////////////////////////////////////


#if ! defined (octave_ov_h)

#define octave_ov_h 1


#include "octave-config.h"


#include <cstdlib>


#include <iosfwd>

#include <string>

#include <list>

#include <memory>

#include <map>


#include "panic.h"


#include "data-conv.h"

#include "idx-vector.h"

#include "mach-info.h"

#include "mx-base.h"

#include "oct-sort.h"

#include "oct-time.h"

#include "str-vec.h"


OCTAVE_BEGIN_NAMESPACE(octave)


class stack_frame;

class type_info;

class scope_stack_frame;

class base_value_stack_frame;


OCTAVE_END_NAMESPACE(octave)


class Cell;

class float_format;

class mxArray;

class octave_map;

class octave_scalar_map;

class octave_function;

class octave_user_function;

class octave_fcn_handle;

class octave_value_list;

class octave_fcn_cache;


#include "mxtypes.h"


#include "oct-stream.h"

#include "ov-base.h"


class OCTINTERP_API octave_value

{

public:


  enum unary_op

  {

    op_not,            // not

    op_uplus,          // uplus

    op_uminus,         // uminus

    op_transpose,      // transpose

    op_hermitian,      // ctranspose

    op_incr,

    op_decr,

    num_unary_ops,

    unknown_unary_op

  };


  enum binary_op

  {

    op_add,            // plus

    op_sub,            // minus

    op_mul,            // mtimes

    op_div,            // mrdivide

    op_pow,            // mpower

    op_ldiv,           // mldivide

    op_lt,             // lt

    op_le,             // le

    op_eq,             // eq

    op_ge,             // ge

    op_gt,             // gt

    op_ne,             // ne

    op_el_mul,         // times

    op_el_div,         // rdivide

    op_el_pow,         // power

    op_el_ldiv,        // ldivide

    op_el_and,         // and

    op_el_or,          // or

    op_struct_ref,

    num_binary_ops,

    unknown_binary_op

  };


  enum compound_binary_op

  {

    // ** compound operations **

    op_trans_mul,

    op_mul_trans,

    op_herm_mul,

    op_mul_herm,

    op_trans_ldiv,

    op_herm_ldiv,

    op_el_not_and,

    op_el_not_or,

    op_el_and_not,

    op_el_or_not,

    num_compound_binary_ops,

    unknown_compound_binary_op

  };


  enum assign_op

  {

    op_asn_eq,

    op_add_eq,

    op_sub_eq,

    op_mul_eq,

    op_div_eq,

    op_ldiv_eq,

    op_pow_eq,

    op_el_mul_eq,

    op_el_div_eq,

    op_el_ldiv_eq,

    op_el_pow_eq,

    op_el_and_eq,

    op_el_or_eq,

    num_assign_ops,

    unknown_assign_op

  };


  static OCTINTERP_API binary_op assign_op_to_binary_op (assign_op);


  static OCTINTERP_API assign_op binary_op_to_assign_op (binary_op);


  static OCTINTERP_API std::string unary_op_as_string (unary_op);

  static OCTINTERP_API std::string unary_op_fcn_name (unary_op);


  static OCTINTERP_API std::string binary_op_as_string (binary_op);

  static OCTINTERP_API std::string binary_op_fcn_name (binary_op);


  static OCTINTERP_API std::string binary_op_fcn_name (compound_binary_op);


  static OCTINTERP_API std::string assign_op_as_string (assign_op);


  static OCTINTERP_API octave_value

  empty_conv (const std::string& type,

              const octave_value& rhs = octave_value ());


  enum magic_colon { magic_colon_t };


  octave_value ()

    : m_rep (nil_rep ())

  {

    m_rep->m_count++;

  }


  OCTINTERP_API octave_value (short int i);

  OCTINTERP_API octave_value (unsigned short int i);

  OCTINTERP_API octave_value (int i);

  OCTINTERP_API octave_value (unsigned int i);

  OCTINTERP_API octave_value (long int i);

  OCTINTERP_API octave_value (unsigned long int i);


  // FIXME: These are kluges.  They turn into doubles internally, which will

  // break for very large values.  We just use them to store things like

  // 64-bit ino_t, etc, and hope that those values are never actually larger

  // than can be represented exactly in a double.


#if defined (OCTAVE_HAVE_LONG_LONG_INT)

  OCTINTERP_API octave_value (long long int i);

#endif

#if defined (OCTAVE_HAVE_UNSIGNED_LONG_LONG_INT)

  OCTINTERP_API octave_value (unsigned long long int i);

#endif


  OCTINTERP_API octave_value (octave::sys::time t);

  OCTINTERP_API octave_value (double d);

  OCTINTERP_API octave_value (float d);

  OCTINTERP_API octave_value (const Array<octave_value>& a,

                              bool is_cs_list = false);

  OCTINTERP_API octave_value (const Cell& c, bool is_cs_list = false);

  OCTINTERP_API octave_value (const Matrix& m,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const FloatMatrix& m,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const NDArray& nda);

  OCTINTERP_API octave_value (const FloatNDArray& nda);

  OCTINTERP_API octave_value (const Array<double>& m);

  OCTINTERP_API octave_value (const Array<float>& m);

  OCTINTERP_API octave_value (const DiagMatrix& d);

  OCTINTERP_API octave_value (const DiagArray2<double>& d);

  OCTINTERP_API octave_value (const DiagArray2<float>& d);

  OCTINTERP_API octave_value (const DiagArray2<Complex>& d);

  OCTINTERP_API octave_value (const DiagArray2<FloatComplex>& d);

  OCTINTERP_API octave_value (const FloatDiagMatrix& d);

  OCTINTERP_API octave_value (const RowVector& v);

  OCTINTERP_API octave_value (const FloatRowVector& v);

  OCTINTERP_API octave_value (const ColumnVector& v);

  OCTINTERP_API octave_value (const FloatColumnVector& v);

  OCTINTERP_API octave_value (const Complex& C);

  OCTINTERP_API octave_value (const FloatComplex& C);

  OCTINTERP_API octave_value (const ComplexMatrix& m,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const FloatComplexMatrix& m,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const ComplexNDArray& cnda);

  OCTINTERP_API octave_value (const FloatComplexNDArray& cnda);

  OCTINTERP_API octave_value (const Array<Complex>& m);

  OCTINTERP_API octave_value (const Array<FloatComplex>& m);

  OCTINTERP_API octave_value (const ComplexDiagMatrix& d);

  OCTINTERP_API octave_value (const FloatComplexDiagMatrix& d);

  OCTINTERP_API octave_value (const ComplexRowVector& v);

  OCTINTERP_API octave_value (const FloatComplexRowVector& v);

  OCTINTERP_API octave_value (const ComplexColumnVector& v);

  OCTINTERP_API octave_value (const FloatComplexColumnVector& v);

  OCTINTERP_API octave_value (const PermMatrix& p);

  OCTINTERP_API octave_value (bool b);

  OCTINTERP_API octave_value (const boolMatrix& bm,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const boolNDArray& bnda);

  OCTINTERP_API octave_value (const Array<bool>& bnda);

  OCTINTERP_API octave_value (char c, char type = '\'');

  OCTINTERP_API octave_value (const char *s, char type = '\'');

  OCTINTERP_API octave_value (const std::string& s, char type = '\'');

  OCTINTERP_API octave_value (const string_vector& s, char type = '\'');

  OCTINTERP_API octave_value (const charMatrix& chm,  char type = '\'');

  OCTINTERP_API octave_value (const charNDArray& chnda, char type = '\'');

  OCTINTERP_API octave_value (const Array<char>& chnda, char type = '\'');


  OCTINTERP_API octave_value (const SparseMatrix& m,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const Sparse<double>& m,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const SparseComplexMatrix& m,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const Sparse<Complex>& m,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const SparseBoolMatrix& bm,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const Sparse<bool>& m,

                              const MatrixType& t = MatrixType ());

  OCTINTERP_API octave_value (const octave_int8& i);

  OCTINTERP_API octave_value (const octave_int16& i);

  OCTINTERP_API octave_value (const octave_int32& i);

  OCTINTERP_API octave_value (const octave_int64& i);

  OCTINTERP_API octave_value (const octave_uint8& i);

  OCTINTERP_API octave_value (const octave_uint16& i);

  OCTINTERP_API octave_value (const octave_uint32& i);

  OCTINTERP_API octave_value (const octave_uint64& i);

  OCTINTERP_API octave_value (const int8NDArray& inda);

  OCTINTERP_API octave_value (const Array<octave_int8>& inda);

  OCTINTERP_API octave_value (const int16NDArray& inda);

  OCTINTERP_API octave_value (const Array<octave_int16>& inda);

  OCTINTERP_API octave_value (const int32NDArray& inda);

  OCTINTERP_API octave_value (const Array<octave_int32>& inda);

  OCTINTERP_API octave_value (const int64NDArray& inda);

  OCTINTERP_API octave_value (const Array<octave_int64>& inda);

  OCTINTERP_API octave_value (const uint8NDArray& inda);

  OCTINTERP_API octave_value (const Array<octave_uint8>& inda);

  OCTINTERP_API octave_value (const uint16NDArray& inda);

  OCTINTERP_API octave_value (const Array<octave_uint16>& inda);

  OCTINTERP_API octave_value (const uint32NDArray& inda);

  OCTINTERP_API octave_value (const Array<octave_uint32>& inda);

  OCTINTERP_API octave_value (const uint64NDArray& inda);

  OCTINTERP_API octave_value (const Array<octave_uint64>& inda);

  OCTINTERP_API octave_value (const Array<octave_idx_type>& inda,

                              bool zero_based = false,

                              bool cache_index = false);

  OCTINTERP_API octave_value (const Array<std::string>& cellstr);

  OCTINTERP_API octave_value (const octave::idx_vector& idx, bool lazy = true);


  OCTINTERP_API octave_value (const octave::range<double>& r,

                              bool force_range = false);


  // For now, enable only range<double>.


  OCTINTERP_API octave_value (const octave_map& m);

  OCTINTERP_API octave_value (const octave_scalar_map& m);

  OCTINTERP_API octave_value (const std::map<std::string, octave_value>&);

  OCTINTERP_API octave_value (const octave_map& m, const std::string& id,

                              const std::list<std::string>& plist);

  OCTINTERP_API octave_value (const octave_scalar_map& m, const std::string& id,

                              const std::list<std::string>& plist);


  // This one is explicit because it can cause some trouble to

  // accidentally create a cs-list when one was not intended.

  explicit OCTINTERP_API octave_value (const octave_value_list& m);


  OCTINTERP_API octave_value (octave_value::magic_colon);


  octave_value (octave_base_value *new_rep, bool borrow = false)

    : m_rep (new_rep)

  {

    if (borrow)

      m_rep->m_count++;

  }


  // Copy constructor.


  octave_value (const octave_value& a)

    : m_rep (a.m_rep)

  {

    m_rep->m_count++;

  }


  octave_value (octave_value&& a)

    : m_rep (a.m_rep)

  {

    a.m_rep = nullptr;

  }


  // This should only be called for derived types.


  OCTINTERP_API octave_base_value * clone () const;


  octave_base_value * empty_clone () const

  { return m_rep->empty_clone (); }


  // Delete the representation of this constant if the count drops to zero.


  ~octave_value ()

  {

    // Because we define a move constructor and a move assignment

    // operator, rep may be a nullptr here.  We should only need to

    // protect the move assignment operator in a similar way.


    if (m_rep && --m_rep->m_count == 0 && m_rep != nil_rep ())

      delete m_rep;

  }


  void make_unique ()

  {

    if (m_rep->m_count > 1)

      {

        octave_base_value *r = m_rep->unique_clone ();


        if (--m_rep->m_count == 0 && m_rep != nil_rep ())

          delete m_rep;


        m_rep = r;

      }

  }


  // This uniquifies the value if it is referenced by more than a certain

  // number of shallow copies.  This is useful for optimizations where we

  // know a certain copy, typically within a cell array, to be obsolete.


  void make_unique (int obsolete_copies)

  {

    if (m_rep->m_count > obsolete_copies + 1)

      {

        octave_base_value *r = m_rep->unique_clone ();


        if (--m_rep->m_count == 0 && m_rep != nil_rep ())

          delete m_rep;


        m_rep = r;

      }

  }


  // Convert any nested function handles in this object to use weak

  // references to their enclosing stack frame context.  Used to break

  // shared_ptr reference cycles for handles to nested functions

  // (closures).

  void break_closure_cycles (const std::shared_ptr<octave::stack_frame>&);


  // Simple assignment.


  octave_value& operator = (const octave_value& a)

  {

    if (m_rep != a.m_rep)

      {

        if (--m_rep->m_count == 0 && m_rep != nil_rep ())

          delete m_rep;


        m_rep = a.m_rep;

        m_rep->m_count++;

      }


    return *this;

  }


  octave_value& operator = (octave_value&& a)

  {

    // Because we define a move constructor and a move assignment

    // operator, rep may be a nullptr here.  We should only need to

    // protect the destructor in a similar way.


    if (this != &a)

      {

        if (m_rep && --m_rep->m_count == 0 && m_rep != nil_rep ())

          delete m_rep;


        m_rep = a.m_rep;

        a.m_rep = nullptr;

      }


    return *this;

  }


  octave_idx_type get_count () const { return m_rep->m_count; }


  octave_base_value::type_conv_info numeric_conversion_function () const

  { return m_rep->numeric_conversion_function (); }


  octave_base_value::type_conv_info numeric_demotion_function () const

  { return m_rep->numeric_demotion_function (); }


  OCTINTERP_API void maybe_mutate ();


  octave_value squeeze () const

  { return m_rep->squeeze (); }


  // The result of full().


  octave_value full_value () const

  { return m_rep->full_value (); }


  // Type conversions.


  // Returns a copy of a scalar (double), or makes a scalar

  // for other types.


  octave_value as_double_or_copy () const

  { return m_rep->as_double_or_copy (); }


  octave_value as_double () const { return m_rep->as_double (); }

  octave_value as_single () const { return m_rep->as_single (); }


  octave_value as_int8 () const { return m_rep->as_int8 (); }

  octave_value as_int16 () const { return m_rep->as_int16 (); }

  octave_value as_int32 () const { return m_rep->as_int32 (); }

  octave_value as_int64 () const { return m_rep->as_int64 (); }


  octave_value as_uint8 () const { return m_rep->as_uint8 (); }

  octave_value as_uint16 () const { return m_rep->as_uint16 (); }

  octave_value as_uint32 () const { return m_rep->as_uint32 (); }

  octave_value as_uint64 () const { return m_rep->as_uint64 (); }


  octave_base_value * try_narrowing_conversion ()

  { return m_rep->try_narrowing_conversion (); }


  // Close to dims (), but can be overloaded for classes.


  Matrix size ()

  { return m_rep->size (); }


  // FIXME: should this function be deprecated and removed?  It supports

  // an undocumented feature of Matlab.


  octave_idx_type xnumel (const octave_value_list& idx)

  { return m_rep->xnumel (idx); }


  // FIXME: Do we really need all these different versions of subsref

  // and related functions?


  OCTINTERP_API octave_value

  single_subsref (const std::string& type, const octave_value_list& idx);


  octave_value subsref (const std::string& type,

                        const std::list<octave_value_list>& idx)

  { return m_rep->subsref (type, idx); }


  octave_value subsref (const std::string& type,

                        const std::list<octave_value_list>& idx,

                        bool auto_add)

  { return m_rep->subsref (type, idx, auto_add); }


  OCTINTERP_API octave_value_list

  subsref (const std::string& type, const std::list<octave_value_list>& idx,

           int nargout);


  octave_value_list

  simple_subsref (char type, octave_value_list& idx, int nargout);


  OCTINTERP_API octave_value

  next_subsref (const std::string& type,

                const std::list<octave_value_list>& idx, std::size_t skip = 1);


  OCTINTERP_API octave_value_list

  next_subsref (int nargout, const std::string& type,

                const std::list<octave_value_list>& idx, std::size_t skip = 1);


  OCTINTERP_API 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 index_op (const octave_value_list& idx, bool resize_ok = false)

  {

    return m_rep->do_index_op (idx, resize_ok);

  }


  OCTINTERP_API octave_idx_type

  end_index (octave_idx_type index_position,

             octave_idx_type num_indices) const;


  OCTINTERP_API octave_value

  subsasgn (const std::string& type, const std::list<octave_value_list>& idx,

            const octave_value& rhs);


  octave_value


  simple_subsasgn (char type, octave_value_list& idx, const octave_value& rhs)

  {

    return m_rep->simple_subsasgn (type, idx, rhs);

  }


  OCTINTERP_API octave_value

  undef_subsasgn (const std::string& type,

                  const std::list<octave_value_list>& idx,

                  const octave_value& rhs);


  OCTINTERP_API octave_value&

  assign (assign_op op, const std::string& type,

          const std::list<octave_value_list>& idx, const octave_value& rhs);


  OCTINTERP_API octave_value& assign (assign_op, const octave_value& rhs);


  octave::idx_vector index_vector (bool require_integers = false) const

  {

    return m_rep->index_vector (require_integers);

  }


  // Size.


  dim_vector dims () const { return m_rep->dims (); }


  OCTINTERP_API std::string get_dims_str () const;


  octave_idx_type rows () const { return m_rep->rows (); }


  octave_idx_type columns () const { return m_rep->columns (); }


  OCTINTERP_API octave_idx_type length () const;


  int ndims () const { return m_rep->ndims (); }


  bool all_zero_dims () const { return dims ().all_zero (); }


  // Are the dimensions of this constant zero by zero?


  bool is_zero_by_zero () const

  { return (ndims () == 2 && rows () == 0 && columns () == 0); }


  octave_idx_type numel () const

  { return m_rep->numel (); }


  std::size_t byte_size () const

  { return m_rep->byte_size (); }


  octave_idx_type nnz () const { return m_rep->nnz (); }


  octave_idx_type nzmax () const { return m_rep->nzmax (); }


  octave_idx_type nfields () const { return m_rep->nfields (); }


  octave_value reshape (const dim_vector& dv) const

  { return m_rep->reshape (dv); }


  octave_value permute (const Array<int>& vec, bool inv = false) const

  { return m_rep->permute (vec, inv); }


  octave_value ipermute (const Array<int>& vec) const

  { return m_rep->permute (vec, true); }


  octave_value resize (const dim_vector& dv, bool fill = false) const

  { return m_rep->resize (dv, fill);}


  MatrixType matrix_type () const

  { return m_rep->matrix_type (); }


  MatrixType matrix_type (const MatrixType& typ) const

  { return m_rep->matrix_type (typ); }


  // Does this constant have a type?  Both of these are provided since it is

  // sometimes more natural to write is_undefined() instead of ! is_defined().


  bool is_defined () const

  { return m_rep->is_defined (); }


  bool is_undefined () const

  { return ! is_defined (); }


  bool is_legacy_object () const

  { return m_rep->is_legacy_object (); }


  bool isempty () const

  { return m_rep->isempty (); }


  bool iscell () const

  { return m_rep->iscell (); }


  bool iscellstr () const

  { return m_rep->iscellstr (); }


  bool is_real_scalar () const

  { return m_rep->is_real_scalar (); }


  bool is_real_matrix () const

  { return m_rep->is_real_matrix (); }


  bool is_complex_scalar () const

  { return m_rep->is_complex_scalar (); }


  bool is_complex_matrix () const

  { return m_rep->is_complex_matrix (); }


  bool is_bool_scalar () const

  { return m_rep->is_bool_scalar (); }


  bool is_bool_matrix () const

  { return m_rep->is_bool_matrix (); }


  bool is_char_matrix () const

  { return m_rep->is_char_matrix (); }


  bool is_diag_matrix () const

  { return m_rep->is_diag_matrix (); }


  bool is_perm_matrix () const

  { return m_rep->is_perm_matrix (); }


  bool is_string () const

  { return m_rep->is_string (); }


  bool is_sq_string () const

  { return m_rep->is_sq_string (); }


  bool is_dq_string () const

  { return m_rep->is_string () && ! m_rep->is_sq_string (); }


  bool is_range () const

  { return m_rep->is_range (); }


  bool isstruct () const

  { return m_rep->isstruct (); }


  bool is_classdef_meta () const

  { return m_rep->is_classdef_meta (); }


  bool is_classdef_object () const

  { return m_rep->is_classdef_object (); }


  bool is_classdef_superclass_ref () const

  { return m_rep->is_classdef_superclass_ref (); }


  bool is_package () const

  { return m_rep->is_package (); }


  bool isobject () const

  { return m_rep->isobject (); }


  bool isjava () const

  { return m_rep->isjava (); }


  bool is_cs_list () const

  { return m_rep->is_cs_list (); }


  bool is_magic_colon () const

  { return m_rep->is_magic_colon (); }


  bool is_magic_int () const

  { return m_rep->is_magic_int (); }


  bool isnull () const

  { return m_rep->isnull (); }


  // Are any or all of the elements in this constant nonzero?


  octave_value all (int dim = 0) const

  { return m_rep->all (dim); }


  octave_value any (int dim = 0) const

  { return m_rep->any (dim); }


  builtin_type_t builtin_type () const

  { return m_rep->builtin_type (); }


  // Floating point types.


  bool is_double_type () const

  { return m_rep->is_double_type (); }


  bool is_single_type () const

  { return m_rep->is_single_type (); }


  bool isfloat () const

  { return m_rep->isfloat (); }


  // Integer types.


  bool is_int8_type () const

  { return m_rep->is_int8_type (); }


  bool is_int16_type () const

  { return m_rep->is_int16_type (); }


  bool is_int32_type () const

  { return m_rep->is_int32_type (); }


  bool is_int64_type () const

  { return m_rep->is_int64_type (); }


  bool is_uint8_type () const

  { return m_rep->is_uint8_type (); }


  bool is_uint16_type () const

  { return m_rep->is_uint16_type (); }


  bool is_uint32_type () const

  { return m_rep->is_uint32_type (); }


  bool is_uint64_type () const

  { return m_rep->is_uint64_type (); }


  bool isinteger () const

  { return m_rep->isinteger (); }


  // Other type stuff.


  bool islogical () const

  { return m_rep->islogical (); }


  bool isreal () const

  { return m_rep->isreal (); }


  bool iscomplex () const

  { return m_rep->iscomplex (); }


  bool is_scalar_type () const

  { return m_rep->is_scalar_type (); }


  bool is_matrix_type () const

  { return m_rep->is_matrix_type (); }


  bool isnumeric () const

  { return m_rep->isnumeric (); }


  bool issparse () const

  { return m_rep->issparse (); }


  // Does this constant correspond to a truth value?


  bool is_true () const

  { return m_rep->is_true (); }


  // Do two constants match (in a switch statement)?


  bool is_equal (const octave_value&) const;


  bool is_constant () const

  { return m_rep->is_constant (); }


  bool is_function_handle () const

  { return m_rep->is_function_handle (); }


  bool is_anonymous_function () const

  { return m_rep->is_anonymous_function (); }


  bool is_inline_function () const

  { return m_rep->is_inline_function (); }


  bool is_function () const

  { return m_rep->is_function (); }


  bool is_user_script () const

  { return m_rep->is_user_script (); }


  bool is_user_function () const

  { return m_rep->is_user_function (); }


  bool is_user_code () const

  { return m_rep->is_user_code (); }


  bool is_builtin_function () const

  { return m_rep->is_builtin_function (); }


  bool is_dld_function () const

  { return m_rep->is_dld_function (); }


  bool is_mex_function () const

  { return m_rep->is_mex_function (); }


  void erase_subfunctions () { m_rep->erase_subfunctions (); }


  // Values.


  octave_value eval () { return *this; }


  short int


  short_value (bool req_int = false, bool frc_str_conv = false) const

  { return m_rep->short_value (req_int, frc_str_conv); }


  unsigned short int


  ushort_value (bool req_int = false, bool frc_str_conv = false) const

  { return m_rep->ushort_value (req_int, frc_str_conv); }


  int int_value (bool req_int = false, bool frc_str_conv = false) const

  { return m_rep->int_value (req_int, frc_str_conv); }


  int strict_int_value (bool frc_str_conv = false) const

  { return m_rep->int_value (true, frc_str_conv); }


  unsigned int


  uint_value (bool req_int = false, bool frc_str_conv = false) const

  { return m_rep->uint_value (req_int, frc_str_conv); }


  int nint_value (bool frc_str_conv = false) const

  { return m_rep->nint_value (frc_str_conv); }


  long int


  long_value (bool req_int = false, bool frc_str_conv = false) const

  { return m_rep->long_value (req_int, frc_str_conv); }


  unsigned long int


  ulong_value (bool req_int = false, bool frc_str_conv = false) const

  { return m_rep->ulong_value (req_int, frc_str_conv); }


  int64_t


  int64_value (bool req_int = false, bool frc_str_conv = false) const

  { return m_rep->int64_value (req_int, frc_str_conv); }


  uint64_t


  uint64_value (bool req_int = false, bool frc_str_conv = false) const

  { return m_rep->uint64_value (req_int, frc_str_conv); }


  octave_idx_type

  idx_type_value (bool req_int = false, bool frc_str_conv = false) const;


  octave_idx_type

  strict_idx_type_value (bool frc_str_conv = false) const;


  double double_value (bool frc_str_conv = false) const

  { return m_rep->double_value (frc_str_conv); }


  float float_value (bool frc_str_conv = false) const

  { return m_rep->float_value (frc_str_conv); }


  double scalar_value (bool frc_str_conv = false) const

  { return m_rep->scalar_value (frc_str_conv); }


  float float_scalar_value (bool frc_str_conv = false) const

  { return m_rep->float_scalar_value (frc_str_conv); }


  Matrix matrix_value (bool frc_str_conv = false) const

  { return m_rep->matrix_value (frc_str_conv); }


  FloatMatrix float_matrix_value (bool frc_str_conv = false) const

  { return m_rep->float_matrix_value (frc_str_conv); }


  NDArray array_value (bool frc_str_conv = false) const

  { return m_rep->array_value (frc_str_conv); }


  FloatNDArray float_array_value (bool frc_str_conv = false) const

  { return m_rep->float_array_value (frc_str_conv); }


  Complex complex_value (bool frc_str_conv = false) const

  { return m_rep->complex_value (frc_str_conv); }


  FloatComplex float_complex_value (bool frc_str_conv = false) const

  { return m_rep->float_complex_value (frc_str_conv); }


  ComplexMatrix complex_matrix_value (bool frc_str_conv = false) const

  { return m_rep->complex_matrix_value (frc_str_conv); }


  FloatComplexMatrix


  float_complex_matrix_value (bool frc_str_conv = false) const

  { return m_rep->float_complex_matrix_value (frc_str_conv); }


  ComplexNDArray complex_array_value (bool frc_str_conv = false) const

  { return m_rep->complex_array_value (frc_str_conv); }


  FloatComplexNDArray


  float_complex_array_value (bool frc_str_conv = false) const

  { return m_rep->float_complex_array_value (frc_str_conv); }


  bool bool_value (bool warn = false) const

  { return m_rep->bool_value (warn); }


  bool strict_bool_value () const

  { return m_rep->bool_value (true); }


  boolMatrix bool_matrix_value (bool warn = false) const

  { return m_rep->bool_matrix_value (warn); }


  boolNDArray bool_array_value (bool warn = false) const

  { return m_rep->bool_array_value (warn); }


  charMatrix char_matrix_value (bool frc_str_conv = false) const

  { return m_rep->char_matrix_value (frc_str_conv); }


  charNDArray char_array_value (bool frc_str_conv = false) const

  { return m_rep->char_array_value (frc_str_conv); }


  SparseMatrix sparse_matrix_value (bool frc_str_conv = false) const

  { return m_rep->sparse_matrix_value (frc_str_conv); }


  SparseComplexMatrix


  sparse_complex_matrix_value (bool frc_str_conv = false) const

  { return m_rep->sparse_complex_matrix_value (frc_str_conv); }


  SparseBoolMatrix sparse_bool_matrix_value (bool warn = false) const

  { return m_rep->sparse_bool_matrix_value (warn); }


  DiagMatrix diag_matrix_value (bool force = false) const

  { return m_rep->diag_matrix_value (force); }


  FloatDiagMatrix float_diag_matrix_value (bool force = false) const

  { return m_rep->float_diag_matrix_value (force); }


  ComplexDiagMatrix complex_diag_matrix_value (bool force = false) const

  { return m_rep->complex_diag_matrix_value (force); }


  FloatComplexDiagMatrix


  float_complex_diag_matrix_value (bool force = false) const

  { return m_rep->float_complex_diag_matrix_value (force); }


  PermMatrix perm_matrix_value () const

  { return m_rep->perm_matrix_value (); }


  octave_int8 int8_scalar_value () const

  { return m_rep->int8_scalar_value (); }


  octave_int16 int16_scalar_value () const

  { return m_rep->int16_scalar_value (); }


  octave_int32 int32_scalar_value () const

  { return m_rep->int32_scalar_value (); }


  octave_int64 int64_scalar_value () const

  { return m_rep->int64_scalar_value (); }


  octave_uint8 uint8_scalar_value () const

  { return m_rep->uint8_scalar_value (); }


  octave_uint16 uint16_scalar_value () const

  { return m_rep->uint16_scalar_value (); }


  octave_uint32 uint32_scalar_value () const

  { return m_rep->uint32_scalar_value (); }


  octave_uint64 uint64_scalar_value () const

  { return m_rep->uint64_scalar_value (); }


  int8NDArray int8_array_value () const

  { return m_rep->int8_array_value (); }


  int16NDArray int16_array_value () const

  { return m_rep->int16_array_value (); }


  int32NDArray int32_array_value () const

  { return m_rep->int32_array_value (); }


  int64NDArray int64_array_value () const

  { return m_rep->int64_array_value (); }


  uint8NDArray uint8_array_value () const

  { return m_rep->uint8_array_value (); }


  uint16NDArray uint16_array_value () const

  { return m_rep->uint16_array_value (); }


  uint32NDArray uint32_array_value () const

  { return m_rep->uint32_array_value (); }


  uint64NDArray uint64_array_value () const

  { return m_rep->uint64_array_value (); }


  std::string string_value (bool force = false) const

  { return m_rep->string_value (force); }


  string_vector string_vector_value (bool pad = false) const

  { return m_rep->string_vector_value (pad); }


  Cell cell_value () const;


  Array<std::string> cellstr_value () const

  { return m_rep->cellstr_value (); }


  octave::range<double> range_value () const

  { return m_rep->range_value (); }


  // For now, enable only range<double>.


  OCTINTERP_API octave_map map_value () const;


  OCTINTERP_API octave_scalar_map scalar_map_value () const;


  string_vector map_keys () const

  { return m_rep->map_keys (); }


  bool isfield (const std::string& field_name) const

  { return m_rep->isfield (field_name); }


  std::size_t nparents () const

  { return m_rep->nparents (); }


  std::list<std::string> parent_class_name_list () const

  { return m_rep->parent_class_name_list (); }


  string_vector parent_class_names () const

  { return m_rep->parent_class_names (); }


  octave_base_value *


  find_parent_class (const std::string& parent_class_name)

  { return m_rep->find_parent_class (parent_class_name); }


  bool is_instance_of (const std::string& cls_name) const

  { return m_rep->is_instance_of (cls_name); }


  OCTINTERP_API octave_classdef *

  classdef_object_value (bool silent = false) const;


  OCTINTERP_API octave_function *

  function_value (bool silent = false) const;


  OCTINTERP_API octave_user_function *

  user_function_value (bool silent = false) const;


  OCTINTERP_API octave_user_script *

  user_script_value (bool silent = false) const;


  OCTINTERP_API octave_user_code * user_code_value (bool silent = false) const;


  OCTINTERP_API octave_fcn_handle *

  fcn_handle_value (bool silent = false) const;


  OCTINTERP_API octave_value_list list_value () const;


  OCTINTERP_API ColumnVector

  column_vector_value (bool frc_str_conv = false,

                       bool frc_vec_conv = false) const;


  OCTINTERP_API ComplexColumnVector

  complex_column_vector_value (bool frc_str_conv = false,

                               bool frc_vec_conv = false) const;


  OCTINTERP_API RowVector

  row_vector_value (bool frc_str_conv = false,

                    bool frc_vec_conv = false) const;


  OCTINTERP_API ComplexRowVector

  complex_row_vector_value (bool frc_str_conv = false,

                            bool frc_vec_conv = false) const;


  OCTINTERP_API FloatColumnVector

  float_column_vector_value (bool frc_str_conv = false,

                             bool frc_vec_conv = false) const;


  OCTINTERP_API FloatComplexColumnVector

  float_complex_column_vector_value (bool frc_str_conv = false,

                                     bool frc_vec_conv = false) const;


  OCTINTERP_API FloatRowVector

  float_row_vector_value (bool frc_str_conv = false,

                          bool frc_vec_conv = false) const;


  OCTINTERP_API FloatComplexRowVector

  float_complex_row_vector_value (bool frc_str_conv = false,

                                  bool frc_vec_conv = false) const;


  OCTINTERP_API Array<int>

  int_vector_value (bool req_int = false,

                    bool frc_str_conv = false,

                    bool frc_vec_conv = false) const;


  OCTINTERP_API Array<octave_idx_type>

  octave_idx_type_vector_value (bool req_int = false,

                                bool frc_str_conv = false,

                                bool frc_vec_conv = false) const;


  OCTINTERP_API Array<double>

  vector_value (bool frc_str_conv = false,

                bool frc_vec_conv = false) const;


  OCTINTERP_API Array<Complex>

  complex_vector_value (bool frc_str_conv = false,

                        bool frc_vec_conv = false) const;


  OCTINTERP_API Array<float>

  float_vector_value (bool frc_str_conv = false,

                      bool frc_vec_conv = false) const;


  OCTINTERP_API Array<FloatComplex>

  float_complex_vector_value (bool frc_str_conv = false,

                              bool frc_vec_conv = false) const;


  // Extract values of specific types without any implicit type conversions.

  // Throw an error if an object is the wrong type for the requested value

  // extraction.

  //

  // These functions are intended to provide a simple way to extract values of

  // specific types and display error messages that are more meaningful than

  // the generic "error: wrong type argument 'cell'" message.


  OCTINTERP_API short int xshort_value (const char *fmt, ...) const;


  OCTINTERP_API unsigned short int xushort_value (const char *fmt, ...) const;


  OCTINTERP_API int xint_value (const char *fmt, ...) const;


  OCTINTERP_API int strict_int_value (const char *fmt, ...) const;


  OCTINTERP_API unsigned int xuint_value (const char *fmt, ...) const;


  OCTINTERP_API int xnint_value (const char *fmt, ...) const;


  OCTINTERP_API long int xlong_value (const char *fmt, ...) const;


  OCTINTERP_API unsigned long int xulong_value (const char *fmt, ...) const;


  OCTINTERP_API int64_t xint64_value (const char *fmt, ...) const;


  OCTINTERP_API uint64_t xuint64_value (const char *fmt, ...) const;


  OCTINTERP_API octave_idx_type xidx_type_value (const char *fmt, ...) const;


  OCTINTERP_API octave_idx_type strict_idx_type_value (const char *fmt, ...) const;


  OCTINTERP_API double xdouble_value (const char *fmt, ...) const;


  OCTINTERP_API float xfloat_value (const char *fmt, ...) const;


  OCTINTERP_API double xscalar_value (const char *fmt, ...) const;


  OCTINTERP_API float xfloat_scalar_value (const char *fmt, ...) const;


  OCTINTERP_API Matrix xmatrix_value (const char *fmt, ...) const;


  OCTINTERP_API FloatMatrix xfloat_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API NDArray xarray_value (const char *fmt, ...) const;


  OCTINTERP_API FloatNDArray xfloat_array_value (const char *fmt, ...) const;


  OCTINTERP_API Complex xcomplex_value (const char *fmt, ...) const;


  OCTINTERP_API FloatComplex xfloat_complex_value (const char *fmt, ...) const;


  OCTINTERP_API ComplexMatrix

  xcomplex_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API FloatComplexMatrix

  xfloat_complex_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API ComplexNDArray

  xcomplex_array_value (const char *fmt, ...) const;


  OCTINTERP_API FloatComplexNDArray

  xfloat_complex_array_value (const char *fmt, ...) const;


  OCTINTERP_API bool xbool_value (const char *fmt, ...) const;


  OCTINTERP_API bool strict_bool_value (const char *fmt, ...) const;


  OCTINTERP_API boolMatrix xbool_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API boolNDArray xbool_array_value (const char *fmt, ...) const;


  OCTINTERP_API charMatrix xchar_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API charNDArray xchar_array_value (const char *fmt, ...) const;


  OCTINTERP_API SparseMatrix xsparse_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API SparseComplexMatrix

  xsparse_complex_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API SparseBoolMatrix

  xsparse_bool_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API DiagMatrix xdiag_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API FloatDiagMatrix

  xfloat_diag_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API ComplexDiagMatrix

  xcomplex_diag_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API FloatComplexDiagMatrix

  xfloat_complex_diag_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API PermMatrix xperm_matrix_value (const char *fmt, ...) const;


  OCTINTERP_API octave_int8 xint8_scalar_value (const char *fmt, ...) const;


  OCTINTERP_API octave_int16 xint16_scalar_value (const char *fmt, ...) const;


  OCTINTERP_API octave_int32 xint32_scalar_value (const char *fmt, ...) const;


  OCTINTERP_API octave_int64 xint64_scalar_value (const char *fmt, ...) const;


  OCTINTERP_API octave_uint8 xuint8_scalar_value (const char *fmt, ...) const;


  OCTINTERP_API octave_uint16 xuint16_scalar_value (const char *fmt, ...) const;


  OCTINTERP_API octave_uint32 xuint32_scalar_value (const char *fmt, ...) const;


  OCTINTERP_API octave_uint64 xuint64_scalar_value (const char *fmt, ...) const;


  OCTINTERP_API int8NDArray xint8_array_value (const char *fmt, ...) const;


  OCTINTERP_API int16NDArray xint16_array_value (const char *fmt, ...) const;


  OCTINTERP_API int32NDArray xint32_array_value (const char *fmt, ...) const;


  OCTINTERP_API int64NDArray xint64_array_value (const char *fmt, ...) const;


  OCTINTERP_API uint8NDArray xuint8_array_value (const char *fmt, ...) const;


  OCTINTERP_API uint16NDArray xuint16_array_value (const char *fmt, ...) const;


  OCTINTERP_API uint32NDArray xuint32_array_value (const char *fmt, ...) const;


  OCTINTERP_API uint64NDArray xuint64_array_value (const char *fmt, ...) const;


  OCTINTERP_API std::string xstring_value (const char *fmt, ...) const;


  OCTINTERP_API string_vector xstring_vector_value (const char *fmt, ...) const;


  OCTINTERP_API Cell xcell_value (const char *fmt, ...) const;


  OCTINTERP_API Array<std::string> xcellstr_value (const char *fmt, ...) const;


  OCTINTERP_API octave::range<double>

  xrange_value (const char *fmt, ...) const;


  // For now, enable only range<double>.


  OCTINTERP_API octave_map xmap_value (const char *fmt, ...) const;


  OCTINTERP_API octave_scalar_map

  xscalar_map_value (const char *fmt, ...) const;


  OCTINTERP_API ColumnVector xcolumn_vector_value (const char *fmt, ...) const;


  OCTINTERP_API ComplexColumnVector

  xcomplex_column_vector_value (const char *fmt, ...) const;


  OCTINTERP_API RowVector xrow_vector_value (const char *fmt, ...) const;


  OCTINTERP_API ComplexRowVector

  xcomplex_row_vector_value (const char *fmt, ...) const;


  OCTINTERP_API FloatColumnVector

  xfloat_column_vector_value (const char *fmt, ...) const;


  OCTINTERP_API FloatComplexColumnVector

  xfloat_complex_column_vector_value (const char *fmt, ...) const;


  OCTINTERP_API FloatRowVector

  xfloat_row_vector_value (const char *fmt, ...) const;


  OCTINTERP_API FloatComplexRowVector

  xfloat_complex_row_vector_value (const char *fmt, ...) const;


  OCTINTERP_API Array<int> xint_vector_value (const char *fmt, ...) const;


  OCTINTERP_API Array<octave_idx_type>

  xoctave_idx_type_vector_value (const char *fmt, ...) const;


  OCTINTERP_API Array<double> xvector_value (const char *fmt, ...) const;


  OCTINTERP_API Array<Complex>

  xcomplex_vector_value (const char *fmt, ...) const;


  OCTINTERP_API Array<float> xfloat_vector_value (const char *fmt, ...) const;


  OCTINTERP_API Array<FloatComplex>

  xfloat_complex_vector_value (const char *fmt, ...) const;


  OCTINTERP_API octave_function * xfunction_value (const char *fmt, ...) const;


  OCTINTERP_API octave_user_function *

  xuser_function_value (const char *fmt, ...) const;


  OCTINTERP_API octave_user_script *

  xuser_script_value (const char *fmt, ...) const;


  OCTINTERP_API octave_user_code *

  xuser_code_value (const char *fmt, ...) const;


  OCTINTERP_API octave_fcn_handle *

  xfcn_handle_value (const char *fmt, ...) const;


  OCTINTERP_API octave_value_list xlist_value (const char *fmt, ...) const;


  // Possibly economize a lazy-indexed value.


  void maybe_economize ()

  { m_rep->maybe_economize (); }


  // The following two hook conversions are called on any octave_value prior to

  // storing it to a "permanent" location, like a named variable, a cell or a

  // struct component, or a return value of a function.


  OCTINTERP_API octave_value storable_value () const;


  // Ditto, but in place, i.e., equivalent to *this = this->storable_value (),

  // but possibly more efficient.


  OCTINTERP_API void make_storable_value ();


  // FIXME: These should probably be private.

  // Conversions.  If a user of this class wants a certain kind of constant,

  // he should simply ask for it, and we should convert it if possible.


  octave_value convert_to_str (bool pad = false, bool force = false,

                               char type = '\'') const

  { return m_rep->convert_to_str (pad, force, type); }


  octave_value


  convert_to_str_internal (bool pad, bool force, char type) const

  { return m_rep->convert_to_str_internal (pad, force, type); }


  void convert_to_row_or_column_vector ()

  { m_rep->convert_to_row_or_column_vector (); }


  bool print_as_scalar () const

  { return m_rep->print_as_scalar (); }


  void print (std::ostream& os, bool pr_as_read_syntax = false)

  { m_rep->print (os, pr_as_read_syntax); }


  void print_raw (std::ostream& os, bool pr_as_read_syntax = false) const

  { m_rep->print_raw (os, pr_as_read_syntax); }


  bool print_name_tag (std::ostream& os, const std::string& name) const

  { return m_rep->print_name_tag (os, name); }


  void print_with_name (std::ostream& os, const std::string& name) const

  { m_rep->print_with_name (os, name, true); }


  void short_disp (std::ostream& os) const { m_rep->short_disp (os); }


  OCTINTERP_API float_display_format get_edit_display_format () const;


  std::string edit_display (const float_display_format& fmt,

                            octave_idx_type i, octave_idx_type j) const

  {

    return m_rep->edit_display (fmt, i, j);

  }


  int type_id () const { return m_rep->type_id (); }


  std::string type_name () const { return m_rep->type_name (); }


  std::string class_name () const { return m_rep->class_name (); }


  // Unary operations that are member functions.  There are also some

  // non-member functions for unary and binary operations declared

  // below, outside of the octave_value class declaration.


  OCTINTERP_API octave_value& non_const_unary_op (unary_op op);


  OCTINTERP_API octave_value&

  non_const_unary_op (unary_op op, const std::string& type,

                      const std::list<octave_value_list>& idx);


  const octave_base_value& get_rep () const { return *m_rep; }


  bool is_copy_of (const octave_value& val) const { return m_rep == val.m_rep; }


  OCTINTERP_API void

  print_info (std::ostream& os, const std::string& prefix = "") const;


  bool save_ascii (std::ostream& os) { return m_rep->save_ascii (os); }


  OCTINTERP_API bool load_ascii (std::istream& is);


  bool save_binary (std::ostream& os, bool save_as_floats)

  { return m_rep->save_binary (os, save_as_floats); }


  OCTINTERP_API bool load_binary (std::istream& is, bool swap,

                                  octave::mach_info::float_format fmt);


  bool save_hdf5 (octave_hdf5_id loc_id, const char *name,

                  bool save_as_floats)

  { return m_rep->save_hdf5 (loc_id, name, save_as_floats); }


  OCTINTERP_API bool load_hdf5 (octave_hdf5_id loc_id, const char *name);


  OCTINTERP_API 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_base_value * internal_rep () const { return m_rep; }


  // These functions exist to support the MEX interface.

  // You should not use them anywhere else.


  OCTINTERP_API const void *

  mex_get_data (mxClassID class_id = mxUNKNOWN_CLASS,

                mxComplexity complexity = mxREAL) const;


  const octave_idx_type * mex_get_ir () const

  {

    return m_rep->mex_get_ir ();

  }


  const octave_idx_type *


  mex_get_jc () const

  {

    return m_rep->mex_get_jc ();

  }


  mxArray * as_mxArray (bool interleaved = false) const

  { return m_rep->as_mxArray (interleaved); }


  octave_value diag (octave_idx_type k = 0) const

  { return m_rep->diag (k); }


  octave_value diag (octave_idx_type m, octave_idx_type n) const

  { return m_rep->diag (m, n); }


  octave_value sort (octave_idx_type dim = 0, sortmode mode = ASCENDING) const

  { return m_rep->sort (dim, mode); }


  octave_value sort (Array<octave_idx_type>& sidx, octave_idx_type dim = 0,

                     sortmode mode = ASCENDING) const

  { return m_rep->sort (sidx, dim, mode); }


  sortmode issorted (sortmode mode = UNSORTED) const

  { return m_rep->issorted (mode); }


  Array<octave_idx_type> sort_rows_idx (sortmode mode = ASCENDING) const

  { return m_rep->sort_rows_idx (mode); }


  sortmode is_sorted_rows (sortmode mode = UNSORTED) const

  { return m_rep->is_sorted_rows (mode); }


  void lock () { m_rep->lock (); }


  void unlock () { m_rep->unlock (); }


  bool islocked () const { return m_rep->islocked (); }


  void call_object_destructor () { return m_rep->call_object_destructor (); }


  octave_value dump () const { return m_rep->dump (); }


#define MAPPER_FORWARD(F) \

  octave_value F () const                           \

  {                                                     \

    return m_rep->map (octave_base_value::umap_ ## F);    \

  }


  MAPPER_FORWARD (abs)

  MAPPER_FORWARD (acos)

  MAPPER_FORWARD (acosh)

  MAPPER_FORWARD (angle)

  MAPPER_FORWARD (arg)

  MAPPER_FORWARD (asin)

  MAPPER_FORWARD (asinh)

  MAPPER_FORWARD (atan)

  MAPPER_FORWARD (atanh)

  MAPPER_FORWARD (cbrt)

  MAPPER_FORWARD (ceil)

  MAPPER_FORWARD (conj)

  MAPPER_FORWARD (cos)

  MAPPER_FORWARD (cosh)

  MAPPER_FORWARD (erf)

  MAPPER_FORWARD (erfinv)

  MAPPER_FORWARD (erfcinv)

  MAPPER_FORWARD (erfc)

  MAPPER_FORWARD (erfcx)

  MAPPER_FORWARD (erfi)

  MAPPER_FORWARD (dawson)

  MAPPER_FORWARD (exp)

  MAPPER_FORWARD (expm1)

  MAPPER_FORWARD (isfinite)

  MAPPER_FORWARD (fix)

  MAPPER_FORWARD (floor)

  MAPPER_FORWARD (gamma)

  MAPPER_FORWARD (imag)

  MAPPER_FORWARD (isinf)

  MAPPER_FORWARD (isna)

  MAPPER_FORWARD (isnan)

  MAPPER_FORWARD (lgamma)

  MAPPER_FORWARD (log)

  MAPPER_FORWARD (log2)

  MAPPER_FORWARD (log10)

  MAPPER_FORWARD (log1p)

  MAPPER_FORWARD (real)

  MAPPER_FORWARD (round)

  MAPPER_FORWARD (roundb)

  MAPPER_FORWARD (signum)

  MAPPER_FORWARD (sin)

  MAPPER_FORWARD (sinh)

  MAPPER_FORWARD (sqrt)

  MAPPER_FORWARD (tan)

  MAPPER_FORWARD (tanh)


  // These functions are prefixed with X to avoid potential macro conflicts.


  MAPPER_FORWARD (xisalnum)

  MAPPER_FORWARD (xisalpha)

  MAPPER_FORWARD (xisascii)

  MAPPER_FORWARD (xiscntrl)

  MAPPER_FORWARD (xisdigit)

  MAPPER_FORWARD (xisgraph)

  MAPPER_FORWARD (xislower)

  MAPPER_FORWARD (xisprint)

  MAPPER_FORWARD (xispunct)

  MAPPER_FORWARD (xisspace)

  MAPPER_FORWARD (xisupper)

  MAPPER_FORWARD (xisxdigit)

  MAPPER_FORWARD (xsignbit)

  MAPPER_FORWARD (xtolower)

  MAPPER_FORWARD (xtoupper)


#undef MAPPER_FORWARD


  octave_value map (octave_base_value::unary_mapper_t umap) const

  { return m_rep->map (umap); }


  //! Extract the n-th element, aka 'val(n)'.

  //!

  //! @return Result is undefined if 'val' is not an array type

  //!         or @p n is out of range.

  //!

  //! @warning Function calls should never error.


  octave_value


  fast_elem_extract (octave_idx_type n) const

  { return m_rep->fast_elem_extract (n); }


  //! Assign the n-th element, aka 'val(n) = x'.

  //!

  //! @returns false if 'val' is not an array type,

  //!          @p x is not a matching scalar type,

  //!          or @p n is out of range.

  //!

  //! @warning Function calls should never error.


  bool


  fast_elem_insert (octave_idx_type n, const octave_value& x)

  {

    make_unique ();

    return m_rep->fast_elem_insert (n, x);

  }


protected:


  //! The real representation.

  octave_base_value *m_rep;


  static OCTINTERP_API octave_base_value * nil_rep ();


private:


  OCTINTERP_API assign_op unary_op_to_assign_op (unary_op op);


  OCTINTERP_API binary_op op_eq_to_binary_op (assign_op op);


  // This declaration protects against constructing octave_value from

  // const octave_base_value* which actually silently calls octave_value (bool).

  OCTINTERP_API octave_value (const octave_base_value *);


};


// Non-member unary and binary operations on octave_value objects.


OCTAVE_BEGIN_NAMESPACE(octave)


extern OCTINTERP_API octave_value

unary_op (type_info& ti, octave_value::unary_op op,

          const octave_value& a);


extern OCTINTERP_API octave_value

unary_op (octave_value::unary_op op, const octave_value& a);


extern OCTINTERP_API octave_value

binary_op (type_info& ti, octave_value::binary_op op,

           const octave_value& a, const octave_value& b);


extern OCTINTERP_API octave_value

binary_op (type_info& ti, octave_value::compound_binary_op op,

           const octave_value& a, const octave_value& b);


extern OCTINTERP_API octave_value

binary_op (octave_value::binary_op op, const octave_value& a,

           const octave_value& b);


extern OCTINTERP_API octave_value

binary_op (octave_value::compound_binary_op op, const octave_value& a,

           const octave_value& b);


extern OCTINTERP_API octave_value

cat_op (type_info& ti, const octave_value& a,

        const octave_value& b, const Array<octave_idx_type>& ra_idx);


extern OCTINTERP_API octave_value

cat_op (const octave_value& a, const octave_value& b,

        const Array<octave_idx_type>& ra_idx);


extern OCTINTERP_API octave_value

colon_op (const octave_value& base, const octave_value& increment,

          const octave_value& limit, bool is_for_cmd_expr = false);


inline octave_value


colon_op (const octave_value& base, const octave_value& limit,

          bool is_for_cmd_expr = false)

{

  // Note, we need to pass an undefined octave_value object instead of

  // octave_value (1.0) so that we can properly detect the

  // two-argument case and correctly pass just two arguments to any

  // user-defined function that is provided if either base or limit is

  // an object.


  return colon_op (base, octave_value (), limit, is_for_cmd_expr);

}


OCTAVE_END_NAMESPACE(octave)


#define OV_UNOP_FN(name)                                \

  inline octave_value                                   \

  name (const octave_value& a)                          \

  {                                                     \

    return octave::unary_op (octave_value::name, a);    \

  }


#define OV_UNOP_OP(name, op)                    \

  inline octave_value                           \

  operator op (const octave_value& a)           \

  {                                             \

    return name (a);                            \

  }


#define OV_UNOP_FN_OP(name, op)                 \

  OV_UNOP_FN (name)                             \

  OV_UNOP_OP (name, op)


OV_UNOP_FN_OP (op_not, !)

OV_UNOP_FN_OP (op_uplus, +)

OV_UNOP_FN_OP (op_uminus, -)


OV_UNOP_FN (op_transpose)

OV_UNOP_FN (op_hermitian)


// No simple way to define these for prefix and suffix ops?

//

//   incr

//   decr


#define OV_BINOP_FN(name)                                       \

  inline octave_value                                           \

  name (const octave_value& a1, const octave_value& a2)         \

  {                                                             \

    return octave::binary_op (octave_value::name, a1, a2);      \

  }


#define OV_BINOP_OP(name, op)                                   \

  inline octave_value                                           \

  operator op (const octave_value& a1, const octave_value& a2)  \

  {                                                             \

    return name (a1, a2);                                       \

  }


#define OV_BINOP_FN_OP(name, op)                \

  OV_BINOP_FN (name)                            \

  OV_BINOP_OP (name, op)


OV_BINOP_FN_OP (op_add, +)

OV_BINOP_FN_OP (op_sub, -)

OV_BINOP_FN_OP (op_mul, *)

OV_BINOP_FN_OP (op_div, /)


OV_BINOP_FN (op_pow)

OV_BINOP_FN (op_ldiv)


OV_BINOP_FN_OP (op_lt, <)

OV_BINOP_FN_OP (op_le, <=)

OV_BINOP_FN_OP (op_eq, ==)

OV_BINOP_FN_OP (op_ge, >=)

OV_BINOP_FN_OP (op_gt, >)

OV_BINOP_FN_OP (op_ne, !=)


OV_BINOP_FN (op_el_mul)

OV_BINOP_FN (op_el_div)

OV_BINOP_FN (op_el_pow)

OV_BINOP_FN (op_el_ldiv)

OV_BINOP_FN (op_el_and)

OV_BINOP_FN (op_el_or)


OV_BINOP_FN (op_struct_ref)


#define OV_COMP_BINOP_FN(name)                                  \

  inline octave_value                                           \

  name (const octave_value& a1, const octave_value& a2)         \

  {                                                             \

    return octave::binary_op (octave_value::name, a1, a2);      \

  }


OV_COMP_BINOP_FN (op_trans_mul)

OV_COMP_BINOP_FN (op_mul_trans)

OV_COMP_BINOP_FN (op_herm_mul)

OV_COMP_BINOP_FN (op_mul_herm)


extern OCTINTERP_API void install_types (octave::type_info&);


// Templated value extractors.


template <typename Value>


inline Value octave_value_extract (const octave_value&)

{

  // We can't include error.h in ov.h.  Is there anything better than

  // panic_impossible that we can do here?


  panic_impossible ();

}


#define DEF_VALUE_EXTRACTOR(VALUE,MPREFIX)                              \

  template <>                                                           \

  inline VALUE octave_value_extract<VALUE> (const octave_value& v)      \

  {                                                                     \

    return v.MPREFIX ## _value ();                                      \

  }


DEF_VALUE_EXTRACTOR (double, scalar)

DEF_VALUE_EXTRACTOR (float, float_scalar)

DEF_VALUE_EXTRACTOR (Complex, complex)

DEF_VALUE_EXTRACTOR (FloatComplex, float_complex)

DEF_VALUE_EXTRACTOR (bool, bool)


DEF_VALUE_EXTRACTOR (octave_int8, int8_scalar)

DEF_VALUE_EXTRACTOR (octave_int16, int16_scalar)

DEF_VALUE_EXTRACTOR (octave_int32, int32_scalar)

DEF_VALUE_EXTRACTOR (octave_int64, int64_scalar)

DEF_VALUE_EXTRACTOR (octave_uint8, uint8_scalar)

DEF_VALUE_EXTRACTOR (octave_uint16, uint16_scalar)

DEF_VALUE_EXTRACTOR (octave_uint32, uint32_scalar)

DEF_VALUE_EXTRACTOR (octave_uint64, uint64_scalar)


DEF_VALUE_EXTRACTOR (NDArray, array)

DEF_VALUE_EXTRACTOR (FloatNDArray, float_array)

DEF_VALUE_EXTRACTOR (ComplexNDArray, complex_array)

DEF_VALUE_EXTRACTOR (FloatComplexNDArray, float_complex_array)

DEF_VALUE_EXTRACTOR (boolNDArray, bool_array)


DEF_VALUE_EXTRACTOR (charNDArray, char_array)

DEF_VALUE_EXTRACTOR (int8NDArray, int8_array)

DEF_VALUE_EXTRACTOR (int16NDArray, int16_array)

DEF_VALUE_EXTRACTOR (int32NDArray, int32_array)

DEF_VALUE_EXTRACTOR (int64NDArray, int64_array)

DEF_VALUE_EXTRACTOR (uint8NDArray, uint8_array)

DEF_VALUE_EXTRACTOR (uint16NDArray, uint16_array)

DEF_VALUE_EXTRACTOR (uint32NDArray, uint32_array)

DEF_VALUE_EXTRACTOR (uint64NDArray, uint64_array)


DEF_VALUE_EXTRACTOR (Matrix, matrix)

DEF_VALUE_EXTRACTOR (FloatMatrix, float_matrix)

DEF_VALUE_EXTRACTOR (ComplexMatrix, complex_matrix)

DEF_VALUE_EXTRACTOR (FloatComplexMatrix, float_complex_matrix)

DEF_VALUE_EXTRACTOR (boolMatrix, bool_matrix)


DEF_VALUE_EXTRACTOR (ColumnVector, column_vector)

DEF_VALUE_EXTRACTOR (FloatColumnVector, float_column_vector)

DEF_VALUE_EXTRACTOR (ComplexColumnVector, complex_column_vector)

DEF_VALUE_EXTRACTOR (FloatComplexColumnVector, float_complex_column_vector)


DEF_VALUE_EXTRACTOR (RowVector, row_vector)

DEF_VALUE_EXTRACTOR (FloatRowVector, float_row_vector)

DEF_VALUE_EXTRACTOR (ComplexRowVector, complex_row_vector)

DEF_VALUE_EXTRACTOR (FloatComplexRowVector, float_complex_row_vector)


DEF_VALUE_EXTRACTOR (DiagMatrix, diag_matrix)

DEF_VALUE_EXTRACTOR (FloatDiagMatrix, float_diag_matrix)

DEF_VALUE_EXTRACTOR (ComplexDiagMatrix, complex_diag_matrix)

DEF_VALUE_EXTRACTOR (FloatComplexDiagMatrix, float_complex_diag_matrix)

DEF_VALUE_EXTRACTOR (PermMatrix, perm_matrix)


DEF_VALUE_EXTRACTOR (SparseMatrix, sparse_matrix)

DEF_VALUE_EXTRACTOR (SparseComplexMatrix, sparse_complex_matrix)

DEF_VALUE_EXTRACTOR (SparseBoolMatrix, sparse_bool_matrix)

#undef DEF_VALUE_EXTRACTOR


// We can't include error.h in ov.h.  Is there anything better than

// panic_impossible that we can do here?


#define DEF_DUMMY_VALUE_EXTRACTOR(VALUE,DEFVAL)                         \

  template <>                                                           \

  inline VALUE octave_value_extract<VALUE> (const octave_value&)        \

  {                                                                     \

    panic_impossible ();                                                \

    return DEFVAL;                                                      \

  }


DEF_DUMMY_VALUE_EXTRACTOR (char, 0)

DEF_DUMMY_VALUE_EXTRACTOR (octave_value, octave_value ())

#undef DEF_DUMMY_VALUE_EXTRACTOR


#endif

conj
ComplexColumnVector conj(const ComplexColumnVector &a)
Definition CColVector.cc:217

C
#define C(a, b)
Definition Faddeeva.cc:256

Array
N Dimensional Array with copy-on-write semantics.
Definition Array.h:130

Array::size
size_type size(const size_type d) const
Size of the specified dimension.
Definition Array.h:496

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:2106

Cell
Definition Cell.h:41

ColumnVector
Definition dColVector.h:35

ComplexColumnVector
Definition CColVector.h:35

ComplexDiagMatrix
Definition CDiagMatrix.h:40

ComplexMatrix
Definition CMatrix.h:41

ComplexNDArray
Definition CNDArray.h:37

ComplexRowVector
Definition CRowVector.h:36

DiagArray2
Definition DiagArray2.h:40

DiagMatrix
Definition dDiagMatrix.h:38

FloatColumnVector
Definition fColVector.h:35

FloatComplexColumnVector
Definition fCColVector.h:35

FloatComplexDiagMatrix
Definition fCDiagMatrix.h:40

FloatComplexMatrix
Definition fCMatrix.h:41

FloatComplexNDArray
Definition fCNDArray.h:37

FloatComplexRowVector
Definition fCRowVector.h:36

FloatDiagMatrix
Definition fDiagMatrix.h:38

FloatMatrix
Definition fMatrix.h:40

FloatNDArray
Definition fNDArray.h:38

FloatRowVector
Definition fRowVector.h:35

MatrixType
Definition MatrixType.h:36

MatrixType::matrix_type
matrix_type
Definition MatrixType.h:39

Matrix
Definition dMatrix.h:40

NDArray
Definition dNDArray.h:38

PermMatrix
Definition PermMatrix.h:38

RowVector
Definition dRowVector.h:35

SparseBoolMatrix
Definition boolSparse.h:39

SparseComplexMatrix
Definition CSparse.h:45

SparseMatrix
Definition dSparse.h:44

Sparse
Definition Sparse.h:46

boolMatrix
Definition boolMatrix.h:37

boolNDArray
Definition boolNDArray.h:37

charMatrix
Definition chMatrix.h:40

charNDArray
Definition chNDArray.h:38

dim_vector
Vector representing the dimensions (size) of an Array.
Definition dim-vector.h:90

float_display_format
Definition pr-flt-fmt.h:207

float_format
Definition pr-flt-fmt.h:48

intNDArray
Definition intNDArray.h:38

mxArray
Definition mxarray.h:328

oct_data_conv::data_type
data_type
Definition data-conv.h:39

octave_base_value::type_conv_info
Definition ov-base.h:261

octave_base_value
Definition ov-base.h:254

octave_base_value::try_narrowing_conversion
virtual octave_base_value * try_narrowing_conversion()
Definition ov-base.h:332

octave_base_value::find_parent_class
virtual octave_base_value * find_parent_class(const std::string &)
Definition ov-base.h:711

octave_base_value::m_count
octave::refcount< octave_idx_type > m_count
Definition ov-base.h:958

octave_base_value::unique_clone
virtual octave_base_value * unique_clone()
Definition ov-base.h:298

octave_base_value::empty_clone
virtual octave_base_value * empty_clone() const
Definition ov-base.cc:118

octave_base_value::unary_mapper_t
unary_mapper_t
Definition ov-base.h:840

octave_classdef
Definition ov-classdef.h:47

octave_fcn_handle
Definition ov-fcn-handle.h:186

octave_function
Definition ov-fcn.h:53

octave_idx_type

octave_int
Definition oct-inttypes.h:783

octave_map
Definition oct-map.h:268

octave_scalar_map
Definition oct-map.h:165

octave_user_code
Definition ov-usr-fcn.h:61

octave_user_function
Definition ov-usr-fcn.h:211

octave_user_script
Definition ov-usr-fcn.h:157

octave_value_list
Definition ovl.h:42

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:1006

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::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:1433

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::mex_get_jc
const octave_idx_type * mex_get_jc() const
Definition ov.h:1417

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::strict_bool_value
bool strict_bool_value(const char *fmt,...) const

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:838

octave_value::int8_scalar_value
octave_int8 int8_scalar_value() const
Definition ov.h:935

octave_value::get_rep
const octave_base_value & get_rep() const
Definition ov.h:1374

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:1339

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:900

octave_value::sparse_matrix_value
SparseMatrix sparse_matrix_value(bool frc_str_conv=false) const
Definition ov.h:909

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:956

octave_value::call_object_destructor
void call_object_destructor()
Definition ov.h:1452

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:1362

octave_value::bool_value
bool bool_value(bool warn=false) const
Definition ov.h:891

octave_value::xnint_value
int xnint_value(const char *fmt,...) const

octave_value::convert_to_str_internal
octave_value convert_to_str_internal(bool pad, bool force, char type) const
Definition ov.h:1327

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:950

octave_value::function_value
octave_function * function_value(bool silent=false) const

octave_value::is_real_scalar
bool is_real_scalar() const
Definition ov.h:610

octave_value::strict_idx_type_value
octave_idx_type strict_idx_type_value(const char *fmt,...) const

octave_value::char_matrix_value
charMatrix char_matrix_value(bool frc_str_conv=false) const
Definition ov.h:903

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:965

octave_value::uint16_array_value
uint16NDArray uint16_array_value() const
Definition ov.h:974

octave_value::diag_matrix_value
DiagMatrix diag_matrix_value(bool force=false) const
Definition ov.h:919

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:1551

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::classdef_object_value
octave_classdef * classdef_object_value(bool silent=false) const

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::assign
octave_value & assign(assign_op, const octave_value &rhs)

octave_value::octave_value
octave_value(const Array< octave_uint8 > &inda)

octave_value::xcellstr_value
Array< std::string > xcellstr_value(const char *fmt,...) const

octave_value::is_instance_of
bool is_instance_of(const std::string &cls_name) const
Definition ov.h:1022

octave_value::octave_value
octave_value(const uint8NDArray &inda)

octave_value::int16_array_value
int16NDArray int16_array_value() const
Definition ov.h:962

octave_value::maybe_economize
void maybe_economize()
Definition ov.h:1304

octave_value::xlist_value
octave_value_list xlist_value(const char *fmt,...) const

octave_value::cell_value
Cell cell_value() 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:1345

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::int8_array_value
int8NDArray int8_array_value() const
Definition ov.h:959

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:944

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:834

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:1428

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::float_vector_value
Array< float > float_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const

octave_value::is_sq_string
bool is_sq_string() const
Definition ov.h:640

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::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::nzmax
octave_idx_type nzmax() const
Definition ov.h:567

octave_value::strict_idx_type_value
octave_idx_type strict_idx_type_value(bool frc_str_conv=false) const

octave_value::is_classdef_meta
bool is_classdef_meta() const
Definition ov.h:652

octave_value::cellstr_value
Array< std::string > cellstr_value() const
Definition ov.h:991

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::strict_int_value
int strict_int_value(bool frc_str_conv=false) const
Definition ov.h:815

octave_value::float_diag_matrix_value
FloatDiagMatrix float_diag_matrix_value(bool force=false) const
Definition ov.h:922

octave_value::complex_matrix_value
ComplexMatrix complex_matrix_value(bool frc_str_conv=false) const
Definition ov.h:877

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:1348

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:1446

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:1454

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:871

octave_value::octave_value
octave_value(const octave_uint16 &i)

octave_value::sort_rows_idx
Array< octave_idx_type > sort_rows_idx(sortmode mode=ASCENDING) const
Definition ov.h:1440

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::user_script_value
octave_user_script * user_script_value(bool silent=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:929

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:1391

octave_value::xrange_value
octave::range< double > xrange_value(const char *fmt,...) const

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::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:1431

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::xcomplex_vector_value
Array< Complex > xcomplex_vector_value(const char *fmt,...) const

octave_value::type_id
int type_id() const
Definition ov.h:1358

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::find_parent_class
octave_base_value * find_parent_class(const std::string &parent_class_name)
Definition ov.h:1019

octave_value::xcomplex_matrix_value
ComplexMatrix xcomplex_matrix_value(const char *fmt,...) const

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::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:884

octave_value::is_copy_of
bool is_copy_of(const octave_value &val) const
Definition ov.h:1376

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::float_complex_vector_value
Array< FloatComplex > float_complex_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const

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:1015

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:1352

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:1385

octave_value::char_array_value
charNDArray char_array_value(bool frc_str_conv=false) const
Definition ov.h:906

octave_value::make_storable_value
void make_storable_value()

octave_value::isempty
bool isempty() const
Definition ov.h:601

octave_value::uint32_scalar_value
octave_uint32 uint32_scalar_value() const
Definition ov.h:953

octave_value::try_narrowing_conversion
octave_base_value * try_narrowing_conversion()
Definition ov.h:458

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:1381

octave_value::xint_vector_value
Array< int > xint_vector_value(const char *fmt,...) const

octave_value::map_keys
string_vector map_keys() const
Definition ov.h:1003

octave_value::float_scalar_value
float float_scalar_value(bool frc_str_conv=false) const
Definition ov.h:856

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:874

octave_value::break_closure_cycles
void break_closure_cycles(const std::shared_ptr< octave::stack_frame > &)

octave_value::is_equal
bool is_equal(const octave_value &) const

octave_value::nparents
std::size_t nparents() const
Definition ov.h:1009

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::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::xuser_function_value
octave_user_function * xuser_function_value(const char *fmt,...) const

octave_value::is_uint16_type
bool is_uint16_type() const
Definition ov.h:721

octave_value::uint64_array_value
uint64NDArray uint64_array_value() const
Definition ov.h:980

octave_value::xchar_matrix_value
charMatrix xchar_matrix_value(const char *fmt,...) const

octave_value::non_const_unary_op
octave_value & non_const_unary_op(unary_op op)

octave_value::xshort_value
short int xshort_value(const char *fmt,...) const

octave_value::float_value
float float_value(bool frc_str_conv=false) const
Definition ov.h:850

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::xuser_script_value
octave_user_script * xuser_script_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::mex_get_data
const void * mex_get_data(mxClassID class_id=mxUNKNOWN_CLASS, mxComplexity complexity=mxREAL) const

octave_value::xfloat_array_value
FloatNDArray xfloat_array_value(const char *fmt,...) const

octave_value::ulong_value
unsigned long int ulong_value(bool req_int=false, bool frc_str_conv=false) const
Definition ov.h:830

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:1333

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:853

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::mex_get_ir
const octave_idx_type * mex_get_ir() const
Definition ov.h:1411

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:1330

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::is_real_matrix
bool is_real_matrix() const
Definition ov.h:613

octave_value::bool_matrix_value
boolMatrix bool_matrix_value(bool warn=false) const
Definition ov.h:897

octave_value::isnull
bool isnull() const
Definition ov.h:679

octave_value::nnz
octave_idx_type nnz() const
Definition ov.h:565

octave_value::xfloat_vector_value
Array< float > xfloat_vector_value(const char *fmt,...) const

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:1539

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::complex_vector_value
Array< Complex > complex_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const

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:983

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::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:925

octave_value::uint8_scalar_value
octave_uint8 uint8_scalar_value() const
Definition ov.h:947

octave_value::nint_value
int nint_value(bool frc_str_conv=false) const
Definition ov.h:822

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:862

octave_value::xscalar_map_value
octave_scalar_map xscalar_map_value(const char *fmt,...) const

octave_value::islocked
bool islocked() const
Definition ov.h:1450

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:1528

octave_value::int16_scalar_value
octave_int16 int16_scalar_value() const
Definition ov.h:938

octave_value::xvector_value
Array< double > xvector_value(const char *fmt,...) const

octave_value::clone
octave_base_value * clone() const

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::xoctave_idx_type_vector_value
Array< octave_idx_type > xoctave_idx_type_vector_value(const char *fmt,...) const

octave_value::octave_value
octave_value(const Array< octave_int32 > &inda)

octave_value::long_value
long int long_value(bool req_int=false, bool frc_str_conv=false) const
Definition ov.h:826

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:986

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:1443

octave_value::as_mxArray
mxArray * as_mxArray(bool interleaved=false) const
Definition ov.h:1422

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::fcn_handle_value
octave_fcn_handle * fcn_handle_value(bool silent=false) const

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::int64_array_value
int64NDArray int64_array_value() const
Definition ov.h:968

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:916

octave_value::array_value
NDArray array_value(bool frc_str_conv=false) const
Definition ov.h:865

octave_value::xfloat_complex_value
FloatComplex xfloat_complex_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::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::xuint16_array_value
uint16NDArray xuint16_array_value(const char *fmt,...) const

octave_value::strict_bool_value
bool strict_bool_value() const
Definition ov.h:894

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::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::convert_to_str
octave_value convert_to_str(bool pad=false, bool force=false, char type='\'') const
Definition ov.h:1322

octave_value::uint8_array_value
uint8NDArray uint8_array_value() const
Definition ov.h:971

octave_value::print_name_tag
bool print_name_tag(std::ostream &os, const std::string &name) const
Definition ov.h:1342

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:1437

octave_value::user_function_value
octave_user_function * user_function_value(bool silent=false) const

octave_value::xfloat_complex_vector_value
Array< FloatComplex > xfloat_complex_vector_value(const char *fmt,...) const

octave_value::type_name
std::string type_name() const
Definition ov.h:1360

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::parent_class_name_list
std::list< std::string > parent_class_name_list() const
Definition ov.h:1012

octave_value::m_rep
octave_base_value * m_rep
The real representation.
Definition ov.h:1560

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::strict_int_value
int strict_int_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:941

octave_value::byte_size
std::size_t byte_size() const
Definition ov.h:562

octave_value::xfcn_handle_value
octave_fcn_handle * xfcn_handle_value(const char *fmt,...) const

octave_value::float_complex_array_value
FloatComplexNDArray float_complex_array_value(bool frc_str_conv=false) const
Definition ov.h:888

octave_value::octave_value
octave_value(const octave_int32 &i)

octave_value::xfunction_value
octave_function * xfunction_value(const char *fmt,...) const

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::xuser_code_value
octave_user_code * xuser_code_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::~octave_value
~octave_value()
Definition ov.h:342

octave_value::xfloat_value
float xfloat_value(const char *fmt,...) const

octave_value::xdiag_matrix_value
DiagMatrix xdiag_matrix_value(const char *fmt,...) 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:868

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::user_code_value
octave_user_code * user_code_value(bool silent=false) const

octave_value::xarray_value
NDArray xarray_value(const char *fmt,...) const

octave_value::uint32_array_value
uint32NDArray uint32_array_value() const
Definition ov.h:977

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:859

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:881

octave_value::print
void print(std::ostream &os, bool pr_as_read_syntax=false)
Definition ov.h:1336

octave_value::empty_clone
octave_base_value * empty_clone() const
Definition ov.h:337

octave_value::diag
octave_value diag(octave_idx_type k=0) const
Definition ov.h:1425

octave_value::octave_value
octave_value(const Array< octave_uint32 > &inda)

octave_value::range_value
octave::range< double > range_value() const
Definition ov.h:994

octave_value::double_value
double double_value(bool frc_str_conv=false) const
Definition ov.h:847

octave_value::uint_value
unsigned int uint_value(bool req_int=false, bool frc_str_conv=false) const
Definition ov.h:819

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:932

octave_value::internal_rep
octave_base_value * internal_rep() const
Definition ov.h:1402

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::sparse_complex_matrix_value
SparseComplexMatrix sparse_complex_matrix_value(bool frc_str_conv=false) const
Definition ov.h:913

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::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:1448

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:38

type_info
Definition ov-typeinfo.h:43

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

data-conv.h

gamma
function gamma(x)
Definition gamma.f:3

idx-vector.h

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

ceil
std::complex< T > ceil(const std::complex< T > &x)
Definition lo-mappers.h:103

atan
Complex atan(const Complex &x)
Definition lo-mappers.h:71

roundb
double roundb(double x)
Definition lo-mappers.h:147

floor
std::complex< T > floor(const std::complex< T > &x)
Definition lo-mappers.h:130

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

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

erfi
double erfi(double x)
Definition lo-specfun.cc:1731

dawson
double dawson(double x)
Definition lo-specfun.cc:1467

erf
Complex erf(const Complex &x)
Definition lo-specfun.cc:1588

erfcinv
double erfcinv(double x)
Definition lo-specfun.cc:1697

erfcx
double erfcx(double x)
Definition lo-specfun.cc:1710

expm1
Complex expm1(const Complex &x)
Definition lo-specfun.cc:1835

log1p
Complex log1p(const Complex &x)
Definition lo-specfun.cc:1919

erfc
Complex erfc(const Complex &x)
Definition lo-specfun.cc:1603

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

mach-info.h

mx-base.h

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

oct-sort.h

sortmode
sortmode
Definition oct-sort.h:97

UNSORTED
@ UNSORTED
Definition oct-sort.h:97

ASCENDING
@ ASCENDING
Definition oct-sort.h:97

oct-stream.h

oct-time.h

ra_idx
const octave_base_value const Array< octave_idx_type > & ra_idx
Definition op-int-concat.cc:170

ov-base.h

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:1691

op_el_ldiv
octave_value op_el_ldiv(const octave_value &a1, const octave_value &a2)
Definition ov.h:1696

op_uplus
octave_value op_uplus(const octave_value &a)
Definition ov.h:1649

op_add
octave_value op_add(const octave_value &a1, const octave_value &a2)
Definition ov.h:1678

op_gt
octave_value op_gt(const octave_value &a1, const octave_value &a2)
Definition ov.h:1690

op_uminus
octave_value op_uminus(const octave_value &a)
Definition ov.h:1650

op_el_div
octave_value op_el_div(const octave_value &a1, const octave_value &a2)
Definition ov.h:1694

DEF_DUMMY_VALUE_EXTRACTOR
#define DEF_DUMMY_VALUE_EXTRACTOR(VALUE, DEFVAL)
Definition ov.h:1795

op_mul_herm
octave_value op_mul_herm(const octave_value &a1, const octave_value &a2)
Definition ov.h:1712

op_transpose
octave_value op_transpose(const octave_value &a)
Definition ov.h:1652

op_el_or
octave_value op_el_or(const octave_value &a1, const octave_value &a2)
Definition ov.h:1698

op_sub
octave_value op_sub(const octave_value &a1, const octave_value &a2)
Definition ov.h:1679

op_mul
octave_value op_mul(const octave_value &a1, const octave_value &a2)
Definition ov.h:1680

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:1653

OV_COMP_BINOP_FN
#define OV_COMP_BINOP_FN(name)
Definition ov.h:1702

op_le
octave_value op_le(const octave_value &a1, const octave_value &a2)
Definition ov.h:1687

op_el_and
octave_value op_el_and(const octave_value &a1, const octave_value &a2)
Definition ov.h:1697

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:1711

MAPPER_FORWARD
#define MAPPER_FORWARD(F)
Definition ov.h:1456

op_eq
octave_value op_eq(const octave_value &a1, const octave_value &a2)
Definition ov.h:1688

op_el_pow
octave_value op_el_pow(const octave_value &a1, const octave_value &a2)
Definition ov.h:1695

OV_UNOP_FN_OP
#define OV_UNOP_FN_OP(name, op)
Definition ov.h:1644

DEF_VALUE_EXTRACTOR
#define DEF_VALUE_EXTRACTOR(VALUE, MPREFIX)
Definition ov.h:1727

op_struct_ref
octave_value op_struct_ref(const octave_value &a1, const octave_value &a2)
Definition ov.h:1700

op_not
octave_value op_not(const octave_value &a)
Definition ov.h:1648

OV_BINOP_FN
#define OV_BINOP_FN(name)
Definition ov.h:1660

op_ldiv
octave_value op_ldiv(const octave_value &a1, const octave_value &a2)
Definition ov.h:1684

OV_UNOP_FN
#define OV_UNOP_FN(name)
Definition ov.h:1630

octave_value_extract
Value octave_value_extract(const octave_value &)
Definition ov.h:1719

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:1683

op_ge
octave_value op_ge(const octave_value &a1, const octave_value &a2)
Definition ov.h:1689

op_el_mul
octave_value op_el_mul(const octave_value &a1, const octave_value &a2)
Definition ov.h:1693

op_div
octave_value op_div(const octave_value &a1, const octave_value &a2)
Definition ov.h:1681

op_trans_mul
octave_value op_trans_mul(const octave_value &a1, const octave_value &a2)
Definition ov.h:1709

op_mul_trans
octave_value op_mul_trans(const octave_value &a1, const octave_value &a2)
Definition ov.h:1710

OV_BINOP_FN_OP
#define OV_BINOP_FN_OP(name, op)
Definition ov.h:1674

op_lt
octave_value op_lt(const octave_value &a1, const octave_value &a2)
Definition ov.h:1686

panic.h

panic_impossible
#define panic_impossible()
Definition panic.h:54

str-vec.h