24 #if ! defined (octave_ov_h) 27 #include "octave-config.h" 68 bool is_for_cmd_expr =
false);
73 bool is_for_cmd_expr =
false);
133 unknown_compound_binary_op
155 static binary_op assign_op_to_binary_op (assign_op);
157 static assign_op binary_op_to_assign_op (binary_op);
162 static std::string binary_op_as_string (binary_op);
165 static std::string binary_op_fcn_name (compound_binary_op);
167 static std::string assign_op_as_string (assign_op);
192 #if defined (OCTAVE_HAVE_LONG_LONG_INT) 195 #if defined (OCTAVE_HAVE_UNSIGNED_LONG_LONG_INT) 281 bool zero_based =
false,
bool cache_index =
false);
288 octave_value (
const std::map<std::string, octave_value>&);
290 const std::list<std::string>& plist);
292 const std::list<std::string>& plist);
294 OCTAVE_DEPRECATED (4.4,
"note: second argument is always ignored; use octave_value (const octave_value_list&) instead")
324 if (--rep->count == 0)
334 if (--rep->count == 0)
346 if (rep->count > obsolete_copies + 1)
350 if (--rep->count == 0)
363 if (--rep->count == 0)
376 {
return rep->numeric_conversion_function (); }
379 {
return rep->numeric_demotion_function (); }
381 void maybe_mutate (
void);
410 {
return rep->
size (); }
413 {
return rep->numel (idx); }
419 const std::list<octave_value_list>& idx)
423 const std::list<octave_value_list>& idx,
428 const std::list<octave_value_list>& idx,
432 std::list<octave_value_list>& idx,
437 std::list<octave_value_list>& idx,
441 std::list<octave_value_list>& idx,
445 bool resize_ok =
false)
449 const std::list<octave_value_list>& idx,
453 const std::list<octave_value_list>& idx,
457 const std::list<octave_value_list>& idx,
464 return rep->index_vector (require_integers);
470 {
return rep->dims (); }
478 int ndims (
void)
const {
return rep->ndims (); }
484 {
return (ndims () == 2 && rows () == 0 && columns () == 0); }
487 {
return rep->numel (); }
489 OCTAVE_DEPRECATED (4.4,
"use 'numel' instead")
491 {
return rep->numel (); }
494 {
return rep->byte_size (); }
506 {
return rep->
permute (vec, inv); }
509 {
return rep->
permute (vec,
true); }
524 {
return rep->is_defined (); }
527 {
return ! is_defined (); }
530 {
return rep->isempty (); }
532 OCTAVE_DEPRECATED (4.4,
"use 'isempty' instead")
534 {
return rep->isempty (); }
537 {
return rep->iscell (); }
539 OCTAVE_DEPRECATED (4.4,
"use 'iscell' instead")
541 {
return rep->iscell (); }
544 {
return rep->iscellstr (); }
546 OCTAVE_DEPRECATED (4.4,
"use 'iscellstr' instead")
548 {
return rep->iscellstr (); }
551 {
return rep->is_real_scalar (); }
554 {
return rep->is_real_matrix (); }
557 {
return rep->is_complex_scalar (); }
560 {
return rep->is_complex_matrix (); }
563 {
return rep->is_bool_scalar (); }
566 {
return rep->is_bool_matrix (); }
569 {
return rep->is_char_matrix (); }
572 {
return rep->is_diag_matrix (); }
575 {
return rep->is_perm_matrix (); }
578 {
return rep->is_string (); }
581 {
return rep->is_sq_string (); }
584 {
return rep->is_string () && ! rep->is_sq_string (); }
587 {
return rep->is_range (); }
590 {
return rep->isstruct (); }
592 OCTAVE_DEPRECATED (4.4,
"use 'isstruct' instead")
594 {
return rep->isstruct (); }
597 {
return rep->is_classdef_meta (); }
600 {
return rep->is_classdef_object (); }
603 {
return rep->is_classdef_superclass_ref (); }
606 {
return rep->is_package (); }
609 {
return rep->isobject (); }
611 OCTAVE_DEPRECATED (4.4,
"use 'isobject' instead")
613 {
return rep->isobject (); }
616 {
return rep->isjava (); }
618 OCTAVE_DEPRECATED (4.4,
"use 'isjava' instead")
620 {
return rep->isjava (); }
623 {
return rep->is_cs_list (); }
626 {
return rep->is_magic_colon (); }
629 {
return rep->isnull (); }
631 OCTAVE_DEPRECATED (4.4,
"use 'isnull' instead")
632 bool is_null_value (
void)
const 633 {
return rep->isnull (); }
638 {
return rep->
all (dim); }
641 {
return rep->
any (dim); }
644 {
return rep->builtin_type (); }
649 {
return rep->is_double_type (); }
652 {
return rep->is_single_type (); }
655 {
return rep->isfloat (); }
657 OCTAVE_DEPRECATED (4.4,
"use 'isfloat' instead")
658 bool is_float_type (
void)
const 659 {
return rep->isfloat (); }
664 {
return rep->is_int8_type (); }
667 {
return rep->is_int16_type (); }
670 {
return rep->is_int32_type (); }
673 {
return rep->is_int64_type (); }
676 {
return rep->is_uint8_type (); }
679 {
return rep->is_uint16_type (); }
682 {
return rep->is_uint32_type (); }
685 {
return rep->is_uint64_type (); }
688 {
return rep->isinteger (); }
690 OCTAVE_DEPRECATED (4.4,
"use 'isinteger' instead")
691 bool is_integer_type (
void)
const 692 {
return rep->isinteger (); }
697 {
return rep->islogical (); }
699 OCTAVE_DEPRECATED (4.4,
"use 'islogical' instead")
701 {
return rep->islogical (); }
704 {
return rep->isreal (); }
706 OCTAVE_DEPRECATED (4.4,
"use 'isreal' instead")
708 {
return rep->isreal (); }
711 {
return rep->iscomplex (); }
713 OCTAVE_DEPRECATED (4.4,
"use 'iscomplex' instead")
714 bool is_complex_type (
void)
const 715 {
return rep->iscomplex (); }
718 {
return rep->is_scalar_type (); }
721 {
return rep->is_matrix_type (); }
724 {
return rep->isnumeric (); }
726 OCTAVE_DEPRECATED (4.4,
"use 'isnumeric' instead")
727 bool is_numeric_type (
void)
const 728 {
return rep->isnumeric (); }
731 {
return rep->issparse (); }
733 OCTAVE_DEPRECATED (4.4,
"use 'issparse' instead")
734 bool is_sparse_type (
void)
const 735 {
return rep->issparse (); }
740 {
return rep->is_true (); }
747 {
return rep->is_constant (); }
750 {
return rep->is_function_handle (); }
753 {
return rep->is_anonymous_function (); }
756 {
return rep->is_inline_function (); }
759 {
return rep->is_function (); }
762 {
return rep->is_user_script (); }
765 {
return rep->is_user_function (); }
768 {
return rep->is_user_code (); }
771 {
return rep->is_builtin_function (); }
774 {
return rep->is_dld_function (); }
777 {
return rep->is_mex_function (); }
786 short_value (
bool req_int =
false,
bool frc_str_conv =
false)
const 787 {
return rep->short_value (req_int, frc_str_conv); }
791 {
return rep->ushort_value (req_int, frc_str_conv); }
793 int int_value (
bool req_int =
false,
bool frc_str_conv =
false)
const 794 {
return rep->int_value (req_int, frc_str_conv); }
797 uint_value (
bool req_int =
false,
bool frc_str_conv =
false)
const 798 {
return rep->uint_value (req_int, frc_str_conv); }
801 {
return rep->nint_value (frc_str_conv); }
804 long_value (
bool req_int =
false,
bool frc_str_conv =
false)
const 805 {
return rep->long_value (req_int, frc_str_conv); }
808 ulong_value (
bool req_int =
false,
bool frc_str_conv =
false)
const 809 {
return rep->ulong_value (req_int, frc_str_conv); }
812 int64_value (
bool req_int =
false,
bool frc_str_conv =
false)
const 813 {
return rep->int64_value (req_int, frc_str_conv); }
817 {
return rep->uint64_value (req_int, frc_str_conv); }
820 idx_type_value (
bool req_int =
false,
bool frc_str_conv =
false)
const;
823 {
return rep->double_value (frc_str_conv); }
826 {
return rep->float_value (frc_str_conv); }
829 {
return rep->scalar_value (frc_str_conv); }
832 {
return rep->float_scalar_value (frc_str_conv); }
835 {
return rep->matrix_value (frc_str_conv); }
838 {
return rep->float_matrix_value (frc_str_conv); }
841 {
return rep->array_value (frc_str_conv); }
844 {
return rep->float_array_value (frc_str_conv); }
847 {
return rep->complex_value (frc_str_conv); }
850 {
return rep->float_complex_value (frc_str_conv); }
853 {
return rep->complex_matrix_value (frc_str_conv); }
857 {
return rep->float_complex_matrix_value (frc_str_conv); }
860 {
return rep->complex_array_value (frc_str_conv); }
864 {
return rep->float_complex_array_value (frc_str_conv); }
867 {
return rep->bool_value (warn); }
870 {
return rep->bool_matrix_value (warn); }
873 {
return rep->bool_array_value (warn); }
876 {
return rep->char_matrix_value (frc_str_conv); }
879 {
return rep->char_array_value (frc_str_conv); }
882 {
return rep->sparse_matrix_value (frc_str_conv); }
886 {
return rep->sparse_complex_matrix_value (frc_str_conv); }
889 {
return rep->sparse_bool_matrix_value (warn); }
892 {
return rep->diag_matrix_value (force); }
895 {
return rep->float_diag_matrix_value (force); }
898 {
return rep->complex_diag_matrix_value (force); }
902 {
return rep->float_complex_diag_matrix_value (force); }
905 {
return rep->perm_matrix_value (); }
908 {
return rep->int8_scalar_value (); }
911 {
return rep->int16_scalar_value (); }
914 {
return rep->int32_scalar_value (); }
917 {
return rep->int64_scalar_value (); }
920 {
return rep->uint8_scalar_value (); }
923 {
return rep->uint16_scalar_value (); }
926 {
return rep->uint32_scalar_value (); }
929 {
return rep->uint64_scalar_value (); }
932 {
return rep->int8_array_value (); }
935 {
return rep->int16_array_value (); }
938 {
return rep->int32_array_value (); }
941 {
return rep->int64_array_value (); }
944 {
return rep->uint8_array_value (); }
947 {
return rep->uint16_array_value (); }
950 {
return rep->uint32_array_value (); }
953 {
return rep->uint64_array_value (); }
956 {
return rep->string_value (force); }
959 {
return rep->string_vector_value (pad); }
961 OCTAVE_DEPRECATED (4.4,
"use 'string_vector_value' instead")
963 {
return string_vector_value (pad); }
968 {
return rep->cellstr_value (); }
971 {
return rep->range_value (); }
978 {
return rep->map_keys (); }
981 {
return rep->nparents (); }
984 {
return rep->parent_class_name_list (); }
987 {
return rep->parent_class_names (); }
994 {
return rep->is_instance_of (cls_name); }
1012 ColumnVector column_vector_value (
bool frc_str_conv =
false,
1013 bool frc_vec_conv =
false)
const;
1016 complex_column_vector_value (
bool frc_str_conv =
false,
1017 bool frc_vec_conv =
false)
const;
1019 RowVector row_vector_value (
bool frc_str_conv =
false,
1020 bool frc_vec_conv =
false)
const;
1023 complex_row_vector_value (
bool frc_str_conv =
false,
1024 bool frc_vec_conv =
false)
const;
1027 bool frc_vec_conv =
false)
const;
1030 float_complex_column_vector_value (
bool frc_str_conv =
false,
1031 bool frc_vec_conv =
false)
const;
1033 FloatRowVector float_row_vector_value (
bool frc_str_conv =
false,
1034 bool frc_vec_conv =
false)
const;
1037 float_complex_row_vector_value (
bool frc_str_conv =
false,
1038 bool frc_vec_conv =
false)
const;
1040 Array<int> int_vector_value (
bool req_int =
false,
1041 bool frc_str_conv =
false,
1042 bool frc_vec_conv =
false)
const;
1045 octave_idx_type_vector_value (
bool req_int =
false,
1046 bool frc_str_conv =
false,
1047 bool frc_vec_conv =
false)
const;
1050 bool frc_vec_conv =
false)
const;
1053 bool frc_vec_conv =
false)
const;
1055 Array<float> float_vector_value (
bool frc_str_conv =
false,
1056 bool frc_vec_conv =
false)
const;
1059 float_complex_vector_value (
bool frc_str_conv =
false,
1060 bool frc_vec_conv =
false)
const;
1070 short int xshort_value (
const char *fmt, ...)
const;
1072 unsigned short int xushort_value (
const char *fmt, ...)
const;
1074 int xint_value (
const char *fmt, ...)
const;
1076 unsigned int xuint_value (
const char *fmt, ...)
const;
1078 int xnint_value (
const char *fmt, ...)
const;
1080 long int xlong_value (
const char *fmt, ...)
const;
1082 unsigned long int xulong_value (
const char *fmt, ...)
const;
1084 int64_t xint64_value (
const char *fmt, ...)
const;
1086 uint64_t xuint64_value (
const char *fmt, ...)
const;
1090 double xdouble_value (
const char *fmt, ...)
const;
1092 float xfloat_value (
const char *fmt, ...)
const;
1094 double xscalar_value (
const char *fmt, ...)
const;
1096 float xfloat_scalar_value (
const char *fmt, ...)
const;
1098 Matrix xmatrix_value (
const char *fmt, ...)
const;
1100 FloatMatrix xfloat_matrix_value (
const char *fmt, ...)
const;
1102 NDArray xarray_value (
const char *fmt, ...)
const;
1104 FloatNDArray xfloat_array_value (
const char *fmt, ...)
const;
1106 Complex xcomplex_value (
const char *fmt, ...)
const;
1108 FloatComplex xfloat_complex_value (
const char *fmt, ...)
const;
1110 ComplexMatrix xcomplex_matrix_value (
const char *fmt, ...)
const;
1114 ComplexNDArray xcomplex_array_value (
const char *fmt, ...)
const;
1118 bool xbool_value (
const char *fmt, ...)
const;
1120 boolMatrix xbool_matrix_value (
const char *fmt, ...)
const;
1122 boolNDArray xbool_array_value (
const char *fmt, ...)
const;
1124 charMatrix xchar_matrix_value (
const char *fmt, ...)
const;
1126 charNDArray xchar_array_value (
const char *fmt, ...)
const;
1128 SparseMatrix xsparse_matrix_value (
const char *fmt, ...)
const;
1134 DiagMatrix xdiag_matrix_value (
const char *fmt, ...)
const;
1136 FloatDiagMatrix xfloat_diag_matrix_value (
const char *fmt, ...)
const;
1142 PermMatrix xperm_matrix_value (
const char *fmt, ...)
const;
1144 octave_int8 xint8_scalar_value (
const char *fmt, ...)
const;
1146 octave_int16 xint16_scalar_value (
const char *fmt, ...)
const;
1148 octave_int32 xint32_scalar_value (
const char *fmt, ...)
const;
1150 octave_int64 xint64_scalar_value (
const char *fmt, ...)
const;
1152 octave_uint8 xuint8_scalar_value (
const char *fmt, ...)
const;
1154 octave_uint16 xuint16_scalar_value (
const char *fmt, ...)
const;
1156 octave_uint32 xuint32_scalar_value (
const char *fmt, ...)
const;
1158 octave_uint64 xuint64_scalar_value (
const char *fmt, ...)
const;
1160 int8NDArray xint8_array_value (
const char *fmt, ...)
const;
1162 int16NDArray xint16_array_value (
const char *fmt, ...)
const;
1164 int32NDArray xint32_array_value (
const char *fmt, ...)
const;
1166 int64NDArray xint64_array_value (
const char *fmt, ...)
const;
1168 uint8NDArray xuint8_array_value (
const char *fmt, ...)
const;
1170 uint16NDArray xuint16_array_value (
const char *fmt, ...)
const;
1172 uint32NDArray xuint32_array_value (
const char *fmt, ...)
const;
1174 uint64NDArray xuint64_array_value (
const char *fmt, ...)
const;
1176 std::string xstring_value (
const char *fmt, ...)
const;
1178 string_vector xstring_vector_value (
const char *fmt, ...)
const;
1180 Cell xcell_value (
const char *fmt, ...)
const;
1184 Range xrange_value (
const char *fmt, ...)
const;
1186 octave_map xmap_value (
const char *fmt, ...)
const;
1190 ColumnVector xcolumn_vector_value (
const char *fmt, ...)
const;
1193 xcomplex_column_vector_value (
const char *fmt, ...)
const;
1195 RowVector xrow_vector_value (
const char *fmt, ...)
const;
1202 xfloat_complex_column_vector_value (
const char *fmt, ...)
const;
1204 FloatRowVector xfloat_row_vector_value (
const char *fmt, ...)
const;
1207 xfloat_complex_row_vector_value (
const char *fmt, ...)
const;
1209 Array<int> xint_vector_value (
const char *fmt, ...)
const;
1212 xoctave_idx_type_vector_value (
const char *fmt, ...)
const;
1216 Array<Complex> xcomplex_vector_value (
const char *fmt, ...)
const;
1218 Array<float> xfloat_vector_value (
const char *fmt, ...)
const;
1234 { rep->maybe_economize (); }
1245 void make_storable_value (
void);
1252 char type =
'\'')
const 1260 { rep->convert_to_row_or_column_vector (); }
1263 {
return rep->print_as_scalar (); }
1265 void print (std::ostream&
os,
bool pr_as_read_syntax =
false)
1266 { rep->print (
os, pr_as_read_syntax); }
1268 void print_raw (std::ostream&
os,
bool pr_as_read_syntax =
false)
const 1269 { rep->print_raw (
os, pr_as_read_syntax); }
1272 {
return rep->print_name_tag (
os,
name); }
1275 { rep->print_with_name (
os,
name,
true); }
1284 return rep->edit_display (fmt,
i, j);
1287 int type_id (
void)
const {
return rep->type_id (); }
1301 const std::list<octave_value_list>& idx);
1317 bool is_for_cmd_expr)
1325 bool is_for_cmd_expr);
1331 void print_info (std::ostream&
os,
1343 {
return rep->load_binary (
is,
swap, fmt); }
1350 {
return rep->load_hdf5 (loc_id,
name); }
1369 {
return rep->
diag (
k); }
1372 {
return rep->
diag (m, n); }
1378 {
return rep->
sort (sidx, dim,
mode); }
1381 {
return rep->issorted (
mode); }
1383 OCTAVE_DEPRECATED (4.4,
"use 'issorted' instead")
1385 {
return rep->issorted (
mode); }
1391 {
return rep->is_sorted_rows (
mode); }
1397 bool islocked (
void)
const {
return rep->islocked (); }
1401 #define MAPPER_FORWARD(F) \ 1402 octave_value F (void) const \ 1404 return rep->map (octave_base_value::umap_ ## F); \ 1471 #undef MAPPER_FORWARD 1474 {
return rep->
map (umap); }
1499 return rep->fast_elem_insert (n,
x);
1555 #define OV_UNOP_FN(name) \ 1556 inline octave_value \ 1557 name (const octave_value& a) \ 1559 return do_unary_op (octave_value::name, a); \ 1562 #define OV_UNOP_OP(name, op) \ 1563 inline octave_value \ 1564 operator op (const octave_value& a) \ 1569 #define OV_UNOP_FN_OP(name, op) \ 1571 OV_UNOP_OP (name, op) 1585 #define OV_BINOP_FN(name) \ 1586 inline octave_value \ 1587 name (const octave_value& a1, const octave_value& a2) \ 1589 return do_binary_op (octave_value::name, a1, a2); \ 1592 #define OV_BINOP_OP(name, op) \ 1593 inline octave_value \ 1594 operator op (const octave_value& a1, const octave_value& a2) \ 1596 return name (a1, a2); \ 1599 #define OV_BINOP_FN_OP(name, op) \ 1600 OV_BINOP_FN (name) \ 1601 OV_BINOP_OP (name, op) 1627 #define OV_COMP_BINOP_FN(name) \ 1628 inline octave_value \ 1629 name (const octave_value& a1, const octave_value& a2) \ 1631 return do_binary_op (octave_value::name, a1, a2); \ 1642 template <typename Value>
1646 #define DEF_VALUE_EXTRACTOR(VALUE,MPREFIX) \ 1648 inline VALUE octave_value_extract<VALUE> (const octave_value& v) \ 1650 return v.MPREFIX ## _value (); \ 1709 #undef DEF_VALUE_EXTRACTOR 1711 #define DEF_DUMMY_VALUE_EXTRACTOR(VALUE,DEFVAL) \ 1713 inline VALUE octave_value_extract<VALUE> (const octave_value&) \ 1721 #undef DEF_DUMMY_VALUE_EXTRACTOR
bool is_dld_function(void) const
FloatComplex float_complex_value(bool frc_str_conv=false) const
octave_value ipermute(const Array< int > &vec) const
bool is_bool_scalar(void) const
octave_value as_uint16(void) const
octave_value op_mul_trans(const octave_value &a1, const octave_value &a2)
octave_value as_int32(void) const
octave_value map(octave_base_value::unary_mapper_t umap) const
octave_value op_uplus(const octave_value &a)
octave_base_value * internal_rep(void) const
int int_value(bool req_int=false, bool frc_str_conv=false) const
bool is_user_code(void) const
bool is_uint32_type(void) const
Range range_value(void) const
bool is_user_function(void) const
#define OV_BINOP_FN_OP(name, op)
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx)
bool is_instance_of(const std::string &cls_name) const
octave_value op_el_pow(const octave_value &a1, const octave_value &a2)
const octave_base_value const Array< octave_idx_type > & ra_idx
characters Given a string matrix
octave_value as_int8(void) const
std::string string_value(bool force=false) const
octave_int16 int16_scalar_value(void) const
octave_value as_single(void) const
octave_value diag(octave_idx_type m, octave_idx_type n) const
octave_value op_eq(const octave_value &a1, const octave_value &a2)
bool save_hdf5(octave_hdf5_id loc_id, const char *name, bool save_as_floats)
nd group nd example oindent but is performed more efficiently If only and it is a scalar
octave_uint64 uint64_scalar_value(void) const
unsigned long int ulong_value(bool req_int=false, bool frc_str_conv=false) const
bool islogical(void) const
void print_with_name(std::ostream &os, const std::string &name) const
std::complex< double > erfi(std::complex< double > z, double relerr=0)
idx_vector index_vector(bool require_integers=false) const
bool is_mex_function(void) const
identity matrix If supplied two scalar respectively For allows like xample val
bool is_real_matrix(void) const
octave_value as_int64(void) const
int nint_value(bool frc_str_conv=false) const
octave_base_value * empty_clone(void) const
Return the CPU time used by your Octave session The first output is the total time spent executing your process and is equal to the sum of second and third which are the number of CPU seconds spent executing in user mode and the number of CPU seconds spent executing in system mode
idx subsref(val, idx) esult
bool is_classdef_superclass_ref(void) const
int64_t int64_value(bool req_int=false, bool frc_str_conv=false) const
octave_value squeeze(void) const
bool all_zero_dims(void) const
octave_value op_el_ldiv(const octave_value &a1, const octave_value &a2)
bool is_cs_list(void) const
octave_uint32 uint32_scalar_value(void) const
bool is_anonymous_function(void) const
OCTAVE_EXPORT octave_value_list or N dimensional array whose elements are all equal to the base of natural logarithms The constant ex $e satisfies the equation log(e)
octave_value all(int dim=0) const
int32NDArray int32_array_value(void) const
std::complex< T > ceil(const std::complex< T > &x)
bool is_complex_scalar(void) const
std::complex< T > floor(const std::complex< T > &x)
bool is_magic_colon(void) const
uint64_t uint64_value(bool req_int=false, bool frc_str_conv=false) const
DiagMatrix diag_matrix_value(bool force=false) const
FloatDiagMatrix float_diag_matrix_value(bool force=false) const
Array< octave_idx_type > sort_rows_idx(sortmode mode=ASCENDING) const
Sort by rows returns only indices.
octave_value op_pow(const octave_value &a1, const octave_value &a2)
octave_base_value * try_narrowing_conversion(void)
Array< octave_idx_type > sort_rows_idx(sortmode mode=ASCENDING) const
octave::mach_info::float_format flt_fmt
bool is_defined(void) const
const octave_base_value & get_rep(void) const
octave_int8 int8_scalar_value(void) const
Complex acos(const Complex &x)
MatrixType matrix_type(const MatrixType &typ) const
Complex atan(const Complex &x)
OCTAVE_EXPORT octave_value_list return the number of command line arguments passed to Octave If called with the optional argument the function t
bool is_constant(void) const
FloatMatrix float_matrix_value(bool frc_str_conv=false) const
Complex complex_value(bool frc_str_conv=false) const
bool is_perm_matrix(void) const
nd example oindent opens the file binary numeric values will be read assuming they are stored in IEEE format with the least significant bit and then converted to the native representation Opening a file that is already open simply opens it again and returns a separate file id It is not an error to open a file several though writing to the same file through several different file ids may produce unexpected results The possible values of text mode reading and writing automatically converts linefeeds to the appropriate line end character for the you may append a you must also open the file in binary mode The parameter conversions are currently only supported for and permissions will be set to and then everything is written in a single operation This is very efficient and improves performance c
FloatNDArray float_array_value(bool frc_str_conv=false) const
Complex asin(const Complex &x)
#define DEF_VALUE_EXTRACTOR(VALUE, MPREFIX)
bool isobject(void) const
Complex log2(const Complex &x)
bool is_int16_type(void) const
std::complex< double > erf(std::complex< double > z, double relerr=0)
float float_value(bool frc_str_conv=false) const
charMatrix char_matrix_value(bool frc_str_conv=false) const
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 const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T const F77_DBLE const F77_DBLE F77_DBLE * d
octave_base_value * rep
The real representation.
bool is_user_script(void) const
OCTINTERP_API void install_types(octave::type_info &)
octave_value resize(const dim_vector &dv, bool fill=false) const
bool is_dq_string(void) const
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
uint32NDArray uint32_array_value(void) const
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx, bool auto_add)
FloatComplexMatrix float_complex_matrix_value(bool frc_str_conv=false) const
charNDArray char_array_value(bool frc_str_conv=false) const
bool iscellstr(void) const
sortmode is_sorted_rows(sortmode mode=UNSORTED) const
octave_value op_div(const octave_value &a1, const octave_value &a2)
then the function must return scalars which will be concatenated into the return array(s). If code
octave_value sort(octave_idx_type dim=0, sortmode mode=ASCENDING) const
bool bool_value(bool warn=false) const
octave_value dump(void) const
Complex expm1(const Complex &x)
octave_value sort(Array< octave_idx_type > &sidx, octave_idx_type dim=0, sortmode mode=ASCENDING) const
int16NDArray int16_array_value(void) const
octave_value as_uint64(void) const
octave_value op_el_or(const octave_value &a1, const octave_value &a2)
ComplexColumnVector conj(const ComplexColumnVector &a)
virtual octave_base_value * try_narrowing_conversion(void)
nd deftypefn *std::string name
size_t byte_size(void) const
virtual octave_base_value * find_parent_class(const std::string &)
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)
bool is_function_handle(void) const
octave_value op_not(const octave_value &a)
void print_raw(std::ostream &os, bool pr_as_read_syntax=false) const
octave_idx_type numel(const octave_value_list &idx)
octave_uint8 uint8_scalar_value(void) const
void print(std::ostream &os, bool pr_as_read_syntax=false)
octave_base_value::type_conv_info numeric_demotion_function(void) const
void * mex_get_data(void) const
#define DEF_DUMMY_VALUE_EXTRACTOR(VALUE, DEFVAL)
Complex log1p(const Complex &x)
octave_idx_type columns(void) const
ComplexDiagMatrix complex_diag_matrix_value(bool force=false) const
bool is_uint64_type(void) const
octave_value op_trans_mul(const octave_value &a1, const octave_value &a2)
OCTINTERP_API octave_value do_binary_op(octave::type_info &ti, octave_value::binary_op op, const octave_value &a, const octave_value &b)
bool load_hdf5(octave_hdf5_id loc_id, const char *name)
octave_value any(int dim=0) const
octave_value op_transpose(const octave_value &a)
bool is_single_type(void) const
Value octave_value_extract(const octave_value &)
double scalar_value(bool frc_str_conv=false) const
octave_value convert_to_str_internal(bool pad, bool force, char type) const
bool save_binary(std::ostream &os, bool &save_as_floats)
void maybe_economize(void)
dim_vector dims(void) const
octave_value op_el_and(const octave_value &a1, const octave_value &a2)
octave_value permute(const Array< int > &vec, bool inv=false) const
bool isinteger(void) const
octave_idx_type rows(void) const
bool issparse(void) const
size_type size(const size_type d) const
Size of the specified dimension.
octave_base_value * find_parent_class(const std::string &parent_class_name)
uint64NDArray uint64_array_value(void) const
std::list< std::string > parent_class_name_list(void) const
bool is_char_matrix(void) const
bool is_complex_matrix(void) const
bool islocked(void) const
octave_value op_mul_herm(const octave_value &a1, const octave_value &a2)
std::complex< double > erfcx(std::complex< double > z, double relerr=0)
bool is_zero_by_zero(void) const
std::string class_name(void) const
string_vector parent_class_names(void) const
bool is_function(void) const
bool is_package(void) const
bool isstruct(void) const
the exceeded dimensions are set to if fewer subscripts than dimensions are the exceeding dimensions are merged into the final requested dimension For consider the following dims
bool is_int8_type(void) const
octave_value op_le(const octave_value &a1, const octave_value &a2)
bool is_bool_matrix(void) const
octave_idx_type get_count(void) const
octave_value op_lt(const octave_value &a1, const octave_value &a2)
void erase_subfunctions(void)
octave_value convert_to_str(bool pad=false, bool force=false, char type='\'') const
octave_value as_int16(void) const
FloatComplexNDArray float_complex_array_value(bool frc_str_conv=false) const
string_vector map_keys(void) const
#define OV_COMP_BINOP_FN(name)
bool is_int32_type(void) const
octave_value op_el_div(const octave_value &a1, const octave_value &a2)
SparseComplexMatrix sparse_complex_matrix_value(bool frc_str_conv=false) const
virtual octave_base_value * unique_clone(void)
OCTINTERP_API octave_value do_unary_op(octave::type_info &ti, octave_value::unary_op op, const octave_value &a)
octave_uint16 uint16_scalar_value(void) const
octave_value as_uint32(void) const
void short_disp(std::ostream &os) const
bool save_ascii(std::ostream &os)
bool fast_elem_insert(octave_idx_type n, const octave_value &x)
Assign the n-th element, aka val(n) = x.
#define OV_BINOP_FN(name)
octave_base_value::type_conv_info numeric_conversion_function(void) const
octave_value reshape(const dim_vector &dv) const
octave_value diag(octave_idx_type k=0) const
return octave_value(v1.char_array_value() . concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string()) ? '\'' :'"'))
short int short_value(bool req_int=false, bool frc_str_conv=false) const
MatrixType matrix_type(void) const
FloatComplexDiagMatrix float_complex_diag_matrix_value(bool force=false) const
builtin_type_t builtin_type(void) const
boolNDArray bool_array_value(bool warn=false) const
long int long_value(bool req_int=false, bool frc_str_conv=false) const
OCTINTERP_API octave_value do_cat_op(octave::type_info &ti, const octave_value &a, const octave_value &b, const Array< octave_idx_type > &ra_idx)
bool is_undefined(void) const
bool is_builtin_function(void) const
bool is_sq_string(void) const
octave_value op_ne(const octave_value &a1, const octave_value &a2)
bool load_ascii(std::istream &is)
octave_idx_type * mex_get_ir(void) const
std::string edit_display(const float_display_format &fmt, octave_idx_type i, octave_idx_type j) const
octave_int32 int32_scalar_value(void) const
bool print_as_scalar(void) const
octave_idx_type nnz(void) const
uint16NDArray uint16_array_value(void) const
bool is_int64_type(void) const
bool print_name_tag(std::ostream &os, const std::string &name) const
octave_value full_value(void) const
bool is_copy_of(const octave_value &val) const
idx subsasgn(val, idx, 0) esult
Cell cell_value(void) const
double double_value(bool frc_str_conv=false) const
int64NDArray int64_array_value(void) const
float float_scalar_value(bool frc_str_conv=false) const
int8NDArray int8_array_value(void) const
SparseMatrix sparse_matrix_value(bool frc_str_conv=false) const
octave_value op_struct_ref(const octave_value &a1, const octave_value &a2)
octave_idx_type numel(void) const
octave_value op_add(const octave_value &a1, const octave_value &a2)
void make_unique(int obsolete_copies)
octave_value op_ldiv(const octave_value &a1, const octave_value &a2)
boolMatrix bool_matrix_value(bool warn=false) const
bool iscomplex(void) const
octave_idx_type nfields(void) const
ColumnVector imag(const ComplexColumnVector &a)
octave_value op_sub(const octave_value &a1, const octave_value &a2)
SparseBoolMatrix sparse_bool_matrix_value(bool warn=false) const
bool is_diag_matrix(void) const
PermMatrix perm_matrix_value(void) const
string_vector string_vector_value(bool pad=false) const
bool is_string(void) const
std::complex< float > FloatComplex
bool is_double_type(void) const
octave_value op_el_mul(const octave_value &a1, const octave_value &a2)
bool is_classdef_meta(void) const
size_t nparents(void) const
octave_value op_herm_mul(const octave_value &a1, const octave_value &a2)
mxArray * as_mxArray(void) const
ComplexMatrix complex_matrix_value(bool frc_str_conv=false) const
std::complex< double > Complex
#define MAPPER_FORWARD(F)
#define OV_UNOP_FN_OP(name, op)
bool is_range(void) const
octave_value op_hermitian(const octave_value &a)
octave_value as_uint8(void) const
ColumnVector real(const ComplexColumnVector &a)
write the output to stdout if nargout is
ComplexNDArray complex_array_value(bool frc_str_conv=false) const
octave_value op_ge(const octave_value &a1, const octave_value &a2)
sortmode issorted(sortmode mode=UNSORTED) const
octave_idx_type * mex_get_jc(void) const
Vector representing the dimensions (size) of an Array.
bool is_uint8_type(void) const
octave_value as_double(void) const
Array< std::string > cellstr_value(void) const
bool load_binary(std::istream &is, bool swap, octave::mach_info::float_format fmt)
octave_value op_uminus(const octave_value &a)
std::string type_name(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
bool is_real_scalar(void) const
unsigned short int ushort_value(bool req_int=false, bool frc_str_conv=false) const
OCTINTERP_API octave_value do_colon_op(const octave_value &base, const octave_value &limit, bool is_for_cmd_expr=false)
octave_value op_mul(const octave_value &a1, const octave_value &a2)
unsigned int uint_value(bool req_int=false, bool frc_str_conv=false) const
bool is_scalar_type(void) const
void convert_to_row_or_column_vector(void)
bool is_classdef_object(void) const
NDArray array_value(bool frc_str_conv=false) const
bool isnumeric(void) const
octave_idx_type nzmax(void) const
bool is_matrix_type(void) const
Matrix matrix_value(bool frc_str_conv=false) const
octave_value op_gt(const octave_value &a1, const octave_value &a2)
octave_int64 int64_scalar_value(void) const
uint8NDArray uint8_array_value(void) const
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 const F77_DBLE F77_DBLE &F77_RET_T const F77_REAL F77_REAL &F77_RET_T const F77_DBLE * x
bool is_inline_function(void) const
static int xisascii(int c)
virtual octave_base_value * empty_clone(void) const
octave_value_list & operator=(const octave_value_list &obj)
static float_display_format get_edit_display_format(const octave_value &val)
bool is_uint16_type(void) const
std::complex< double > erfc(std::complex< double > z, double relerr=0)
octave_value fast_elem_extract(octave_idx_type n) const
Extract the n-th element, aka val(n).
octave_value do_index_op(const octave_value_list &idx, bool resize_ok=false)
1.8.14