Mercurial > octave-nkf
annotate examples/code/make_int.cc @ 19632:76478d2da117
unconditionally disable the octave_allocator class
* configure.ac: Delete the --enable-octave-allocator option.
* oct-alloc.h: Delete octave_allocator class. Warn if file is
included. Unconditionally define macros to be empty.
* NEWS: Make note of these changes.
* oct-alloc.cc: Delete.
* liboctave/util/module.mk (UTIL_SRC): Remove it from the list.
* make_int.cc, Cell.h, oct-obj.cc, oct-obj.h, audiodevinfo.cc,
ov-base-int.h, ov-base-scalar.h, ov-bool-mat.cc, ov-bool-mat.h,
ov-bool-sparse.cc, ov-bool-sparse.h, ov-bool.cc, ov-bool.h,
ov-builtin.cc, ov-builtin.h, ov-cell.cc, ov-cell.h, ov-ch-mat.h,
ov-class.cc, ov-class.h, ov-classdef.cc, ov-classdef.h, ov-complex.cc,
ov-complex.h, ov-cs-list.cc, ov-cs-list.h, ov-cx-diag.cc,
ov-cx-diag.h, ov-cx-mat.cc, ov-cx-mat.h, ov-cx-sparse.cc,
ov-cx-sparse.h, ov-dld-fcn.cc, ov-dld-fcn.h, ov-fcn-handle.cc,
ov-fcn-handle.h, ov-fcn-inline.cc, ov-fcn-inline.h, ov-fcn.cc,
ov-fcn.h, ov-float.cc, ov-float.h, ov-flt-complex.cc,
ov-flt-complex.h, ov-flt-cx-diag.cc, ov-flt-cx-diag.h,
ov-flt-cx-mat.cc, ov-flt-cx-mat.h, ov-flt-re-diag.cc,
ov-flt-re-diag.h, ov-flt-re-mat.cc, ov-flt-re-mat.h, ov-int16.cc,
ov-int32.cc, ov-int64.cc, ov-int8.cc, ov-intx.h, ov-java.cc,
ov-java.h, ov-mex-fcn.cc, ov-mex-fcn.h, ov-perm.cc, ov-perm.h,
ov-range.cc, ov-range.h, ov-re-diag.cc, ov-re-diag.h, ov-re-mat.cc,
ov-re-mat.h, ov-re-sparse.cc, ov-re-sparse.h, ov-scalar.cc,
ov-scalar.h, ov-str-mat.cc, ov-str-mat.h, ov-struct.cc, ov-struct.h,
ov-uint16.cc, ov-uint32.cc, ov-uint64.cc, ov-uint8.cc, ov-usr-fcn.cc,
ov-usr-fcn.h, ov.cc, ov.h, pt-const.cc, pt-const.h, idx-vector.cc,
idx-vector.h: Delete uses of oct-alloc.h and OCTAVE_ALLOCATOR macros.
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Tue, 20 Jan 2015 13:43:29 -0500 |
| parents | c8240a60dd01 |
| children | b7ee5cefa9d6 |
| rev | line source |
|---|---|
| 2391 | 1 #include <octave/config.h> |
| 2 | |
| 3 #include <cstdlib> | |
| 4 | |
| 5 #include <string> | |
| 6 | |
| 4320 | 7 #include <ostream> |
| 2391 | 8 |
| 3301 | 9 #include <octave/lo-mappers.h> |
| 2391 | 10 #include <octave/lo-utils.h> |
| 11 #include <octave/mx-base.h> | |
| 12 #include <octave/str-vec.h> | |
| 13 | |
| 14 #include <octave/defun-dld.h> | |
| 15 #include <octave/error.h> | |
| 16 #include <octave/gripes.h> | |
| 17 #include <octave/oct-obj.h> | |
| 18 #include <octave/ops.h> | |
| 19 #include <octave/ov-base.h> | |
| 20 #include <octave/ov-typeinfo.h> | |
| 21 #include <octave/ov.h> | |
| 22 #include <octave/ov-scalar.h> | |
| 23 #include <octave/pager.h> | |
| 24 #include <octave/pr-output.h> | |
| 25 #include <octave/symtab.h> | |
| 26 #include <octave/variables.h> | |
| 27 | |
| 28 class octave_value_list; | |
| 29 | |
| 30 class tree_walker; | |
| 31 | |
| 32 // Integer values. | |
| 33 | |
| 34 class | |
| 35 octave_integer : public octave_base_value | |
| 36 { | |
| 37 public: | |
| 38 | |
| 39 octave_integer (void) | |
| 40 : octave_base_value (), scalar (0) { } | |
| 41 | |
| 42 octave_integer (int i) | |
| 43 : octave_base_value (), scalar (i) { } | |
| 44 | |
| 45 octave_integer (const octave_integer& s) | |
| 46 : octave_base_value (), scalar (s.scalar) { } | |
| 47 | |
| 48 ~octave_integer (void) { } | |
| 49 | |
| 6445 | 50 octave_base_value *clone (void) { return new octave_integer (*this); } |
| 2391 | 51 |
| 52 #if 0 | |
| 53 void *operator new (size_t size); | |
| 54 void operator delete (void *p, size_t size); | |
| 55 #endif | |
| 56 | |
| 57 idx_vector index_vector (void) const { return idx_vector ((double) scalar); } | |
| 58 | |
| 59 int rows (void) const { return 1; } | |
| 60 int columns (void) const { return 1; } | |
| 61 | |
| 3354 | 62 bool is_constant (void) const { return true; } |
| 63 | |
| 2391 | 64 bool is_defined (void) const { return true; } |
| 65 bool is_real_scalar (void) const { return true; } | |
| 66 | |
| 3301 | 67 octave_value all (void) const { return (double) (scalar != 0); } |
| 68 octave_value any (void) const { return (double) (scalar != 0); } | |
| 2391 | 69 |
| 70 bool is_real_type (void) const { return true; } | |
| 71 bool is_scalar_type (void) const { return true; } | |
| 72 bool is_numeric_type (void) const { return true; } | |
| 73 | |
| 74 bool valid_as_scalar_index (void) const | |
|
17791
224e76250443
Use GNU style coding conventions for code in examples/
Rik <rik@octave.org>
parents:
11052
diff
changeset
|
75 { return scalar == 1; } |
| 2391 | 76 |
| 77 bool valid_as_zero_index (void) const | |
|
17791
224e76250443
Use GNU style coding conventions for code in examples/
Rik <rik@octave.org>
parents:
11052
diff
changeset
|
78 { return scalar == 0; } |
| 2391 | 79 |
| 80 bool is_true (void) const { return (scalar != 0); } | |
| 81 | |
| 82 double double_value (bool = false) const { return (double) scalar; } | |
| 83 | |
| 84 int integer_value (bool = false) const { return scalar; } | |
| 85 | |
| 86 Matrix matrix_value (bool = false) const { return Matrix (1, 1, scalar); } | |
| 87 | |
| 88 Complex complex_value (bool = false) const { return scalar; } | |
| 89 | |
| 90 ComplexMatrix complex_matrix_value (bool = false) const | |
|
17791
224e76250443
Use GNU style coding conventions for code in examples/
Rik <rik@octave.org>
parents:
11052
diff
changeset
|
91 { return ComplexMatrix (1, 1, Complex (scalar)); } |
| 2391 | 92 |
| 4320 | 93 octave_value gnot (void) const { return octave_value ((double) ! scalar); } |
| 2391 | 94 |
| 3301 | 95 octave_value uminus (void) const { return new octave_integer (- scalar); } |
| 2391 | 96 |
| 3301 | 97 octave_value transpose (void) const { return new octave_integer (scalar); } |
| 2391 | 98 |
| 3301 | 99 octave_value hermitian (void) const { return new octave_integer (scalar); } |
| 2391 | 100 |
| 101 void increment (void) { ++scalar; } | |
| 102 | |
| 103 void decrement (void) { --scalar; } | |
| 104 | |
| 4320 | 105 void print (std::ostream& os, bool pr_as_read_syntax = false) const; |
| 2391 | 106 |
| 107 private: | |
| 108 | |
| 109 int scalar; | |
| 110 | |
| 111 | |
| 3301 | 112 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA |
| 2391 | 113 }; |
| 114 | |
| 3301 | 115 void |
| 4320 | 116 octave_integer::print (std::ostream& os, bool pr_as_read_syntax) const |
| 3301 | 117 { |
| 4320 | 118 os << scalar; |
| 119 // octave_print_internal (os, scalar, pr_as_read_syntax); | |
| 3301 | 120 } |
| 2391 | 121 |
| 3327 | 122 #ifdef DEFUNOP_OP |
| 123 #undef DEFUNOP_OP | |
| 124 #endif | |
| 125 | |
| 126 #define DEFUNOP_OP(name, t, op) \ | |
| 127 UNOPDECL (name, a) \ | |
| 128 { \ | |
| 129 CAST_UNOP_ARG (const octave_ ## t&); \ | |
| 130 return octave_value (new octave_integer (op v.t ## _value ())); \ | |
| 131 } | |
| 132 | |
| 4320 | 133 DEFUNOP_OP (gnot, integer, !) |
| 3327 | 134 DEFUNOP_OP (uminus, integer, -) |
| 135 DEFUNOP_OP (transpose, integer, /* no-op */) | |
| 136 DEFUNOP_OP (hermitian, integer, /* no-op */) | |
| 137 | |
| 138 DEFNCUNOP_METHOD (incr, integer, increment) | |
| 139 DEFNCUNOP_METHOD (decr, integer, decrement) | |
| 140 | |
| 3301 | 141 #ifdef DEFBINOP_OP |
| 142 #undef DEFBINOP_OP | |
| 143 #endif | |
| 144 | |
| 145 #define DEFBINOP_OP(name, t1, t2, op) \ | |
| 146 BINOPDECL (name, a1, a2) \ | |
| 147 { \ | |
| 148 CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \ | |
| 149 return octave_value \ | |
| 150 (new octave_integer (v1.t1 ## _value () op v2.t2 ## _value ())); \ | |
| 151 } | |
| 2391 | 152 |
| 153 // integer by integer ops. | |
| 154 | |
| 3301 | 155 DEFBINOP_OP (add, integer, integer, +) |
| 156 DEFBINOP_OP (sub, integer, integer, -) | |
| 157 DEFBINOP_OP (mul, integer, integer, *) | |
| 2391 | 158 |
| 3301 | 159 DEFBINOP (div, integer, integer) |
| 2391 | 160 { |
| 161 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 162 | |
| 163 int d = v2.integer_value (); | |
| 164 | |
| 165 if (d == 0) | |
| 166 gripe_divide_by_zero (); | |
| 167 | |
| 168 return new octave_integer (v1.integer_value () / d); | |
| 169 } | |
| 170 | |
| 3301 | 171 |
| 172 DEFBINOP (i_s_div, integer, scalar) | |
| 2391 | 173 { |
| 174 CAST_BINOP_ARGS (const octave_integer&, const octave_scalar&); | |
| 175 | |
| 176 double d = v2.double_value (); | |
| 177 | |
| 178 if (d == 0.0) | |
| 179 gripe_divide_by_zero (); | |
| 180 | |
| 181 return new octave_scalar (v1.double_value () / d); | |
| 182 } | |
| 183 | |
| 3301 | 184 DEFBINOP (ldiv, integer, integer) |
| 2391 | 185 { |
| 186 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 187 | |
| 188 int d = v1.integer_value (); | |
| 189 | |
| 190 if (d == 0) | |
| 191 gripe_divide_by_zero (); | |
| 192 | |
| 193 return new octave_integer (v2.integer_value () / d); | |
| 194 } | |
| 195 | |
| 3301 | 196 DEFBINOP_OP (lt, integer, integer, <) |
| 197 DEFBINOP_OP (le, integer, integer, <=) | |
| 198 DEFBINOP_OP (eq, integer, integer, ==) | |
| 199 DEFBINOP_OP (ge, integer, integer, >=) | |
| 200 DEFBINOP_OP (gt, integer, integer, >) | |
| 201 DEFBINOP_OP (ne, integer, integer, !=) | |
| 2391 | 202 |
| 3301 | 203 DEFBINOP_OP (el_mul, integer, integer, !=) |
| 2391 | 204 |
| 3301 | 205 DEFBINOP (el_div, integer, integer) |
| 2391 | 206 { |
| 207 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 208 | |
| 209 int d = v2.integer_value (); | |
| 210 | |
| 211 if (d == 0) | |
| 212 gripe_divide_by_zero (); | |
| 213 | |
| 214 return new octave_integer (v1.integer_value () / d); | |
| 215 } | |
| 216 | |
| 3301 | 217 DEFBINOP (el_ldiv, integer, integer) |
| 2391 | 218 { |
| 219 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 220 | |
| 221 int d = v1.integer_value (); | |
| 222 | |
| 223 if (d == 0) | |
| 224 gripe_divide_by_zero (); | |
| 225 | |
| 226 return new octave_integer (v2.integer_value () / d); | |
| 227 } | |
| 228 | |
| 3301 | 229 DEFBINOP_OP (el_and, integer, integer, &&) |
| 230 DEFBINOP_OP (el_or, integer, integer, ||) | |
| 2391 | 231 |
| 232 DEFUN_DLD (make_int, args, , | |
|
17791
224e76250443
Use GNU style coding conventions for code in examples/
Rik <rik@octave.org>
parents:
11052
diff
changeset
|
233 "int_val = make_int (val)\n\ |
| 2391 | 234 \n\ |
| 235 Creates an integer variable from VAL.") | |
| 236 { | |
| 237 static bool type_loaded = false; | |
| 238 | |
| 239 if (! type_loaded) | |
| 240 { | |
| 241 octave_integer::register_type (); | |
|
11052
b099acf06b55
make_int.cc: don't pass arg to mlock
John W. Eaton <jwe@octave.org>
parents:
11051
diff
changeset
|
242 mlock (); |
| 2391 | 243 |
| 4320 | 244 octave_stdout << "installing integer type at type-id = " |
|
17791
224e76250443
Use GNU style coding conventions for code in examples/
Rik <rik@octave.org>
parents:
11052
diff
changeset
|
245 << octave_integer::static_type_id () << "\n"; |
| 2391 | 246 |
| 4320 | 247 INSTALL_UNOP (op_not, octave_integer, gnot); |
| 3603 | 248 INSTALL_UNOP (op_uminus, octave_integer, uminus); |
| 249 INSTALL_UNOP (op_transpose, octave_integer, transpose); | |
| 250 INSTALL_UNOP (op_hermitian, octave_integer, hermitian); | |
| 3327 | 251 |
| 3603 | 252 INSTALL_NCUNOP (op_incr, octave_integer, incr); |
| 253 INSTALL_NCUNOP (op_decr, octave_integer, decr); | |
| 3327 | 254 |
| 3603 | 255 INSTALL_BINOP (op_add, octave_integer, octave_integer, add); |
| 256 INSTALL_BINOP (op_sub, octave_integer, octave_integer, sub); | |
| 257 INSTALL_BINOP (op_mul, octave_integer, octave_integer, mul); | |
| 258 INSTALL_BINOP (op_div, octave_integer, octave_integer, div); | |
| 259 INSTALL_BINOP (op_ldiv, octave_integer, octave_integer, ldiv); | |
| 260 INSTALL_BINOP (op_lt, octave_integer, octave_integer, lt); | |
| 261 INSTALL_BINOP (op_le, octave_integer, octave_integer, le); | |
| 262 INSTALL_BINOP (op_eq, octave_integer, octave_integer, eq); | |
| 263 INSTALL_BINOP (op_ge, octave_integer, octave_integer, ge); | |
| 264 INSTALL_BINOP (op_gt, octave_integer, octave_integer, gt); | |
| 265 INSTALL_BINOP (op_ne, octave_integer, octave_integer, ne); | |
| 266 INSTALL_BINOP (op_el_mul, octave_integer, octave_integer, el_mul); | |
| 267 INSTALL_BINOP (op_el_div, octave_integer, octave_integer, el_div); | |
| 268 INSTALL_BINOP (op_el_ldiv, octave_integer, octave_integer, el_ldiv); | |
| 269 INSTALL_BINOP (op_el_and, octave_integer, octave_integer, el_and); | |
| 270 INSTALL_BINOP (op_el_or, octave_integer, octave_integer, el_or); | |
| 2391 | 271 |
| 3603 | 272 INSTALL_BINOP (op_div, octave_integer, octave_scalar, i_s_div); |
| 2391 | 273 } |
| 274 | |
| 275 octave_value retval; | |
| 276 | |
| 277 if (args.length () == 1) | |
| 278 { | |
| 279 double d = args(0).double_value (); | |
| 280 | |
| 281 if (! error_state) | |
|
9932
6cb30a539481
untabify files in examples directory
John W. Eaton <jwe@octave.org>
parents:
9053
diff
changeset
|
282 retval = octave_value (new octave_integer (NINT (d))); |
| 2391 | 283 } |
| 284 else | |
| 285 usage ("make_int"); | |
| 286 | |
| 287 return retval; | |
| 288 } | |
| 289 | |
| 3301 | 290 DEFUN_DLD (doit, args, , |
|
17791
224e76250443
Use GNU style coding conventions for code in examples/
Rik <rik@octave.org>
parents:
11052
diff
changeset
|
291 "doit (I)") |
| 3301 | 292 { |
| 293 octave_value_list retval; | |
| 294 | |
| 3328 | 295 if (args(0).type_id () == octave_integer::static_type_id ()) |
| 3301 | 296 { |
| 297 // At this point, we know we have a handle for an octave_integer | |
| 298 // object, so we can peek at the representation and extract the | |
| 299 // data. | |
| 300 | |
| 6445 | 301 const octave_base_value& rep = args(0).get_rep (); |
| 3301 | 302 |
| 303 int my_value = ((const octave_integer&) rep) . integer_value (); | |
| 304 | |
| 305 message ("doit", "your lucky number is: %d", my_value); | |
| 306 } | |
| 307 else | |
| 308 gripe_wrong_type_arg ("doit", args(0)); | |
| 309 | |
| 310 return retval; | |
| 311 } | |
| 312 | |
| 313 | |
| 5172 | 314 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_integer, "integer", "integer"); |