home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / octa21eb.zip / octave / DLFCN.ZIP / dlfcn / examples / make_int.cc < prev    next >
C/C++ Source or Header  |  1999-04-29  |  10KB  |  373 lines
  1. /*
  2.  
  3. Copyright (C) 1996, 1997 John W. Eaton
  4.  
  5. This file is part of Octave.
  6.  
  7. Octave is free software; you can redistribute it and/or modify it
  8. under the terms of the GNU General Public License as published by the
  9. Free Software Foundation; either version 2, or (at your option) any
  10. later version.
  11.  
  12. Octave is distributed in the hope that it will be useful, but WITHOUT
  13. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15. for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with Octave; see the file COPYING.  If not, write to the Free
  19. Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20.  
  21. */
  22.  
  23. #include <octave/config.h>
  24.  
  25. #include <cstdlib>
  26.  
  27. #include <string>
  28.  
  29. class ostream;
  30.  
  31. #include <octave/lo-utils.h>
  32. #include <octave/mx-base.h>
  33. #include <octave/str-vec.h>
  34.  
  35. #include <octave/defun-dld.h>
  36. #include <octave/error.h>
  37. #include <octave/gripes.h>
  38. //#include <octave/mappers.h>
  39. #include <octave/oct-obj.h>
  40. #include <octave/ops.h>
  41. #include <octave/ov-base.h>
  42. #include <octave/ov-typeinfo.h>
  43. #include <octave/ov.h>
  44. #include <octave/ov-scalar.h>
  45. #include <octave/pager.h>
  46. #include <octave/pr-output.h>
  47. #include <octave/symtab.h>
  48. #include <octave/variables.h>
  49.  
  50. class Octave_map;
  51. class octave_value_list;
  52.  
  53. class tree_walker;
  54.  
  55. // Integer values.
  56.  
  57. class
  58. octave_integer : public octave_base_value
  59. {
  60. public:
  61.  
  62.   octave_integer (void)
  63.     : octave_base_value (), scalar (0) { }
  64.  
  65.   octave_integer (int i)
  66.     : octave_base_value (), scalar (i) { }
  67.  
  68.   octave_integer (const octave_integer& s)
  69.     : octave_base_value (), scalar (s.scalar) { }
  70.  
  71.   ~octave_integer (void) { }
  72.  
  73.   octave_value *clone (void) { return new octave_integer (*this); }
  74.  
  75. #if 0
  76.   void *operator new (size_t size);
  77.   void operator delete (void *p, size_t size);
  78. #endif
  79.  
  80.   idx_vector index_vector (void) const { return idx_vector ((double) scalar); }
  81.  
  82.   int rows (void) const { return 1; }
  83.   int columns (void) const { return 1; }
  84.  
  85.   bool is_defined (void) const { return true; }
  86.   bool is_real_scalar (void) const { return true; }
  87.  
  88.   octave_value all (void) const { return (scalar != 0); }
  89.   octave_value any (void) const { return (scalar != 0); }
  90.  
  91.   bool is_real_type (void) const { return true; }
  92.   bool is_scalar_type (void) const { return true; }
  93.   bool is_numeric_type (void) const { return true; }
  94.  
  95.   bool valid_as_scalar_index (void) const
  96.     { return scalar == 1; }
  97.  
  98.   bool valid_as_zero_index (void) const
  99.     { return scalar == 0; }
  100.  
  101.   bool is_true (void) const { return (scalar != 0); }
  102.  
  103.   double double_value (bool = false) const { return (double) scalar; }
  104.  
  105.   int integer_value (bool = false) const { return scalar; }
  106.  
  107.   Matrix matrix_value (bool = false) const { return Matrix (1, 1, scalar); }
  108.  
  109.   Complex complex_value (bool = false) const { return scalar; }
  110.  
  111.   ComplexMatrix complex_matrix_value (bool = false) const
  112.     { return  ComplexMatrix (1, 1, Complex (scalar)); }
  113.  
  114.   octave_value not (void) const { return octave_value (! scalar); }
  115.  
  116.   octave_value uminus (void) const { return octave_value (static_cast<double> (- scalar)); }
  117.  
  118.   octave_value transpose (void) const { return octave_value (static_cast<double> (scalar)); }
  119.  
  120.   octave_value hermitian (void) const { return octave_value (static_cast<double> (scalar)); }
  121.  
  122.   void increment (void) { ++scalar; }
  123.  
  124.   void decrement (void) { --scalar; }
  125.  
  126.   void print (ostream& os);
  127.  
  128.   int type_id (void) const { return t_id; }
  129.  
  130.   string type_name (void) const { return t_name; }
  131.  
  132.   static int static_type_id (void) { return t_id; }
  133.  
  134.   static void register_type (void)
  135.     { t_id = octave_value_typeinfo::register_type (t_name); }
  136.  
  137. private:
  138.  
  139.   int scalar;
  140.  
  141.   static int t_id;
  142.  
  143.   static const string t_name;
  144. };
  145.  
  146. int octave_integer::t_id = -1;
  147.  
  148. const string octave_integer::t_name ("integer");
  149.  
  150. void
  151. octave_integer::print (ostream& os)
  152. {
  153.   octave_print_internal (os, scalar, false);
  154. }
  155.  
  156. // integer by integer ops.
  157.  
  158. static octave_value
  159. oct_binop_add (const octave_value& a1, const octave_value& a2)
  160. {
  161.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  162.  
  163.   return new octave_integer (v1.integer_value () + v2.integer_value ());
  164. }
  165.  
  166. static octave_value
  167. oct_binop_sub (const octave_value& a1, const octave_value& a2)
  168. {
  169.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  170.  
  171.   return new octave_integer (v1.integer_value () - v2.integer_value ());
  172. }
  173.  
  174. static octave_value
  175. oct_binop_mul (const octave_value& a1, const octave_value& a2)
  176. {
  177.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  178.  
  179.   return new octave_integer (v1.integer_value () * v2.integer_value ());
  180. }
  181.  
  182. static octave_value
  183. oct_binop_div (const octave_value& a1, const octave_value& a2)
  184. {
  185.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  186.  
  187.   int d = v2.integer_value ();
  188.  
  189.   if (d == 0)
  190.     gripe_divide_by_zero ();
  191.  
  192.   return new octave_integer (v1.integer_value () / d);
  193. }
  194.  
  195. static octave_value
  196. oct_binop_i_s_div (const octave_value& a1, const octave_value& a2)
  197. {
  198.   CAST_BINOP_ARGS (const octave_integer&, const octave_scalar&);
  199.  
  200.   double d = v2.double_value ();
  201.  
  202.   if (d == 0.0)
  203.     gripe_divide_by_zero ();
  204.  
  205.   return new octave_scalar (v1.double_value () / d);
  206. }
  207.  
  208. static octave_value
  209. oct_binop_ldiv (const octave_value& a1, const octave_value& a2)
  210. {
  211.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  212.  
  213.   int d = v1.integer_value ();
  214.  
  215.   if (d == 0)
  216.     gripe_divide_by_zero ();
  217.  
  218.   return new octave_integer (v2.integer_value () / d);
  219. }
  220.  
  221. static octave_value
  222. oct_binop_lt (const octave_value& a1, const octave_value& a2)
  223. {
  224.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  225.  
  226.   return new octave_integer (v1.integer_value () < v2.integer_value ());
  227. }
  228.  
  229. static octave_value
  230. oct_binop_le (const octave_value& a1, const octave_value& a2)
  231. {
  232.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  233.  
  234.   return new octave_integer (v1.integer_value () <= v2.integer_value ());
  235. }
  236.  
  237. static octave_value
  238. oct_binop_eq (const octave_value& a1, const octave_value& a2)
  239. {
  240.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  241.  
  242.   return new octave_integer (v1.integer_value () == v2.integer_value ());
  243. }
  244.  
  245. static octave_value
  246. oct_binop_ge (const octave_value& a1, const octave_value& a2)
  247. {
  248.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  249.  
  250.   return new octave_integer (v1.integer_value () >= v2.integer_value ());
  251. }
  252.  
  253. static octave_value
  254. oct_binop_gt (const octave_value& a1, const octave_value& a2)
  255. {
  256.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  257.  
  258.   return new octave_integer (v1.integer_value () > v2.integer_value ());
  259. }
  260.  
  261. static octave_value
  262. oct_binop_ne (const octave_value& a1, const octave_value& a2)
  263. {
  264.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  265.  
  266.   return new octave_integer (v1.integer_value () != v2.integer_value ());
  267. }
  268.  
  269. static octave_value
  270. oct_binop_el_mul (const octave_value& a1, const octave_value& a2)
  271. {
  272.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  273.  
  274.   return new octave_integer (v1.integer_value () * v2.integer_value ());
  275. }
  276.  
  277. static octave_value
  278. oct_binop_el_div (const octave_value& a1, const octave_value& a2)
  279. {
  280.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  281.  
  282.   int d = v2.integer_value ();
  283.  
  284.   if (d == 0)
  285.     gripe_divide_by_zero ();
  286.  
  287.   return new octave_integer (v1.integer_value () / d);
  288. }
  289.  
  290. static octave_value
  291. oct_binop_el_ldiv (const octave_value& a1, const octave_value& a2)
  292. {
  293.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  294.  
  295.   int d = v1.integer_value ();
  296.  
  297.   if (d == 0)
  298.     gripe_divide_by_zero ();
  299.  
  300.   return new octave_integer (v2.integer_value () / d);
  301. }
  302.  
  303. static octave_value
  304. oct_binop_el_and (const octave_value& a1, const octave_value& a2)
  305. {
  306.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  307.  
  308.   return new octave_integer (v1.integer_value () && v2.integer_value ());
  309. }
  310.  
  311. static octave_value
  312. oct_binop_el_or (const octave_value& a1, const octave_value& a2)
  313. {
  314.   CAST_BINOP_ARGS (const octave_integer&, const octave_integer&);
  315.  
  316.   return new octave_integer (v1.integer_value () || v2.integer_value ());
  317. }
  318.  
  319. DEFUN_DLD (make_int, args, ,
  320.   "int_val = make_int (val)\n\
  321. \n\
  322. Creates an integer variable from VAL.")
  323. {
  324.   static bool type_loaded = false;
  325.  
  326.   if (! type_loaded)
  327.     {
  328.       octave_integer::register_type ();
  329.  
  330.       cerr << "installing integer type at type-id = "
  331.        << octave_integer::static_type_id () << "\n";
  332.  
  333.       INSTALL_BINOP (add, octave_integer, octave_integer, add);
  334.       INSTALL_BINOP (sub, octave_integer, octave_integer, sub);
  335.       INSTALL_BINOP (mul, octave_integer, octave_integer, mul);
  336.       INSTALL_BINOP (div, octave_integer, octave_integer, div);
  337.       INSTALL_BINOP (ldiv, octave_integer, octave_integer, ldiv);
  338.       INSTALL_BINOP (lt, octave_integer, octave_integer, lt);
  339.       INSTALL_BINOP (le, octave_integer, octave_integer, le);
  340.       INSTALL_BINOP (eq, octave_integer, octave_integer, eq);
  341.       INSTALL_BINOP (ge, octave_integer, octave_integer, ge);
  342.       INSTALL_BINOP (gt, octave_integer, octave_integer, gt);
  343.       INSTALL_BINOP (ne, octave_integer, octave_integer, ne);
  344.       INSTALL_BINOP (el_mul, octave_integer, octave_integer, el_mul);
  345.       INSTALL_BINOP (el_div, octave_integer, octave_integer, el_div);
  346.       INSTALL_BINOP (el_ldiv, octave_integer, octave_integer, el_ldiv);
  347.       INSTALL_BINOP (el_and, octave_integer, octave_integer, el_and);
  348.       INSTALL_BINOP (el_or, octave_integer, octave_integer, el_or);
  349.  
  350.       INSTALL_BINOP (div, octave_integer, octave_scalar, i_s_div);
  351.     }
  352.  
  353.   octave_value retval;
  354.  
  355.   if (args.length () == 1)
  356.     {
  357.       double d = args(0).double_value ();
  358.  
  359.       if (! error_state)
  360.     retval = octave_value (new octave_integer (NINT (d)));
  361.     }
  362.   else
  363.     usage ("make_int");
  364.  
  365.   return retval;
  366. }
  367.  
  368. /*
  369. ;;; Local Variables: ***
  370. ;;; mode: C++ ***
  371. ;;; End: ***
  372. */
  373.