24 #if ! defined (octave_ov_h)
27 #include "octave-config.h"
63 bool is_for_cmd_expr =
false);
68 bool is_for_cmd_expr =
false);
128 unknown_compound_binary_op
150 static binary_op assign_op_to_binary_op (assign_op);
152 static assign_op binary_op_to_assign_op (binary_op);
157 static std::string binary_op_as_string (binary_op);
160 static std::string binary_op_fcn_name (compound_binary_op);
162 static std::string assign_op_as_string (assign_op);
187 #if defined (OCTAVE_HAVE_LONG_LONG_INT)
190 #if defined (OCTAVE_HAVE_UNSIGNED_LONG_LONG_INT)
243 OCTAVE_DEPRECATED (
"note: IS_STRING argument is ignored")
246 OCTAVE_DEPRECATED ("note: IS_STRING
argument is ignored")
249 OCTAVE_DEPRECATED ("note: IS_STRING
argument is ignored")
255 const MatrixType&
t = MatrixType ());
258 const MatrixType&
t = MatrixType ());
285 bool zero_based =
false,
bool cache_index = false);
301 OCTAVE_DEPRECATED ("note: in the future there will be no way
to directly set reference count")
323 if (--rep->count == 0)
333 if (--rep->count == 0)
345 if (rep->count > obsolete_copies + 1)
349 if (--rep->count == 0)
362 if (--rep->count == 0)
375 {
return rep->numeric_conversion_function (); }
378 {
return rep->numeric_demotion_function (); }
380 void maybe_mutate (
void);
409 {
return rep->
size (); }
412 {
return rep->numel (idx); }
418 const std::list<octave_value_list>&
idx)
419 {
return rep->
subsref (type, idx); }
422 const std::list<octave_value_list>&
idx,
424 {
return rep->
subsref (type, idx, auto_add); }
427 const std::list<octave_value_list>&
idx,
431 const std::list<octave_value_list>&
idx,
433 const std::list<octave_lvalue> *lvalue_list);
436 std::list<octave_value_list>&
idx,
441 std::list<octave_value_list>&
idx,
446 std::list<octave_value_list>&
idx,
447 const std::list<octave_lvalue> *lvalue_list,
451 std::list<octave_value_list>&
idx,
455 bool resize_ok =
false)
463 const std::list<octave_lvalue> *lvalue_list);
466 const std::list<octave_value_list>&
idx,
470 const std::list<octave_value_list>&
idx,
474 const std::list<octave_value_list>&
idx,
481 return rep->index_vector (require_integers);
487 {
return rep->dims (); }
495 int ndims (
void)
const {
return rep->ndims (); }
500 {
return rep->numel (); }
502 OCTAVE_DEPRECATED (
"use 'numel' instead")
504 {
return rep->numel (); }
507 {
return rep->byte_size (); }
519 {
return rep->
permute (vec, inv); }
522 {
return rep->
permute (vec,
true); }
525 {
return rep->
resize (dv, fill);}
537 {
return rep->is_defined (); }
543 {
return rep->is_empty (); }
546 {
return rep->is_cell (); }
549 {
return rep->is_cellstr (); }
552 {
return rep->is_real_scalar (); }
555 {
return rep->is_real_matrix (); }
558 {
return rep->is_complex_scalar (); }
561 {
return rep->is_complex_matrix (); }
564 {
return rep->is_bool_scalar (); }
567 {
return rep->is_bool_matrix (); }
570 {
return rep->is_char_matrix (); }
573 {
return rep->is_diag_matrix (); }
576 {
return rep->is_perm_matrix (); }
579 {
return rep->is_string (); }
582 {
return rep->is_sq_string (); }
585 {
return rep->is_string () && ! rep->is_sq_string (); }
588 {
return rep->is_range (); }
591 {
return rep->is_map (); }
594 {
return rep->is_object (); }
597 {
return rep->is_classdef_object (); }
600 {
return rep->is_java (); }
603 {
return rep->is_cs_list (); }
606 {
return rep->is_magic_colon (); }
609 {
return rep->is_null_value (); }
614 {
return rep->
all (dim); }
617 {
return rep->
any (dim); }
620 {
return rep->builtin_type (); }
625 {
return rep->is_double_type (); }
628 {
return rep->is_single_type (); }
631 {
return rep->is_float_type (); }
636 {
return rep->is_int8_type (); }
639 {
return rep->is_int16_type (); }
642 {
return rep->is_int32_type (); }
645 {
return rep->is_int64_type (); }
648 {
return rep->is_uint8_type (); }
651 {
return rep->is_uint16_type (); }
654 {
return rep->is_uint32_type (); }
657 {
return rep->is_uint64_type (); }
662 {
return rep->is_bool_type (); }
665 {
return rep->is_integer_type (); }
668 {
return rep->is_real_type (); }
671 {
return rep->is_complex_type (); }
674 {
return rep->is_scalar_type (); }
677 {
return rep->is_matrix_type (); }
680 {
return rep->is_numeric_type (); }
683 {
return rep->is_sparse_type (); }
688 {
return rep->is_true (); }
697 {
return (ndims () == 2 && rows () == 0 && columns () == 0); }
700 {
return rep->is_constant (); }
703 {
return rep->is_function_handle (); }
706 {
return rep->is_anonymous_function (); }
709 {
return rep->is_inline_function (); }
712 {
return rep->is_function (); }
715 {
return rep->is_user_script (); }
718 {
return rep->is_user_function (); }
721 {
return rep->is_user_code (); }
724 {
return rep->is_builtin_function (); }
727 {
return rep->is_dld_function (); }
730 {
return rep->is_mex_function (); }
739 short_value (
bool req_int =
false,
bool frc_str_conv =
false)
const
740 {
return rep->short_value (req_int, frc_str_conv); }
744 {
return rep->ushort_value (req_int, frc_str_conv); }
746 int int_value (
bool req_int =
false,
bool frc_str_conv =
false)
const
747 {
return rep->int_value (req_int, frc_str_conv); }
750 uint_value (
bool req_int =
false,
bool frc_str_conv =
false)
const
751 {
return rep->uint_value (req_int, frc_str_conv); }
754 {
return rep->nint_value (frc_str_conv); }
757 long_value (
bool req_int =
false,
bool frc_str_conv =
false)
const
758 {
return rep->long_value (req_int, frc_str_conv); }
761 ulong_value (
bool req_int =
false,
bool frc_str_conv =
false)
const
762 {
return rep->ulong_value (req_int, frc_str_conv); }
765 int64_value (
bool req_int =
false,
bool frc_str_conv =
false)
const
766 {
return rep->int64_value (req_int, frc_str_conv); }
770 {
return rep->uint64_value (req_int, frc_str_conv); }
773 idx_type_value (
bool req_int =
false,
bool frc_str_conv =
false)
const;
776 {
return rep->double_value (frc_str_conv); }
779 {
return rep->float_value (frc_str_conv); }
782 {
return rep->scalar_value (frc_str_conv); }
785 {
return rep->float_scalar_value (frc_str_conv); }
788 {
return rep->matrix_value (frc_str_conv); }
791 {
return rep->float_matrix_value (frc_str_conv); }
794 {
return rep->array_value (frc_str_conv); }
797 {
return rep->float_array_value (frc_str_conv); }
800 {
return rep->complex_value (frc_str_conv); }
803 {
return rep->float_complex_value (frc_str_conv); }
806 {
return rep->complex_matrix_value (frc_str_conv); }
810 {
return rep->float_complex_matrix_value (frc_str_conv); }
813 {
return rep->complex_array_value (frc_str_conv); }
817 {
return rep->float_complex_array_value (frc_str_conv); }
820 {
return rep->bool_value (warn); }
823 {
return rep->bool_matrix_value (warn); }
826 {
return rep->bool_array_value (warn); }
829 {
return rep->char_matrix_value (frc_str_conv); }
832 {
return rep->char_array_value (frc_str_conv); }
835 {
return rep->sparse_matrix_value (frc_str_conv); }
839 {
return rep->sparse_complex_matrix_value (frc_str_conv); }
842 {
return rep->sparse_bool_matrix_value (warn); }
845 {
return rep->diag_matrix_value (force); }
848 {
return rep->float_diag_matrix_value (force); }
851 {
return rep->complex_diag_matrix_value (force); }
855 {
return rep->float_complex_diag_matrix_value (force); }
858 {
return rep->perm_matrix_value (); }
861 {
return rep->int8_scalar_value (); }
864 {
return rep->int16_scalar_value (); }
867 {
return rep->int32_scalar_value (); }
870 {
return rep->int64_scalar_value (); }
873 {
return rep->uint8_scalar_value (); }
876 {
return rep->uint16_scalar_value (); }
879 {
return rep->uint32_scalar_value (); }
882 {
return rep->uint64_scalar_value (); }
885 {
return rep->int8_array_value (); }
888 {
return rep->int16_array_value (); }
891 {
return rep->int32_array_value (); }
894 {
return rep->int64_array_value (); }
897 {
return rep->uint8_array_value (); }
900 {
return rep->uint16_array_value (); }
903 {
return rep->uint32_array_value (); }
906 {
return rep->uint64_array_value (); }
909 {
return rep->string_value (force); }
912 {
return rep->string_vector_value (pad); }
914 OCTAVE_DEPRECATED (
"use 'string_vector_value' instead")
916 {
return string_vector_value (pad); }
918 Cell cell_value (
void)
const;
921 {
return rep->cellstr_value (); }
924 {
return rep->range_value (); }
931 {
return rep->map_keys (); }
934 {
return rep->nparents (); }
937 {
return rep->parent_class_name_list (); }
940 {
return rep->parent_class_names (); }
947 {
return rep->is_instance_of (cls_name); }
963 ColumnVector column_vector_value (
bool frc_str_conv =
false,
964 bool frc_vec_conv =
false)
const;
967 complex_column_vector_value (
bool frc_str_conv =
false,
968 bool frc_vec_conv =
false)
const;
970 RowVector row_vector_value (
bool frc_str_conv =
false,
971 bool frc_vec_conv =
false)
const;
974 complex_row_vector_value (
bool frc_str_conv =
false,
975 bool frc_vec_conv =
false)
const;
978 bool frc_vec_conv =
false)
const;
981 float_complex_column_vector_value (
bool frc_str_conv =
false,
982 bool frc_vec_conv =
false)
const;
985 bool frc_vec_conv =
false)
const;
988 float_complex_row_vector_value (
bool frc_str_conv =
false,
989 bool frc_vec_conv =
false)
const;
991 Array<int> int_vector_value (
bool req_int =
false,
992 bool frc_str_conv =
false,
993 bool frc_vec_conv =
false)
const;
996 octave_idx_type_vector_value (
bool req_int =
false,
997 bool frc_str_conv =
false,
998 bool frc_vec_conv =
false)
const;
1001 bool frc_vec_conv =
false)
const;
1004 bool frc_vec_conv =
false)
const;
1006 Array<float> float_vector_value (
bool frc_str_conv =
false,
1007 bool frc_vec_conv =
false)
const;
1010 float_complex_vector_value (
bool frc_str_conv =
false,
1011 bool frc_vec_conv =
false)
const;
1021 short int xshort_value (
const char *fmt, ...)
const;
1023 unsigned short int xushort_value (
const char *fmt, ...)
const;
1025 int xint_value (
const char *fmt, ...)
const;
1027 unsigned int xuint_value (
const char *fmt, ...)
const;
1029 int xnint_value (
const char *fmt, ...)
const;
1031 long int xlong_value (
const char *fmt, ...)
const;
1033 unsigned long int xulong_value (
const char *fmt, ...)
const;
1035 int64_t xint64_value (
const char *fmt, ...)
const;
1037 uint64_t xuint64_value (
const char *fmt, ...)
const;
1041 double xdouble_value (
const char *fmt, ...)
const;
1043 float xfloat_value (
const char *fmt, ...)
const;
1045 double xscalar_value (
const char *fmt, ...)
const;
1047 float xfloat_scalar_value (
const char *fmt, ...)
const;
1049 Matrix xmatrix_value (
const char *fmt, ...)
const;
1051 FloatMatrix xfloat_matrix_value (
const char *fmt, ...)
const;
1053 NDArray xarray_value (
const char *fmt, ...)
const;
1055 FloatNDArray xfloat_array_value (
const char *fmt, ...)
const;
1057 Complex xcomplex_value (
const char *fmt, ...)
const;
1059 FloatComplex xfloat_complex_value (
const char *fmt, ...)
const;
1061 ComplexMatrix xcomplex_matrix_value (
const char *fmt, ...)
const;
1065 ComplexNDArray xcomplex_array_value (
const char *fmt, ...)
const;
1069 bool xbool_value (
const char *fmt, ...)
const;
1071 boolMatrix xbool_matrix_value (
const char *fmt, ...)
const;
1073 boolNDArray xbool_array_value (
const char *fmt, ...)
const;
1075 charMatrix xchar_matrix_value (
const char *fmt, ...)
const;
1077 charNDArray xchar_array_value (
const char *fmt, ...)
const;
1079 SparseMatrix xsparse_matrix_value (
const char *fmt, ...)
const;
1085 DiagMatrix xdiag_matrix_value (
const char *fmt, ...)
const;
1087 FloatDiagMatrix xfloat_diag_matrix_value (
const char *fmt, ...)
const;
1093 PermMatrix xperm_matrix_value (
const char *fmt, ...)
const;
1095 octave_int8 xint8_scalar_value (
const char *fmt, ...)
const;
1097 octave_int16 xint16_scalar_value (
const char *fmt, ...)
const;
1099 octave_int32 xint32_scalar_value (
const char *fmt, ...)
const;
1101 octave_int64 xint64_scalar_value (
const char *fmt, ...)
const;
1103 octave_uint8 xuint8_scalar_value (
const char *fmt, ...)
const;
1105 octave_uint16 xuint16_scalar_value (
const char *fmt, ...)
const;
1107 octave_uint32 xuint32_scalar_value (
const char *fmt, ...)
const;
1109 octave_uint64 xuint64_scalar_value (
const char *fmt, ...)
const;
1111 int8NDArray xint8_array_value (
const char *fmt, ...)
const;
1113 int16NDArray xint16_array_value (
const char *fmt, ...)
const;
1115 int32NDArray xint32_array_value (
const char *fmt, ...)
const;
1117 int64NDArray xint64_array_value (
const char *fmt, ...)
const;
1119 uint8NDArray xuint8_array_value (
const char *fmt, ...)
const;
1121 uint16NDArray xuint16_array_value (
const char *fmt, ...)
const;
1123 uint32NDArray xuint32_array_value (
const char *fmt, ...)
const;
1125 uint64NDArray xuint64_array_value (
const char *fmt, ...)
const;
1127 std::string xstring_value (
const char *fmt, ...)
const;
1129 string_vector xstring_vector_value (
const char *fmt, ...)
const;
1131 Cell xcell_value (
const char *fmt, ...)
const;
1135 Range xrange_value (
const char *fmt, ...)
const;
1137 octave_map xmap_value (
const char *fmt, ...)
const;
1141 ColumnVector xcolumn_vector_value (
const char *fmt, ...)
const;
1144 xcomplex_column_vector_value (
const char *fmt, ...)
const;
1146 RowVector xrow_vector_value (
const char *fmt, ...)
const;
1153 xfloat_complex_column_vector_value (
const char *fmt, ...)
const;
1155 FloatRowVector xfloat_row_vector_value (
const char *fmt, ...)
const;
1158 xfloat_complex_row_vector_value (
const char *fmt, ...)
const;
1160 Array<int> xint_vector_value (
const char *fmt, ...)
const;
1163 xoctave_idx_type_vector_value (
const char *fmt, ...)
const;
1167 Array<Complex> xcomplex_vector_value (
const char *fmt, ...)
const;
1169 Array<float> xfloat_vector_value (
const char *fmt, ...)
const;
1185 { rep->maybe_economize (); }
1196 void make_storable_value (
void);
1203 char type =
'\'')
const
1211 { rep->convert_to_row_or_column_vector (); }
1214 {
return rep->print_as_scalar (); }
1216 void print (std::ostream& os,
bool pr_as_read_syntax =
false)
1217 { rep->print (os, pr_as_read_syntax); }
1219 void print_raw (std::ostream& os,
bool pr_as_read_syntax =
false)
const
1220 { rep->print_raw (os, pr_as_read_syntax); }
1223 {
return rep->print_name_tag (os, name); }
1226 { rep->print_with_name (os, name,
true); }
1228 void short_disp (std::ostream& os)
const { rep->short_disp (os); }
1230 int type_id (
void)
const {
return rep->type_id (); }
1244 const std::list<octave_value_list>&
idx);
1260 bool is_for_cmd_expr)
1268 bool is_for_cmd_expr);
1274 void print_info (std::ostream& os,
1277 bool save_ascii (std::ostream& os) {
return rep->save_ascii (os); }
1282 {
return rep->save_binary (os, save_as_floats); }
1286 {
return rep->load_binary (is, swap, fmt); }
1290 {
return rep->save_hdf5 (loc_id, name, save_as_floats); }
1293 {
return rep->load_hdf5 (loc_id, name); }
1312 {
return rep->
diag (
k); }
1315 {
return rep->
diag (m, n); }
1321 {
return rep->
sort (sidx, dim,
mode); }
1324 {
return rep->is_sorted (
mode); }
1330 {
return rep->is_sorted_rows (
mode); }
1336 bool islocked (
void)
const {
return rep->islocked (); }
1338 void dump (std::ostream& os)
const { rep->dump (os); }
1340 #define MAPPER_FORWARD(F) \
1341 octave_value F (void) const \
1343 return rep->map (octave_base_value::umap_ ## F); \
1411 #undef MAPPER_FORWARD
1414 {
return rep->
map (umap); }
1431 return rep->fast_elem_insert (n, x);
1466 #define OV_UNOP_FN(name) \
1467 inline octave_value \
1468 name (const octave_value& a) \
1470 return do_unary_op (octave_value::name, a); \
1473 #define OV_UNOP_OP(name, op) \
1474 inline octave_value \
1475 operator op (const octave_value& a) \
1480 #define OV_UNOP_FN_OP(name, op) \
1482 OV_UNOP_OP (name, op)
1496 #define OV_BINOP_FN(name) \
1497 inline octave_value \
1498 name (const octave_value& a1, const octave_value& a2) \
1500 return do_binary_op (octave_value::name, a1, a2); \
1503 #define OV_BINOP_OP(name, op) \
1504 inline octave_value \
1505 operator op (const octave_value& a1, const octave_value& a2) \
1507 return name (a1, a2); \
1510 #define OV_BINOP_FN_OP(name, op) \
1511 OV_BINOP_FN (name) \
1512 OV_BINOP_OP (name, op)
1538 #define OV_COMP_BINOP_FN(name) \
1539 inline octave_value \
1540 name (const octave_value& a1, const octave_value& a2) \
1542 return do_binary_op (octave_value::name, a1, a2); \
1553 template <typename Value>
1557 #define DEF_VALUE_EXTRACTOR(VALUE,MPREFIX) \
1559 inline VALUE octave_value_extract<VALUE> (const octave_value& v) \
1561 return v.MPREFIX ## _value (); \
1620 #undef DEF_VALUE_EXTRACTOR
1622 #define DEF_DUMMY_VALUE_EXTRACTOR(VALUE,DEFVAL) \
1624 inline VALUE octave_value_extract<VALUE> (const octave_value&) \
1632 #undef DEF_DUMMY_VALUE_EXTRACTOR
sortmode is_sorted_rows(sortmode mode=UNSORTED) const
uint8NDArray uint8_array_value(void) const
void short_disp(std::ostream &os) const
bool is_builtin_function(void) const
bool is_object(void) const
octave_idx_type nnz(void) const
octave_value op_mul_trans(const octave_value &a1, const octave_value &a2)
ComplexNDArray complex_array_value(bool frc_str_conv=false) const
bool is_range(void) const
FloatComplexDiagMatrix float_complex_diag_matrix_value(bool force=false) const
octave_value op_uplus(const octave_value &a)
size_t nparents(void) const
charNDArray char_array_value(bool frc_str_conv=false) const
octave_refcount< octave_idx_type > count
bool is_real_type(void) const
octave_value as_uint16(void) const
boolMatrix bool_matrix_value(bool warn=false) const
#define OV_BINOP_FN_OP(name, op)
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx)
octave_value op_el_pow(const octave_value &a1, const octave_value &a2)
bool print_name_tag(std::ostream &os, const std::string &name) const
octave_value as_int64(void) const
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
octave_value permute(const Array< int > &vec, bool inv=false) const
octave_value do_cat_op(const octave_value &v1, const octave_value &v2, const Array< octave_idx_type > &ra_idx)
The value of lines which begin with a space character are not saved in the history list A value of all commands are saved on the history list
octave_int16 int16_scalar_value(void) const
octave_value op_eq(const octave_value &a1, const octave_value &a2)
octave_value full_value(void) const
unsigned int uint_value(bool req_int=false, bool frc_str_conv=false) const
bool save_hdf5(octave_hdf5_id loc_id, const char *name, bool save_as_floats)
int8NDArray int8_array_value(void) const
nd group nd example oindent but is performed more efficiently If only and it is a scalar
Array< octave_idx_type > sort_rows_idx(sortmode mode=ASCENDING) const
Sort by rows returns only indices.
FloatComplexMatrix float_complex_matrix_value(bool frc_str_conv=false) const
octave_base_value * empty_clone(void) const
mxArray * as_mxArray(void) const
bool is_uint16_type(void) const
bool islocked(void) const
bool is_user_code(void) const
bool is_function(void) const
std::complex< double > erfi(std::complex< double > z, double relerr=0)
identity matrix If supplied two scalar respectively For allows like xample val
int16NDArray int16_array_value(void) const
MatrixType matrix_type(const MatrixType &typ) const
static int xtoascii(int c)
octave_idx_type nfields(void) const
std::list< std::string > parent_class_name_list(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_scalar_type(void) const
octave_value diag(octave_idx_type k=0) const
bool is_numeric_type(void) const
bool is_defined(void) const
octave_value op_el_ldiv(const octave_value &a1, const octave_value &a2)
the sparsity preserving column transformation such that that defines the pivoting threshold can be given in which case it defines the then the first element defines the pivoting tolerance for the unsymmetric the values defined such that for full matrix
bool is_complex_scalar(void) const
int int_value(bool req_int=false, bool frc_str_conv=false) const
uint64NDArray uint64_array_value(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)
int64_t int64_value(bool req_int=false, bool frc_str_conv=false) const
octave_int32 int32_scalar_value(void) const
float float_value(bool frc_str_conv=false) const
int32NDArray int32_array_value(void) const
bool is_perm_matrix(void) const
bool is_int8_type(void) const
octave_value map(octave_base_value::unary_mapper_t umap) const
octave_value as_double(void) const
Array< octave_idx_type > sort_rows_idx(sortmode mode=ASCENDING) const
size_type size(const size_type d) const
Size of the specified dimension.
octave_value op_pow(const octave_value &a1, const octave_value &a2)
octave_base_value * try_narrowing_conversion(void)
octave::mach_info::float_format flt_fmt
octave_value resize(const dim_vector &dv, bool fill=false) const
float float_scalar_value(bool frc_str_conv=false) const
Complex acos(const Complex &x)
octave_idx_type nzmax(void) const
octave_value as_int32(void) const
octave_value convert_to_str_internal(bool pad, bool force, char type) const
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_int32_type(void) const
bool is_copy_of(const octave_value &val) const
octave_value as_uint8(void) const
double scalar_value(bool frc_str_conv=false) const
Complex asin(const Complex &x)
#define DEF_VALUE_EXTRACTOR(VALUE, MPREFIX)
ComplexDiagMatrix complex_diag_matrix_value(bool force=false) const
boolNDArray bool_array_value(bool warn=false) const
bool is_function_handle(void) const
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
bool is_instance_of(const std::string &cls_name) 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
octave_value ipermute(const Array< int > &vec) const
int64NDArray int64_array_value(void) const
octave_value subsref(const std::string &type, const std::list< octave_value_list > &idx, bool auto_add)
sortmode is_sorted(sortmode mode=UNSORTED) const
idx_vector index_vector(bool require_integers=false) const
bool is_float_type(void) const
octave_base_value::type_conv_info numeric_demotion_function(void) const
Array< std::string > cellstr_value(void) const
octave_value op_div(const octave_value &a1, const octave_value &a2)
octave_value any(int dim=0) const
octave_value op_el_or(const octave_value &a1, const octave_value &a2)
octave_idx_type columns(void) const
ComplexColumnVector conj(const ComplexColumnVector &a)
long int long_value(bool req_int=false, bool frc_str_conv=false) const
bool is_dld_function(void) const
virtual octave_base_value * try_narrowing_conversion(void)
FloatNDArray float_array_value(bool frc_str_conv=false) const
void dump(std::ostream &os) const
bool is_char_matrix(void) const
virtual octave_base_value * find_parent_class(const std::string &)
octave_value as_single(void) const
Complex atan(const Complex &x)
bool is_mex_function(void) const
unsigned long int ulong_value(bool req_int=false, bool frc_str_conv=false) const
octave_uint8 uint8_scalar_value(void) const
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)
octave_value as_int16(void) const
octave_value convert_to_str(bool pad=false, bool force=false, char type= '\'') const
bool print_as_scalar(void) const
bool is_complex_matrix(void) const
uint64_t uint64_value(bool req_int=false, bool frc_str_conv=false) const
octave_value op_not(const octave_value &a)
bool is_sparse_type(void) const
octave_value squeeze(void) const
octave_value as_int8(void) const
octave_idx_type numel(const octave_value_list &idx)
bool is_bool_type(void) const
bool is_real_scalar(void) const
octave_idx_type * mex_get_jc(void) const
bool is_bool_matrix(void) const
void print(std::ostream &os, bool pr_as_read_syntax=false)
std::string string_value(bool force=false) const
FloatDiagMatrix float_diag_matrix_value(bool force=false) const
nd deftypefn *octave_map m
#define DEF_DUMMY_VALUE_EXTRACTOR(VALUE, DEFVAL)
then the function must return scalars which will be concatenated into the return array(s).If code
octave_value op_trans_mul(const octave_value &a1, const octave_value &a2)
int nint_value(bool frc_str_conv=false) const
bool load_hdf5(octave_hdf5_id loc_id, const char *name)
FloatComplex float_complex_value(bool frc_str_conv=false) const
octave_base_value::type_conv_info numeric_conversion_function(void) const
Range range_value(void) const
octave_value op_transpose(const octave_value &a)
bool is_matrix_type(void) const
returns the type of the matrix and caches it for future use Called with more than one argument
Value octave_value_extract(const octave_value &)
FloatComplexNDArray float_complex_array_value(bool frc_str_conv=false) const
bool is_string(void) const
bool is_double_type(void) const
bool save_binary(std::ostream &os, bool &save_as_floats)
void maybe_economize(void)
octave_value as_uint32(void) const
SparseBoolMatrix sparse_bool_matrix_value(bool warn=false) const
bool is_inline_function(void) const
void print_raw(std::ostream &os, bool pr_as_read_syntax=false) const
octave_value op_el_and(const octave_value &a1, const octave_value &a2)
bool is_complex_type(void) const
bool is_magic_colon(void) const
bool is_int64_type(void) const
virtual octave_base_value * empty_clone(void) const
octave_base_value * find_parent_class(const std::string &parent_class_name)
bool is_cellstr(void) const
octave_idx_type * mex_get_ir(void) const
octave_value op_mul_herm(const octave_value &a1, const octave_value &a2)
bool all_zero_dims(void) const
std::complex< double > erfcx(std::complex< double > z, double relerr=0)
bool is_user_script(void) const
string_vector map_keys(void) const
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
SparseComplexMatrix sparse_complex_matrix_value(bool frc_str_conv=false) const
string_vector parent_class_names(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
dim_vector dims(void) const
string_vector string_vector_value(bool pad=false) const
Matrix matrix_value(bool frc_str_conv=false) const
OCTINTERP_API octave_value do_unary_op(octave_value::unary_op op, const octave_value &a)
octave_value op_le(const octave_value &a1, const octave_value &a2)
octave_value op_lt(const octave_value &a1, const octave_value &a2)
void erase_subfunctions(void)
may be zero for pure relative error test tem the relative tolerance must be greater than or equal to
octave_idx_type numel(void) const
#define OV_COMP_BINOP_FN(name)
bool is_defined(void) const
charMatrix char_matrix_value(bool frc_str_conv=false) const
bool is_classdef_object(void) const
octave_value op_el_div(const octave_value &a1, const octave_value &a2)
virtual octave_base_value * unique_clone(void)
OCTINTERP_API octave_value do_binary_op(octave_value::binary_op op, const octave_value &a, const octave_value &b)
bool is_int16_type(void) const
bool save_ascii(std::ostream &os)
MatrixType matrix_type(void) const
DiagMatrix diag_matrix_value(bool force=false) const
#define OV_BINOP_FN(name)
unsigned short int ushort_value(bool req_int=false, bool frc_str_conv=false) const
std::string type_name(void) const
octave_value sort(octave_idx_type dim=0, sortmode mode=ASCENDING) const
bool is_bool_scalar(void) const
bool is_empty(void) const
bool is_sq_string(void) const
NDArray array_value(bool frc_str_conv=false) const
octave_int8 int8_scalar_value(void) const
void assign(octave_value::assign_op, const octave_value &)
void * mex_get_data(void) const
octave_value op_ne(const octave_value &a1, const octave_value &a2)
bool load_ascii(std::istream &is)
bool is_dq_string(void) const
bool bool_value(bool warn=false) const
=val(i)}if ode{val(i)}occurs in table i
ComplexMatrix complex_matrix_value(bool frc_str_conv=false) const
OCTAVE_EXPORT octave_value_list return the value of the option it must match the dimension of the state and the relative tolerance must also be a vector of the same length tem it must match the dimension of the state and the absolute tolerance must also be a vector of the same length The local error test applied at each integration step is xample roup abs(local error in x(i))<
bool is_uint8_type(void) const
const octave_base_value & get_rep(void) const
bool is_cs_list(void) const
Complex complex_value(bool frc_str_conv=false) const
std::list< octave_value_list > idx
FloatMatrix float_matrix_value(bool frc_str_conv=false) const
idx subsasgn(val, idx, 0) esult
OCTINTERP_API void install_types(void)
void print_with_name(std::ostream &os, const std::string &name) const
bool is_anonymous_function(void) const
std::string class_name(void) const
octave_value op_struct_ref(const octave_value &a1, const octave_value &a2)
octave_int64 int64_scalar_value(void) const
octave_idx_type get_count(void) const
bool is_constant(void) const
bool is_user_function(void) const
octave_value op_add(const octave_value &a1, const octave_value &a2)
bool is_undefined(void) const
void make_unique(int obsolete_copies)
bool is_uint64_type(void) const
octave_value op_ldiv(const octave_value &a1, const octave_value &a2)
octave_value diag(octave_idx_type m, octave_idx_type n) const
ColumnVector imag(const ComplexColumnVector &a)
octave_uint64 uint64_scalar_value(void) const
octave_value op_sub(const octave_value &a1, const octave_value &a2)
octave_value fast_elem_extract(octave_idx_type n) const
std::complex< float > FloatComplex
virtual bool fast_elem_insert(octave_idx_type n, const octave_value &x)
PermMatrix perm_matrix_value(void) const
SparseMatrix sparse_matrix_value(bool frc_str_conv=false) const
octave_value op_el_mul(const octave_value &a1, const octave_value &a2)
octave_value op_herm_mul(const octave_value &a1, const octave_value &a2)
std::complex< double > Complex
#define MAPPER_FORWARD(F)
octave_value sort(Array< octave_idx_type > &sidx, octave_idx_type dim=0, sortmode mode=ASCENDING) const
#define OV_UNOP_FN_OP(name, op)
bool is_single_type(void) const
octave_value op_hermitian(const octave_value &a)
octave_base_value * internal_rep(void) const
ColumnVector real(const ComplexColumnVector &a)
double double_value(bool frc_str_conv=false) const
write the output to stdout if nargout is
octave_value op_ge(const octave_value &a1, const octave_value &a2)
bool is_uint32_type(void) const
Vector representing the dimensions (size) of an Array.
octave_uint32 uint32_scalar_value(void) const
bool load_binary(std::istream &is, bool swap, octave::mach_info::float_format fmt)
uint32NDArray uint32_array_value(void) const
octave_value op_uminus(const octave_value &a)
set(hf,"paperorientation") esult
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
builtin_type_t builtin_type(void) const
octave_value as_uint64(void) const
OCTINTERP_API octave_value do_colon_op(const octave_value &base, const octave_value &limit, bool is_for_cmd_expr=false)
bool is_diag_matrix(void) const
uint16NDArray uint16_array_value(void) const
octave_value op_mul(const octave_value &a1, const octave_value &a2)
bool is_zero_by_zero(void) const
void convert_to_row_or_column_vector(void)
octave_uint16 uint16_scalar_value(void) const
octave_value op_gt(const octave_value &a1, const octave_value &a2)
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 * x
return octave_value(v1.char_array_value().concat(v2.char_array_value(), ra_idx),((a1.is_sq_string()||a2.is_sq_string())? '\'': '"'))
static int xisascii(int c)
bool is_real_matrix(void) const
size_t byte_size(void) const
short int short_value(bool req_int=false, bool frc_str_conv=false) const
octave_lvalue & operator=(const octave_lvalue &vr)
bool is_integer_type(void) const
std::complex< double > erfc(std::complex< double > z, double relerr=0)
octave_value do_index_op(const octave_value_list &idx, bool resize_ok=false)