24 #if defined (HAVE_CONFIG_H)
498 #if defined (OCTAVE_HAVE_LONG_LONG_INT)
504 #if defined (OCTAVE_HAVE_UNSIGNED_LONG_LONG_INT)
571 : rep (Vdisable_diagonal_matrix
579 : rep (Vdisable_diagonal_matrix
587 : rep (Vdisable_diagonal_matrix
595 : rep (Vdisable_diagonal_matrix
603 : rep (Vdisable_diagonal_matrix
611 : rep (Vdisable_diagonal_matrix
691 : rep (Vdisable_diagonal_matrix
699 : rep (Vdisable_diagonal_matrix
731 : rep (Vdisable_permutation_matrix
877 : rep (new octave_int8_scalar (i))
883 : rep (new octave_uint8_scalar (i))
889 : rep (new octave_int16_scalar (i))
895 : rep (new octave_uint16_scalar (i))
901 : rep (new octave_int32_scalar (i))
907 : rep (new octave_uint32_scalar (i))
913 : rep (new octave_int64_scalar (i))
919 : rep (new octave_uint64_scalar (i))
925 : rep (new octave_int8_matrix (inda))
931 : rep (new octave_int8_matrix (inda))
937 : rep (new octave_uint8_matrix (inda))
943 : rep (new octave_uint8_matrix (inda))
949 : rep (new octave_int16_matrix (inda))
955 : rep (new octave_int16_matrix (inda))
961 : rep (new octave_uint16_matrix (inda))
967 : rep (new octave_uint16_matrix (inda))
973 : rep (new octave_int32_matrix (inda))
979 : rep (new octave_int32_matrix (inda))
985 : rep (new octave_uint32_matrix (inda))
991 : rep (new octave_uint32_matrix (inda))
997 : rep (new octave_int64_matrix (inda))
1003 : rep (new octave_int64_matrix (inda))
1009 : rep (new octave_uint64_matrix (inda))
1015 : rep (new octave_uint64_matrix (inda))
1052 idx.
unconvert (idx_class, scalar, range, array, mask);
1098 : rep (force_range || ! Vdisable_range
1116 const std::list<std::string>& plist)
1123 const std::list<std::string>& plist)
1159 if (tmp && tmp !=
rep)
1175 if (
args.length () != 1)
1178 return ovl (
args(0).as_double ());
1219 if (
args.length () != 1)
1222 return args(0).as_single ();
1260 if (
args.length () != 1)
1263 return args(0).as_int8 ();
1282 if (
args.length () != 1)
1285 return args(0).as_int16 ();
1304 if (
args.length () != 1)
1307 return args(0).as_int32 ();
1326 if (
args.length () != 1)
1329 return args(0).as_int64 ();
1348 if (
args.length () != 1)
1351 return args(0).as_uint8 ();
1370 if (
args.length () != 1)
1373 return args(0).as_uint16 ();
1392 if (
args.length () != 1)
1395 return args(0).as_uint32 ();
1414 if (
args.length () != 1)
1417 return args(0).as_uint64 ();
1433 std::list<octave_value_list>
i;
1442 const std::list<octave_value_list>& idx,
int nargout)
1452 const std::list<octave_value_list>& idx,
int nargout,
1453 const std::list<octave_lvalue> *lvalue_list)
1456 return rep->
subsref (type, idx, nargout, lvalue_list);
1458 return subsref (type, idx, nargout);
1463 const std::list<octave_value_list>& idx,
1466 if (idx.size () > skip)
1468 std::list<octave_value_list> new_idx (idx);
1469 for (
size_t i = 0;
i < skip;
i++)
1470 new_idx.erase (new_idx.begin ());
1471 return subsref (type.substr (skip), new_idx);
1479 const std::list<octave_value_list>& idx,
1482 if (idx.size () > skip)
1484 std::list<octave_value_list> new_idx (idx);
1485 for (
size_t i = 0;
i < skip;
i++)
1486 new_idx.erase (new_idx.begin ());
1495 const std::list<octave_value_list>& idx,
1496 const std::list<octave_lvalue> *lvalue_list,
1499 if (idx.size () > skip)
1501 std::list<octave_value_list> new_idx (idx);
1502 for (
size_t i = 0;
i < skip;
i++)
1503 new_idx.erase (new_idx.begin ());
1504 return subsref (type.substr (skip), new_idx,
nargout, lvalue_list);
1512 const std::list<octave_value_list>& idx,
1515 if (idx.size () > skip)
1517 std::list<octave_value_list> new_idx (idx);
1518 for (
size_t i = 0;
i < skip;
i++)
1519 new_idx.erase (new_idx.begin ());
1520 return subsref (type.substr (skip), new_idx, auto_add);
1534 const std::list<octave_lvalue> *lvalue_list)
1541 const std::list<octave_value_list>& idx,
1549 const std::list<octave_value_list>& idx,
1557 const std::list<octave_value_list>& idx,
1567 error (
"in computed assignment A(index) OP= X, A must be defined first");
1576 *
this =
subsasgn (type, idx, t_rhs);
1617 error (
"in computed assignment A OP= X, A must be defined first");
1629 for (
int i = 0;
i < dv.
ndims ();
i++)
1679 #if defined (OCTAVE_ENABLE_64)
1682 return int_value (req_int, frc_str_conv);
1756 if (! force_vector_conversion)
1758 my_type.c_str (), wanted_type.c_str ());
1767 bool frc_vec_conv)
const
1775 bool frc_vec_conv)
const
1783 bool frc_vec_conv)
const
1791 bool frc_vec_conv)
const
1799 bool force_vector_conversion)
const
1804 force_vector_conversion,
1808 template <
typename T>
1823 bool force_vector_conversion)
const
1857 double ai = a.
elem (
i);
1858 int v =
static_cast<int> (ai);
1873 force_vector_conversion,
1877 template <
typename T>
1892 bool force_string_conv,
1893 bool force_vector_conversion)
const
1927 double ai = a.
elem (
i);
1943 force_vector_conversion,
1949 bool force_vector_conversion)
const
1954 force_vector_conversion,
1960 bool frc_vec_conv)
const
1968 bool frc_vec_conv)
const
1977 bool frc_vec_conv)
const
1985 bool frc_vec_conv)
const
1993 bool force_vector_conversion)
const
1998 force_vector_conversion,
2004 bool force_vector_conversion)
const
2009 force_vector_conversion,
2017 #define XVALUE_EXTRACTOR(TYPE, NAME, FCN) \
2019 octave_value::NAME (const char *fmt, ...) const \
2027 catch (octave::execution_exception& e) \
2032 va_start (args, fmt); \
2033 verror (e, fmt, args); \
2163 #undef XVALUE_EXTRACTOR
2196 return rep->
write (os, block_size, output_type, skip, flt_fmt);
2199 OCTAVE_NORETURN
static void
2203 error (
"binary operator '%s' not implemented for '%s' by '%s' operations",
2204 on.c_str (), tn1.c_str (), tn2.c_str ());
2207 OCTAVE_NORETURN
static void
2210 error (
"type conversion failed for binary operator '%s'", on.c_str ());
2234 retval =
f (v1, v2);
2245 retval =
f (*v1.
rep, *v2.
rep);
2347 retval =
f (*tv1.
rep, *tv2.
rep);
2402 error (
"invalid compound operator");
2424 retval =
f (v1, v2);
2434 retval =
f (*v1.
rep, *v2.
rep);
2442 OCTAVE_NORETURN
static void
2445 error (
"concatenation operator not implemented for '%s' by '%s' operations",
2446 tn1.c_str (), tn2.c_str ());
2449 OCTAVE_NORETURN
static void
2452 error (
"type conversion failed for concatenation operator");
2471 retval =
f (*v1.
rep, *v2.
rep, ra_idx);
2543 error (
"colon method not defined for %s class", dispatch_type.c_str ());
2545 octave_value_list
args;
2550 args(1) = increment;
2567 Matrix m_base, m_limit, m_increment;
2573 catch (octave::execution_exception&
e)
2575 error (e,
"invalid base value in colon expression");
2582 catch (octave::execution_exception& e)
2584 error (e,
"invalid limit value in colon expression");
2591 : Matrix (1, 1, 1.0));
2593 catch (octave::execution_exception& e)
2595 error (e,
"invalid increment value in colon expression");
2598 bool base_empty = m_base.
is_empty ();
2599 bool limit_empty = m_limit.
is_empty ();
2600 bool increment_empty = m_increment.
is_empty ();
2602 if (base_empty || limit_empty || increment_empty)
2606 Range r (m_base(0), m_limit(0), m_increment(0));
2614 retval = retval.
convert_to_str (
false,
true, dq_str ?
'"' :
'\'');
2624 os << prefix <<
"type_name: " <<
type_name () <<
"\n"
2625 << prefix <<
"count: " <<
get_count () <<
"\n"
2626 << prefix <<
"rep info: ";
2631 OCTAVE_NORETURN
static void
2634 error (
"unary operator '%s' not implemented for '%s' operands",
2635 on.c_str (), tn.c_str ());
2638 OCTAVE_NORETURN
static void
2641 error (
"type conversion failed for unary operator '%s'", on.c_str ());
2671 retval =
f (*v.
rep);
2695 OCTAVE_NORETURN
static void
2699 error (
"operator %s: type conversion for '%s' failed",
2700 op.c_str (), tn.c_str ());
2714 error (
"in x%s or %sx, x must be defined first",
2715 op_str.c_str (), op_str.c_str ());
2755 if (old_rep && --old_rep->
count == 0)
2795 const std::list<octave_value_list>& idx)
2807 assign (assop, type, idx, 1.0);
2827 error (
"operator %s: no assign operator found", on.c_str ());
2876 error (
"operator %s: no binary operator found", on.c_str ());
2884 if (type.length () > 0)
2889 if (type.length () > 1 && type[1] ==
'.')
2890 return octave_map ();
2898 return octave_scalar_map ();
2924 octave_int8_scalar::register_type ();
2925 octave_int16_scalar::register_type ();
2926 octave_int32_scalar::register_type ();
2927 octave_int64_scalar::register_type ();
2928 octave_uint8_scalar::register_type ();
2929 octave_uint16_scalar::register_type ();
2930 octave_uint32_scalar::register_type ();
2931 octave_uint64_scalar::register_type ();
2932 octave_int8_matrix::register_type ();
2933 octave_int16_matrix::register_type ();
2934 octave_int32_matrix::register_type ();
2935 octave_int64_matrix::register_type ();
2936 octave_uint8_matrix::register_type ();
2937 octave_uint16_matrix::register_type ();
2938 octave_uint32_matrix::register_type ();
2939 octave_uint64_matrix::register_type ();
2975 if (
args.length () != 1)
2978 return ovl (
args(0).byte_size ());
2990 std::list<octave_value_list>& idx)
2992 const octave_map
m = arg.
xmap_value (
"%s: second argument must be a structure with fields 'type' and 'subs'", name);
2995 error (
"%s: second argument must be a structure with fields 'type' and 'subs'",
2998 octave_idx_type nel = m.
numel ();
3001 idx = std::list<octave_value_list> ();
3009 for (
int k = 0;
k < nel;
k++)
3011 std::string item =
type(
k).xstring_value (
"%s: type(%d) must be a string", name,
k+1);
3014 type_string[
k] =
'{';
3015 else if (item ==
"()")
3016 type_string[
k] =
'(';
3017 else if (item ==
".")
3018 type_string[
k] =
'.';
3020 error (
"%s: invalid indexing type '%s'", name, item.c_str ());
3022 octave_value_list idx_item;
3024 if (
subs(
k).is_string ())
3025 idx_item(0) =
subs(
k);
3026 else if (
subs(
k).is_cell ())
3028 Cell subs_cell =
subs(
k).cell_value ();
3030 for (
int n = 0; n < subs_cell.
numel (); n++)
3032 if (subs_cell(n).is_string ()
3033 && subs_cell(n).string_value () ==
":")
3036 idx_item(n) = subs_cell(n);
3040 error (
"%s: subs(%d) must be a string or cell array", name,
k+1);
3042 idx.push_back (idx_item);
3082 if (
args.length () != 2)
3086 std::list<octave_value_list> idx;
3131 if (
args.length () != 3)
3135 std::list<octave_value_list> idx;
3142 return ovl (
args(2).storable_value ());
3237 if (
args.length () != 1)
3240 return ovl (
args(0).is_sq_string ());
3260 if (
args.length () != 1)
3263 return ovl (
args(0).is_dq_string ());
uint8NDArray uint8_array_value(void) const
static void register_type(void)
bool is_object(void) const
ColumnVector column_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
ComplexNDArray complex_array_value(bool frc_str_conv=false) const
const Cell & contents(const_iterator p) const
bool is_empty(void) const
void(* non_const_unary_op_fcn)(octave_base_value &)
virtual octave_fcn_handle * fcn_handle_value(bool silent=false)
octave_refcount< octave_idx_type > count
static OCTAVE_NORETURN void err_unary_op_conv(const std::string &on)
static OCTAVE_NORETURN void err_cat_op_conv(void)
octave_map xmap_value(const char *fmt,...) const
#define XVALUE_EXTRACTOR(TYPE, NAME, FCN)
octave_value(* binary_op_fcn)(const octave_base_value &, const octave_base_value &)
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx)
virtual octave_value_list do_multi_index_op(int nargout, const octave_value_list &idx)
octave_value & operator=(const octave_value &a)
const octave_base_value const Array< octave_idx_type > & ra_idx
octave_value reshape(const dim_vector &dv) const
octave_idx_type rows(void) const
virtual 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 do_cat_op(const octave_value &v1, const octave_value &v2, const Array< octave_idx_type > &ra_idx)
int8NDArray int8_array_value(void) const
nd group nd example oindent but is performed more efficiently If only and it is a scalar
virtual octave_map map_value(void) const
octave_base_value * empty_clone(void) const
static octave_value find_method(const std::string &name, const std::string &dispatch_type)
OCTAVE_EXPORT octave_value_list isa nd deftypefn *return ovl(args(0).is_integer_type())
FloatColumnVector float_column_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
bool is_uint16_type(void) const
static void register_type(void)
static void register_type(void)
OCTINTERP_API void print_usage(void)
static std::string binary_op_as_string(binary_op)
octave_idx_type numel(void) const
Number of elements in the array.
OCTAVE_EXPORT octave_value_list uint16
static bool Vdisable_range
F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T F77_REAL F77_REAL &F77_RET_T F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE const F77_DBLE * f
int16NDArray int16_array_value(void) const
octave_idx_type length(void) const
octave_map map_value(void) const
octave_value do_unary_op(octave_value::unary_op op, const octave_value &v)
idx subsref(val, idx) esult
octave_user_code * user_code_value(bool silent=false) const
static void register_type(void)
static assign_op binary_op_to_assign_op(binary_op)
bool contains(const std::string &name) const
bool is_defined(void) const
static non_const_unary_op_fcn lookup_non_const_unary_op(octave_value::unary_op op, int t)
static void register_type(void)
static void register_type(void)
int int_value(bool req_int=false, bool frc_str_conv=false) const
uint64NDArray uint64_array_value(void) const
int64_t int64_value(bool req_int=false, bool frc_str_conv=false) const
#define DEFUN(name, args_name, nargout_name, doc)
void error(const char *fmt,...)
int32NDArray int32_array_value(void) const
#define SET_INTERNAL_VARIABLE(NM)
static std::string unary_op_fcn_name(unary_op)
bool is_int8_type(void) const
static void register_type(void)
static void register_type(void)
static void register_type(void)
static binary_op assign_op_to_binary_op(assign_op)
octave_value(* binary_class_op_fcn)(const octave_value &, const octave_value &)
octave::mach_info::float_format flt_fmt
static void register_type(void)
static std::string assign_op_as_string(assign_op)
static void register_type(void)
static OCTAVE_NORETURN void err_unary_op_conversion_failed(const std::string &op, const std::string &tn)
T & elem(octave_idx_type n)
static binary_op_fcn lookup_binary_op(octave_value::binary_op op, int t1, int t2)
octave_idx_type numel(void) const
static void register_type(void)
OCTAVE_EXPORT octave_value_list return the number of command line arguments passed to Octave If called with the optional argument the function t
static void register_type(void)
bool is_int32_type(void) const
octave_fcn_handle * fcn_handle_value(bool silent=false) const
virtual octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx)
octave_idx_type idx_type_value(bool req_int=false, bool frc_str_conv=false) const
static void register_type(void)
binary_op op_eq_to_binary_op(assign_op op)
Array< Complex > complex_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value & do_non_const_unary_op(unary_op op)
octave_base_value * clone(void) const
octave_idx_type numel(int n=0) const
Number of elements that a matrix with this dimensions would have.
virtual octave_value subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_REAL const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T F77_DBLE &F77_RET_T F77_REAL &F77_RET_T F77_REAL &F77_RET_T F77_DBLE &F77_RET_T const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T F77_REAL F77_REAL &F77_RET_T F77_DBLE F77_DBLE &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE * d
virtual void print_info(std::ostream &os, const std::string &prefix) const
issues an error eealso single
octave_value subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
calling an anonymous function involves an overhead quite comparable to the overhead of an m file function Passing a handle to a built in function is because the interpreter is not involved in the internal loop For a
int64NDArray int64_array_value(void) const
Cell cell_value(void) const
static unary_class_op_fcn lookup_unary_class_op(octave_value::unary_op op)
octave_base_value::type_conv_info numeric_demotion_function(void) const
static bool Vdisable_permutation_matrix
virtual octave_value undef_subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
virtual octave_value_list list_value(void) const
const dim_vector & dims(void) const
Return a const-reference so that dims ()(i) works efficiently.
static void register_type(void)
octave_value single_subsref(const std::string &type, const octave_value_list &idx)
static void register_type(void)
octave_value_list do_multi_index_op(int nargout, const octave_value_list &idx)
virtual octave_fcn_inline * fcn_inline_value(bool silent=false)
static void register_type(void)
virtual octave_base_value * clone(void) const
octave_value(* cat_op_fcn)(octave_base_value &, const octave_base_value &, const Array< octave_idx_type > &ra_idx)
void print_info(std::ostream &os, const std::string &prefix="") const
octave_idx_type columns(void) const
virtual octave_base_value * try_narrowing_conversion(void)
static void register_type(void)
FloatNDArray float_array_value(bool frc_str_conv=false) const
static void register_type(void)
virtual octave_user_function * user_function_value(bool silent=false)
bool is_null_value(void) const
OCTAVE_EXPORT octave_value_list return the number of command line arguments passed to Octave If called with the optional argument the function xample nargout(@histc)
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
static void register_type(void)
octave_value convert_to_str(bool pad=false, bool force=false, char type= '\'') const
static OCTAVE_NORETURN void err_cat_op(const std::string &tn1, const std::string &tn2)
static const octave_value instance
virtual octave_scalar_map scalar_map_value(void) const
octave_idx_type nfields(void) const
octave_idx_type numel(const octave_value_list &idx)
static void register_type(void)
octave_value(* unary_op_fcn)(const octave_base_value &)
OCTAVE_EXPORT octave_value_list uint32
static void register_type(void)
void error_with_cfn(const char *fmt,...)
nd deftypefn *octave_map m
static void register_type(void)
then the function must return scalars which will be concatenated into the return array(s).If code
static void register_type(void)
octave_base_value::type_conv_info numeric_conversion_function(void) const
FloatComplexNDArray float_complex_array_value(bool frc_str_conv=false) const
bool is_string(void) const
OCTAVE_EXPORT octave_value_list int16
octave_user_function * user_function_value(bool silent=false) const
bool is_double_type(void) const
void maybe_economize(void)
static std::string binary_op_fcn_name(binary_op)
static void register_type(void)
static void register_type(void)
static void register_type(void)
Array< octave_idx_type > octave_idx_type_vector_value(bool req_int=false, bool frc_str_conv=false, bool frc_vec_conv=false) const
friend OCTINTERP_API octave_value do_binary_op(binary_op op, const octave_value &a, const octave_value &b)
void resize(const dim_vector &dv, const T &rfv)
octave_value & assign(assign_op op, const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
bool is_int64_type(void) const
virtual octave_base_value * empty_clone(void) const
#define panic_impossible()
FloatComplexRowVector float_complex_row_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
OCTAVE_EXPORT octave_value_list int32
static void register_type(void)
static int static_type_id(void)
assign_op unary_op_to_assign_op(unary_op op)
octave_idx_type length(void) const
static void register_type(void)
static binary_class_op_fcn lookup_binary_class_op(octave_value::binary_op op)
octave_value all(int dim=0) const
the sparsity preserving column transformation such that that defines the pivoting threshold can be given in which case it defines the c
dim_vector dims(void) const
virtual octave_user_code * user_code_value(bool silent=false)
Matrix matrix_value(bool frc_str_conv=false) const
static void register_type(void)
void make_storable_value(void)
static void register_type(void)
octave_function * function_value(bool silent=false) const
T & xelem(octave_idx_type n)
bool is_int16_type(void) const
OCTAVE_EXPORT octave_value_list int64
static octave_base_value * nil_rep(void)
std::string type_name(void) const
idx_class_type idx_class(void) const
static Array< octave_idx_type > convert_to_octave_idx_type_array(const Array< octave_int< T > > &A)
octave_value(* assign_op_fcn)(octave_base_value &, const octave_value_list &, const octave_base_value &)
bool is_empty(void) const
static OCTAVE_NORETURN void err_unary_op(const std::string &on, const std::string &tn)
octave_value undef_subsasgn(const std::string &type, const std::list< octave_value_list > &idx, const octave_value &rhs)
const octave_char_matrix & v2
NDArray array_value(bool frc_str_conv=false) const
static cat_op_fcn lookup_cat_op(int t1, int t2)
octave_base_value *(* type_conv_fcn)(const octave_base_value &)
FloatRowVector float_row_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
OCTAVE_EXPORT octave_value_list uint64 nd deftypefn *return args(0).as_int8()
octave_scalar_map scalar_map_value(void) const
ComplexRowVector complex_row_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
bool is_dq_string(void) const
static void register_type(void)
=val(i)}if ode{val(i)}occurs in table i
bool is_uint8_type(void) const
RowVector row_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
static bool Vdisable_diagonal_matrix
FloatComplexColumnVector float_complex_column_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
void warn_implicit_conversion(const char *id, const char *from, const char *to)
octave_value(* unary_class_op_fcn)(const octave_value &)
Array< double > vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
idx subsasgn(val, idx, 0) esult
octave_idx_type ndims(void) const
Number of dimensions.
std::string class_name(void) const
octave_idx_type get_count(void) const
static void register_type(void)
bool is_undefined(void) const
bool is_uint64_type(void) const
Array< T > reshape(octave_idx_type nr, octave_idx_type nc) const
void unconvert(idx_class_type &iclass, double &scalar, Range &range, Array< double > &array, Array< bool > &mask) const
static void decode_subscripts(const char *name, const octave_value &arg, std::string &type_string, std::list< octave_value_list > &idx)
octave_value_list list_value(void) const
std::complex< float > FloatComplex
ComplexColumnVector complex_column_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
Array< int > int_vector_value(bool req_int=false, bool frc_str_conv=false, bool frc_vec_conv=false) const
friend OCTINTERP_API octave_value do_unary_op(unary_op op, const octave_value &a)
static OCTAVE_NORETURN void err_binary_op(const std::string &on, const std::string &tn1, const std::string &tn2)
Array< FloatComplex > float_complex_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
static assign_op_fcn lookup_assign_op(octave_value::assign_op op, int t_lhs, int t_rhs)
std::complex< double > Complex
virtual octave_function * function_value(bool silent=false)
octave_fcn_inline * fcn_inline_value(bool silent=false) const
static std::string unary_op_as_string(unary_op)
static OCTAVE_NORETURN void err_binary_op_conv(const std::string &on)
static Array< int > convert_to_int_array(const Array< octave_int< T > > &A)
bool is_uint32_type(void) const
Vector representing the dimensions (size) of an Array.
static void register_type(void)
octave_user_script * user_script_value(bool silent=false) const
virtual Cell cell_value(void) const
octave_value storable_value(void) const
bool is_equal(const octave_value &) const
static void register_type(void)
void chop_trailing_singletons(void)
octave_value do_colon_op(const octave_value &base, const octave_value &increment, const octave_value &limit, bool is_for_cmd_expr)
uint32NDArray uint32_array_value(void) const
If this string is the system will ring the terminal sometimes it is useful to be able to print the original representation of the string
static dim_vector make_vector_dims(const dim_vector &dv, bool force_vector_conversion, const std::string &my_type, const std::string &wanted_type)
virtual octave_user_script * user_script_value(bool silent=false)
static int static_type_id(void)
uint16NDArray uint16_array_value(void) const
static void register_type(void)
bool is_zero_by_zero(void) const
octave_value next_subsref(const std::string &type, const std::list< octave_value_list > &idx, size_t skip=1)
OCTAVE_EXPORT octave_value_list or cell arrays Arguments are concatenated vertically The returned values are padded with blanks as needed to make each row of the string array have the same length Empty input strings are significant and will concatenated in the output For numerical each element is converted to the corresponding ASCII character A range error results if an input is outside the ASCII range(0-255).For cell arrays
return octave_value(v1.char_array_value().concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string())? '\'': '"'))
static octave_value empty_conv(const std::string &type, const octave_value &rhs=octave_value())
Array< float > float_vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
octave_value do_binary_op(octave_value::binary_op op, const octave_value &v1, const octave_value &v2)
static void register_type(void)
F77_RET_T const F77_INT F77_CMPLX * A
static void register_type(void)
static octave_value decompose_binary_op(octave_value::compound_binary_op op, const octave_value &v1, const octave_value &v2)
static unary_op_fcn lookup_unary_op(octave_value::unary_op op, int t)
bool is_integer_type(void) const
static void register_type(void)