Mercurial > hg > octave-lyh
annotate examples/make_int.cc @ 17514:96cf8ee3440e
text.m: Match variable names to documentation.
* scripts/plot/text.m: Improve docstring. Rename variable 'label' to 'string'
to match docstring.
| author | Rik <rik@octave.org> |
|---|---|
| date | Wed, 25 Sep 2013 17:21:31 -0700 |
| parents | b099acf06b55 |
| children |
| 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 | |
| 75 { return scalar == 1; } | |
| 76 | |
| 77 bool valid_as_zero_index (void) const | |
| 78 { return scalar == 0; } | |
| 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 | |
| 91 { return ComplexMatrix (1, 1, Complex (scalar)); } | |
| 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 | |
| 3301 | 111 DECLARE_OCTAVE_ALLOCATOR |
| 2391 | 112 |
| 3301 | 113 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA |
| 2391 | 114 }; |
| 115 | |
| 3301 | 116 void |
| 4320 | 117 octave_integer::print (std::ostream& os, bool pr_as_read_syntax) const |
| 3301 | 118 { |
| 4320 | 119 os << scalar; |
| 120 // octave_print_internal (os, scalar, pr_as_read_syntax); | |
| 3301 | 121 } |
| 2391 | 122 |
| 3327 | 123 #ifdef DEFUNOP_OP |
| 124 #undef DEFUNOP_OP | |
| 125 #endif | |
| 126 | |
| 127 #define DEFUNOP_OP(name, t, op) \ | |
| 128 UNOPDECL (name, a) \ | |
| 129 { \ | |
| 130 CAST_UNOP_ARG (const octave_ ## t&); \ | |
| 131 return octave_value (new octave_integer (op v.t ## _value ())); \ | |
| 132 } | |
| 133 | |
| 4320 | 134 DEFUNOP_OP (gnot, integer, !) |
| 3327 | 135 DEFUNOP_OP (uminus, integer, -) |
| 136 DEFUNOP_OP (transpose, integer, /* no-op */) | |
| 137 DEFUNOP_OP (hermitian, integer, /* no-op */) | |
| 138 | |
| 139 DEFNCUNOP_METHOD (incr, integer, increment) | |
| 140 DEFNCUNOP_METHOD (decr, integer, decrement) | |
| 141 | |
| 3301 | 142 #ifdef DEFBINOP_OP |
| 143 #undef DEFBINOP_OP | |
| 144 #endif | |
| 145 | |
| 146 #define DEFBINOP_OP(name, t1, t2, op) \ | |
| 147 BINOPDECL (name, a1, a2) \ | |
| 148 { \ | |
| 149 CAST_BINOP_ARGS (const octave_ ## t1&, const octave_ ## t2&); \ | |
| 150 return octave_value \ | |
| 151 (new octave_integer (v1.t1 ## _value () op v2.t2 ## _value ())); \ | |
| 152 } | |
| 2391 | 153 |
| 154 // integer by integer ops. | |
| 155 | |
| 3301 | 156 DEFBINOP_OP (add, integer, integer, +) |
| 157 DEFBINOP_OP (sub, integer, integer, -) | |
| 158 DEFBINOP_OP (mul, integer, integer, *) | |
| 2391 | 159 |
| 3301 | 160 DEFBINOP (div, integer, integer) |
| 2391 | 161 { |
| 162 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 163 | |
| 164 int d = v2.integer_value (); | |
| 165 | |
| 166 if (d == 0) | |
| 167 gripe_divide_by_zero (); | |
| 168 | |
| 169 return new octave_integer (v1.integer_value () / d); | |
| 170 } | |
| 171 | |
| 3301 | 172 |
| 173 DEFBINOP (i_s_div, integer, scalar) | |
| 2391 | 174 { |
| 175 CAST_BINOP_ARGS (const octave_integer&, const octave_scalar&); | |
| 176 | |
| 177 double d = v2.double_value (); | |
| 178 | |
| 179 if (d == 0.0) | |
| 180 gripe_divide_by_zero (); | |
| 181 | |
| 182 return new octave_scalar (v1.double_value () / d); | |
| 183 } | |
| 184 | |
| 3301 | 185 DEFBINOP (ldiv, integer, integer) |
| 2391 | 186 { |
| 187 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 188 | |
| 189 int d = v1.integer_value (); | |
| 190 | |
| 191 if (d == 0) | |
| 192 gripe_divide_by_zero (); | |
| 193 | |
| 194 return new octave_integer (v2.integer_value () / d); | |
| 195 } | |
| 196 | |
| 3301 | 197 DEFBINOP_OP (lt, integer, integer, <) |
| 198 DEFBINOP_OP (le, integer, integer, <=) | |
| 199 DEFBINOP_OP (eq, integer, integer, ==) | |
| 200 DEFBINOP_OP (ge, integer, integer, >=) | |
| 201 DEFBINOP_OP (gt, integer, integer, >) | |
| 202 DEFBINOP_OP (ne, integer, integer, !=) | |
| 2391 | 203 |
| 3301 | 204 DEFBINOP_OP (el_mul, integer, integer, !=) |
| 2391 | 205 |
| 3301 | 206 DEFBINOP (el_div, integer, integer) |
| 2391 | 207 { |
| 208 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 209 | |
| 210 int d = v2.integer_value (); | |
| 211 | |
| 212 if (d == 0) | |
| 213 gripe_divide_by_zero (); | |
| 214 | |
| 215 return new octave_integer (v1.integer_value () / d); | |
| 216 } | |
| 217 | |
| 3301 | 218 DEFBINOP (el_ldiv, integer, integer) |
| 2391 | 219 { |
| 220 CAST_BINOP_ARGS (const octave_integer&, const octave_integer&); | |
| 221 | |
| 222 int d = v1.integer_value (); | |
| 223 | |
| 224 if (d == 0) | |
| 225 gripe_divide_by_zero (); | |
| 226 | |
| 227 return new octave_integer (v2.integer_value () / d); | |
| 228 } | |
| 229 | |
| 3301 | 230 DEFBINOP_OP (el_and, integer, integer, &&) |
| 231 DEFBINOP_OP (el_or, integer, integer, ||) | |
| 2391 | 232 |
| 233 DEFUN_DLD (make_int, args, , | |
| 234 "int_val = make_int (val)\n\ | |
| 235 \n\ | |
| 236 Creates an integer variable from VAL.") | |
| 237 { | |
| 238 static bool type_loaded = false; | |
| 239 | |
| 240 if (! type_loaded) | |
| 241 { | |
| 242 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
|
243 mlock (); |
| 2391 | 244 |
| 4320 | 245 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
|
246 << octave_integer::static_type_id () << "\n"; |
| 2391 | 247 |
| 4320 | 248 INSTALL_UNOP (op_not, octave_integer, gnot); |
| 3603 | 249 INSTALL_UNOP (op_uminus, octave_integer, uminus); |
| 250 INSTALL_UNOP (op_transpose, octave_integer, transpose); | |
| 251 INSTALL_UNOP (op_hermitian, octave_integer, hermitian); | |
| 3327 | 252 |
| 3603 | 253 INSTALL_NCUNOP (op_incr, octave_integer, incr); |
| 254 INSTALL_NCUNOP (op_decr, octave_integer, decr); | |
| 3327 | 255 |
| 3603 | 256 INSTALL_BINOP (op_add, octave_integer, octave_integer, add); |
| 257 INSTALL_BINOP (op_sub, octave_integer, octave_integer, sub); | |
| 258 INSTALL_BINOP (op_mul, octave_integer, octave_integer, mul); | |
| 259 INSTALL_BINOP (op_div, octave_integer, octave_integer, div); | |
| 260 INSTALL_BINOP (op_ldiv, octave_integer, octave_integer, ldiv); | |
| 261 INSTALL_BINOP (op_lt, octave_integer, octave_integer, lt); | |
| 262 INSTALL_BINOP (op_le, octave_integer, octave_integer, le); | |
| 263 INSTALL_BINOP (op_eq, octave_integer, octave_integer, eq); | |
| 264 INSTALL_BINOP (op_ge, octave_integer, octave_integer, ge); | |
| 265 INSTALL_BINOP (op_gt, octave_integer, octave_integer, gt); | |
| 266 INSTALL_BINOP (op_ne, octave_integer, octave_integer, ne); | |
| 267 INSTALL_BINOP (op_el_mul, octave_integer, octave_integer, el_mul); | |
| 268 INSTALL_BINOP (op_el_div, octave_integer, octave_integer, el_div); | |
| 269 INSTALL_BINOP (op_el_ldiv, octave_integer, octave_integer, el_ldiv); | |
| 270 INSTALL_BINOP (op_el_and, octave_integer, octave_integer, el_and); | |
| 271 INSTALL_BINOP (op_el_or, octave_integer, octave_integer, el_or); | |
| 2391 | 272 |
| 3603 | 273 INSTALL_BINOP (op_div, octave_integer, octave_scalar, i_s_div); |
| 2391 | 274 } |
| 275 | |
| 276 octave_value retval; | |
| 277 | |
| 278 if (args.length () == 1) | |
| 279 { | |
| 280 double d = args(0).double_value (); | |
| 281 | |
| 282 if (! error_state) | |
|
9932
6cb30a539481
untabify files in examples directory
John W. Eaton <jwe@octave.org>
parents:
9053
diff
changeset
|
283 retval = octave_value (new octave_integer (NINT (d))); |
| 2391 | 284 } |
| 285 else | |
| 286 usage ("make_int"); | |
| 287 | |
| 288 return retval; | |
| 289 } | |
| 290 | |
| 3301 | 291 DEFUN_DLD (doit, args, , |
| 292 "doit (I)") | |
| 293 { | |
| 294 octave_value_list retval; | |
| 295 | |
| 3328 | 296 if (args(0).type_id () == octave_integer::static_type_id ()) |
| 3301 | 297 { |
| 298 // At this point, we know we have a handle for an octave_integer | |
| 299 // object, so we can peek at the representation and extract the | |
| 300 // data. | |
| 301 | |
| 6445 | 302 const octave_base_value& rep = args(0).get_rep (); |
| 3301 | 303 |
| 304 int my_value = ((const octave_integer&) rep) . integer_value (); | |
| 305 | |
| 306 message ("doit", "your lucky number is: %d", my_value); | |
| 307 } | |
| 308 else | |
| 309 gripe_wrong_type_arg ("doit", args(0)); | |
| 310 | |
| 311 return retval; | |
| 312 } | |
| 313 | |
| 314 DEFINE_OCTAVE_ALLOCATOR (octave_integer); | |
| 315 | |
| 5172 | 316 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_integer, "integer", "integer"); |