Mercurial > octave-nkf
annotate examples/make_int.cc @ 9932:6cb30a539481
untabify files in examples directory
| author | John W. Eaton <jwe@octave.org> |
|---|---|
| date | Mon, 07 Dec 2009 14:53:20 -0500 |
| parents | 4295d634797d |
| children | ac4b97c6bf8b |
| 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_map; | |
| 29 class octave_value_list; | |
| 30 | |
| 31 class tree_walker; | |
| 32 | |
| 33 // Integer values. | |
| 34 | |
| 35 class | |
| 36 octave_integer : public octave_base_value | |
| 37 { | |
| 38 public: | |
| 39 | |
| 40 octave_integer (void) | |
| 41 : octave_base_value (), scalar (0) { } | |
| 42 | |
| 43 octave_integer (int i) | |
| 44 : octave_base_value (), scalar (i) { } | |
| 45 | |
| 46 octave_integer (const octave_integer& s) | |
| 47 : octave_base_value (), scalar (s.scalar) { } | |
| 48 | |
| 49 ~octave_integer (void) { } | |
| 50 | |
| 6445 | 51 octave_base_value *clone (void) { return new octave_integer (*this); } |
| 2391 | 52 |
| 53 #if 0 | |
| 54 void *operator new (size_t size); | |
| 55 void operator delete (void *p, size_t size); | |
| 56 #endif | |
| 57 | |
| 58 idx_vector index_vector (void) const { return idx_vector ((double) scalar); } | |
| 59 | |
| 60 int rows (void) const { return 1; } | |
| 61 int columns (void) const { return 1; } | |
| 62 | |
| 3354 | 63 bool is_constant (void) const { return true; } |
| 64 | |
| 2391 | 65 bool is_defined (void) const { return true; } |
| 66 bool is_real_scalar (void) const { return true; } | |
| 67 | |
| 3301 | 68 octave_value all (void) const { return (double) (scalar != 0); } |
| 69 octave_value any (void) const { return (double) (scalar != 0); } | |
| 2391 | 70 |
| 71 bool is_real_type (void) const { return true; } | |
| 72 bool is_scalar_type (void) const { return true; } | |
| 73 bool is_numeric_type (void) const { return true; } | |
| 74 | |
| 75 bool valid_as_scalar_index (void) const | |
| 76 { return scalar == 1; } | |
| 77 | |
| 78 bool valid_as_zero_index (void) const | |
| 79 { return scalar == 0; } | |
| 80 | |
| 81 bool is_true (void) const { return (scalar != 0); } | |
| 82 | |
| 83 double double_value (bool = false) const { return (double) scalar; } | |
| 84 | |
| 85 int integer_value (bool = false) const { return scalar; } | |
| 86 | |
| 87 Matrix matrix_value (bool = false) const { return Matrix (1, 1, scalar); } | |
| 88 | |
| 89 Complex complex_value (bool = false) const { return scalar; } | |
| 90 | |
| 91 ComplexMatrix complex_matrix_value (bool = false) const | |
| 92 { return ComplexMatrix (1, 1, Complex (scalar)); } | |
| 93 | |
| 4320 | 94 octave_value gnot (void) const { return octave_value ((double) ! scalar); } |
| 2391 | 95 |
| 3301 | 96 octave_value uminus (void) const { return new octave_integer (- scalar); } |
| 2391 | 97 |
| 3301 | 98 octave_value transpose (void) const { return new octave_integer (scalar); } |
| 2391 | 99 |
| 3301 | 100 octave_value hermitian (void) const { return new octave_integer (scalar); } |
| 2391 | 101 |
| 102 void increment (void) { ++scalar; } | |
| 103 | |
| 104 void decrement (void) { --scalar; } | |
| 105 | |
| 4320 | 106 void print (std::ostream& os, bool pr_as_read_syntax = false) const; |
| 2391 | 107 |
| 108 private: | |
| 109 | |
| 110 int scalar; | |
| 111 | |
| 3301 | 112 DECLARE_OCTAVE_ALLOCATOR |
| 2391 | 113 |
| 3301 | 114 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA |
| 2391 | 115 }; |
| 116 | |
| 3301 | 117 void |
| 4320 | 118 octave_integer::print (std::ostream& os, bool pr_as_read_syntax) const |
| 3301 | 119 { |
| 4320 | 120 os << scalar; |
| 121 // octave_print_internal (os, scalar, pr_as_read_syntax); | |
| 3301 | 122 } |
| 2391 | 123 |
| 3327 | 124 #ifdef DEFUNOP_OP |
| 125 #undef DEFUNOP_OP | |
| 126 #endif | |
| 127 | |
| 128 #define DEFUNOP_OP(name, t, op) \ | |
| 129 UNOPDECL (name, a) \ | |
| 130 { \ | |
| 131 CAST_UNOP_ARG (const octave_ ## t&); \ | |
| 132 return octave_value (new octave_integer (op v.t ## _value ())); \ | |
| 133 } | |
| 134 | |
| 4320 | 135 DEFUNOP_OP (gnot, integer, !) |
| 3327 | 136 DEFUNOP_OP (uminus, integer, -) |
| 137 DEFUNOP_OP (transpose, integer, /* no-op */) | |
| 138 DEFUNOP_OP (hermitian, integer, /* no-op */) | |
| 139 | |
| 140 DEFNCUNOP_METHOD (incr, integer, increment) | |
| 141 DEFNCUNOP_METHOD (decr, integer, decrement) | |
| 142 | |
| 3301 | 143 #ifdef DEFBINOP_OP |
| 144 #undef DEFBINOP_OP | |
| 145 #endif | |
| 146 | |
| 147 #define DEFBINOP_OP(name, t1, t2, op) \ | |
| 148 BINOPDECL (name, a1, a2) \ | |
| 149 { \ | |
| 150 CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \ | |
| 151 return octave_value \ | |
| 152 (new octave_integer (v1.t1 ## _value () op v2.t2 ## _value ())); \ | |
| 153 } | |
| 2391 | 154 |
| 155 // integer by integer ops. | |
| 156 | |
| 3301 | 157 DEFBINOP_OP (add, integer, integer, +) |
| 158 DEFBINOP_OP (sub, integer, integer, -) | |
| 159 DEFBINOP_OP (mul, integer, integer, *) | |
| 2391 | 160 |
| 3301 | 161 DEFBINOP (div, integer, integer) |
| 2391 | 162 { |
| 163 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 164 | |
| 165 int d = v2.integer_value (); | |
| 166 | |
| 167 if (d == 0) | |
| 168 gripe_divide_by_zero (); | |
| 169 | |
| 170 return new octave_integer (v1.integer_value () / d); | |
| 171 } | |
| 172 | |
| 3301 | 173 |
| 174 DEFBINOP (i_s_div, integer, scalar) | |
| 2391 | 175 { |
| 176 CAST_BINOP_ARGS (const octave_integer&, const octave_scalar&); | |
| 177 | |
| 178 double d = v2.double_value (); | |
| 179 | |
| 180 if (d == 0.0) | |
| 181 gripe_divide_by_zero (); | |
| 182 | |
| 183 return new octave_scalar (v1.double_value () / d); | |
| 184 } | |
| 185 | |
| 3301 | 186 DEFBINOP (ldiv, integer, integer) |
| 2391 | 187 { |
| 188 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 189 | |
| 190 int d = v1.integer_value (); | |
| 191 | |
| 192 if (d == 0) | |
| 193 gripe_divide_by_zero (); | |
| 194 | |
| 195 return new octave_integer (v2.integer_value () / d); | |
| 196 } | |
| 197 | |
| 3301 | 198 DEFBINOP_OP (lt, integer, integer, <) |
| 199 DEFBINOP_OP (le, integer, integer, <=) | |
| 200 DEFBINOP_OP (eq, integer, integer, ==) | |
| 201 DEFBINOP_OP (ge, integer, integer, >=) | |
| 202 DEFBINOP_OP (gt, integer, integer, >) | |
| 203 DEFBINOP_OP (ne, integer, integer, !=) | |
| 2391 | 204 |
| 3301 | 205 DEFBINOP_OP (el_mul, integer, integer, !=) |
| 2391 | 206 |
| 3301 | 207 DEFBINOP (el_div, integer, integer) |
| 2391 | 208 { |
| 209 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 210 | |
| 211 int d = v2.integer_value (); | |
| 212 | |
| 213 if (d == 0) | |
| 214 gripe_divide_by_zero (); | |
| 215 | |
| 216 return new octave_integer (v1.integer_value () / d); | |
| 217 } | |
| 218 | |
| 3301 | 219 DEFBINOP (el_ldiv, integer, integer) |
| 2391 | 220 { |
| 221 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 222 | |
| 223 int d = v1.integer_value (); | |
| 224 | |
| 225 if (d == 0) | |
| 226 gripe_divide_by_zero (); | |
| 227 | |
| 228 return new octave_integer (v2.integer_value () / d); | |
| 229 } | |
| 230 | |
| 3301 | 231 DEFBINOP_OP (el_and, integer, integer, &&) |
| 232 DEFBINOP_OP (el_or, integer, integer, ||) | |
| 2391 | 233 |
| 234 DEFUN_DLD (make_int, args, , | |
| 235 "int_val = make_int (val)\n\ | |
| 236 \n\ | |
| 237 Creates an integer variable from VAL.") | |
| 238 { | |
| 239 static bool type_loaded = false; | |
| 240 | |
| 241 if (! type_loaded) | |
| 242 { | |
| 243 octave_integer::register_type (); | |
| 4320 | 244 mlock ("make_int"); |
| 2391 | 245 |
| 4320 | 246 octave_stdout << "installing integer type at type-id = " |
|
9932
6cb30a539481
untabify files in examples directory
John W. Eaton <jwe@octave.org>
parents:
9053
diff
changeset
|
247 << octave_integer::static_type_id () << "\n"; |
| 2391 | 248 |
| 4320 | 249 INSTALL_UNOP (op_not, octave_integer, gnot); |
| 3603 | 250 INSTALL_UNOP (op_uminus, octave_integer, uminus); |
| 251 INSTALL_UNOP (op_transpose, octave_integer, transpose); | |
| 252 INSTALL_UNOP (op_hermitian, octave_integer, hermitian); | |
| 3327 | 253 |
| 3603 | 254 INSTALL_NCUNOP (op_incr, octave_integer, incr); |
| 255 INSTALL_NCUNOP (op_decr, octave_integer, decr); | |
| 3327 | 256 |
| 3603 | 257 INSTALL_BINOP (op_add, octave_integer, octave_integer, add); |
| 258 INSTALL_BINOP (op_sub, octave_integer, octave_integer, sub); | |
| 259 INSTALL_BINOP (op_mul, octave_integer, octave_integer, mul); | |
| 260 INSTALL_BINOP (op_div, octave_integer, octave_integer, div); | |
| 261 INSTALL_BINOP (op_ldiv, octave_integer, octave_integer, ldiv); | |
| 262 INSTALL_BINOP (op_lt, octave_integer, octave_integer, lt); | |
| 263 INSTALL_BINOP (op_le, octave_integer, octave_integer, le); | |
| 264 INSTALL_BINOP (op_eq, octave_integer, octave_integer, eq); | |
| 265 INSTALL_BINOP (op_ge, octave_integer, octave_integer, ge); | |
| 266 INSTALL_BINOP (op_gt, octave_integer, octave_integer, gt); | |
| 267 INSTALL_BINOP (op_ne, octave_integer, octave_integer, ne); | |
| 268 INSTALL_BINOP (op_el_mul, octave_integer, octave_integer, el_mul); | |
| 269 INSTALL_BINOP (op_el_div, octave_integer, octave_integer, el_div); | |
| 270 INSTALL_BINOP (op_el_ldiv, octave_integer, octave_integer, el_ldiv); | |
| 271 INSTALL_BINOP (op_el_and, octave_integer, octave_integer, el_and); | |
| 272 INSTALL_BINOP (op_el_or, octave_integer, octave_integer, el_or); | |
| 2391 | 273 |
| 3603 | 274 INSTALL_BINOP (op_div, octave_integer, octave_scalar, i_s_div); |
| 2391 | 275 } |
| 276 | |
| 277 octave_value retval; | |
| 278 | |
| 279 if (args.length () == 1) | |
| 280 { | |
| 281 double d = args(0).double_value (); | |
| 282 | |
| 283 if (! error_state) | |
|
9932
6cb30a539481
untabify files in examples directory
John W. Eaton <jwe@octave.org>
parents:
9053
diff
changeset
|
284 retval = octave_value (new octave_integer (NINT (d))); |
| 2391 | 285 } |
| 286 else | |
| 287 usage ("make_int"); | |
| 288 | |
| 289 return retval; | |
| 290 } | |
| 291 | |
| 3301 | 292 DEFUN_DLD (doit, args, , |
| 293 "doit (I)") | |
| 294 { | |
| 295 octave_value_list retval; | |
| 296 | |
| 3328 | 297 if (args(0).type_id () == octave_integer::static_type_id ()) |
| 3301 | 298 { |
| 299 // At this point, we know we have a handle for an octave_integer | |
| 300 // object, so we can peek at the representation and extract the | |
| 301 // data. | |
| 302 | |
| 6445 | 303 const octave_base_value& rep = args(0).get_rep (); |
| 3301 | 304 |
| 305 int my_value = ((const octave_integer&) rep) . integer_value (); | |
| 306 | |
| 307 message ("doit", "your lucky number is: %d", my_value); | |
| 308 } | |
| 309 else | |
| 310 gripe_wrong_type_arg ("doit", args(0)); | |
| 311 | |
| 312 return retval; | |
| 313 } | |
| 314 | |
| 315 DEFINE_OCTAVE_ALLOCATOR (octave_integer); | |
| 316 | |
| 5172 | 317 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_integer, "integer", "integer"); |
| 3301 | 318 |
| 2391 | 319 /* |
| 320 ;;; Local Variables: *** | |
| 321 ;;; mode: C++ *** | |
| 322 ;;; End: *** | |
| 323 */ |