home *** CD-ROM | disk | FTP | other *** search
/ NeXTSTEP 3.2 (Developer) / NS_dev_3.2.iso / NextDeveloper / Headers / g++ / Integer.h < prev    next >
C/C++ Source or Header  |  1993-06-29  |  27KB  |  1,117 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2.  
  3. /* 
  4. Copyright (C) 1988 Free Software Foundation
  5.     written by Doug Lea (dl@rocky.oswego.edu)
  6.  
  7. This file is part of the GNU C++ Library.  This library is free
  8. software; you can redistribute it and/or modify it under the terms of
  9. the GNU Library General Public License as published by the Free
  10. Software Foundation; either version 2 of the License, or (at your
  11. option) any later version.  This library is distributed in the hope
  12. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  13. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14. PURPOSE.  See the GNU Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. #ifndef _Integer_h
  21. #ifdef __GNUG__
  22. #pragma interface
  23. #endif
  24. #define _Integer_h 1
  25.  
  26. #include <stream.h>
  27.  
  28. struct IntRep                    // internal Integer representations
  29. {
  30.   unsigned short  len;          // current length
  31.   unsigned short  sz;           // allocated space (0 means static).
  32.   short           sgn;          // 1 means >= 0; 0 means < 0 
  33.   unsigned short  s[1];         // represented as ushort array starting here
  34. };
  35.  
  36. // True if REP is staticly (or manually) allocated,
  37. // and should not be deleted by an Integer destructor.
  38. #define STATIC_IntRep(rep) ((rep)->sz==0)
  39.  
  40. extern IntRep*  Ialloc(IntRep*, const unsigned short *, int, int, int);
  41. extern IntRep*  Icalloc(IntRep*, int);
  42. extern IntRep*  Icopy_ulong(IntRep*, unsigned long);
  43. extern IntRep*  Icopy_long(IntRep*, long);
  44. extern IntRep*  Icopy(IntRep*, const IntRep*);
  45. extern IntRep*  Iresize(IntRep*, int);
  46. extern IntRep*  add(const IntRep*, int, const IntRep*, int, IntRep*);
  47. extern IntRep*  add(const IntRep*, int, long, IntRep*);
  48. extern IntRep*  multiply(const IntRep*, const IntRep*, IntRep*);
  49. extern IntRep*  multiply(const IntRep*, long, IntRep*);
  50. extern IntRep*  lshift(const IntRep*, long, IntRep*);
  51. extern IntRep*  lshift(const IntRep*, const IntRep*, int, IntRep*);
  52. extern IntRep*  bitop(const IntRep*, const IntRep*, IntRep*, char);
  53. extern IntRep*  bitop(const IntRep*, long, IntRep*, char);
  54. extern IntRep*  power(const IntRep*, long, IntRep*);
  55. extern IntRep*  div(const IntRep*, const IntRep*, IntRep*);
  56. extern IntRep*  mod(const IntRep*, const IntRep*, IntRep*);
  57. extern IntRep*  div(const IntRep*, long, IntRep*);
  58. extern IntRep*  mod(const IntRep*, long, IntRep*);
  59. extern IntRep*  compl(const IntRep*, IntRep*);
  60. extern IntRep*  abs(const IntRep*, IntRep*);
  61. extern IntRep*  negate(const IntRep*, IntRep*);
  62. extern IntRep*  pow(const IntRep*, long);
  63. extern IntRep*  gcd(const IntRep*, const IntRep* y);
  64. extern int      compare(const IntRep*, const IntRep*);
  65. extern int      compare(const IntRep*, long);
  66. extern int      ucompare(const IntRep*, const IntRep*);
  67. extern int      ucompare(const IntRep*, long);
  68. extern char*    Itoa(const IntRep* x, int base = 10, int width = 0);
  69. extern char*    cvtItoa(const IntRep* x, char* fmt, int& fmtlen, int base,
  70.                         int showbase, int width, int align_right, 
  71.                         char fillchar, char Xcase, int showpos);
  72. extern IntRep*  atoIntRep(const char* s, int base = 10);
  73. extern long     Itolong(const IntRep*);
  74. extern double   Itodouble(const IntRep*);
  75. extern int      Iislong(const IntRep*);
  76. extern int      Iisdouble(const IntRep*);
  77. extern long     lg(const IntRep*);
  78.  
  79. extern IntRep _ZeroRep, _OneRep, _MinusOneRep;
  80.  
  81. class Integer
  82. {
  83. protected:
  84.   IntRep*         rep;
  85. public:
  86.                   Integer();
  87.                   Integer(long);
  88.                   Integer(unsigned long);
  89.                   Integer(IntRep*);
  90.                   Integer(const Integer&);
  91.  
  92.                   ~Integer();
  93.  
  94.   void            operator =  (const Integer&);
  95.   void            operator =  (long);
  96.  
  97. // unary operations to self
  98.  
  99.   void            operator ++ ();
  100.   void            operator -- ();
  101.   void            negate();          // negate in-place
  102.   void            abs();             // absolute-value in-place
  103.   void            complement();      // bitwise complement in-place
  104.  
  105. // assignment-based operations
  106.  
  107.   void            operator += (const Integer&);
  108.   void            operator -= (const Integer&);
  109.   void            operator *= (const Integer&);
  110.   void            operator /= (const Integer&);
  111.   void            operator %= (const Integer&);
  112.   void            operator <<=(const Integer&);
  113.   void            operator >>=(const Integer&);
  114.   void            operator &= (const Integer&);
  115.   void            operator |= (const Integer&);
  116.   void            operator ^= (const Integer&);
  117.  
  118.   void            operator += (long);
  119.   void            operator -= (long);
  120.   void            operator *= (long);
  121.   void            operator /= (long);
  122.   void            operator %= (long);
  123.   void            operator <<=(long);
  124.   void            operator >>=(long);
  125.   void            operator &= (long);
  126.   void            operator |= (long);
  127.   void            operator ^= (long);
  128.  
  129. // (constructive binary operations are inlined below)
  130.  
  131. #ifdef __GNUG__
  132.   friend Integer operator <? (const Integer& x, const Integer& y); // min
  133.   friend Integer operator >? (const Integer& x, const Integer& y); // max
  134. #endif
  135.  
  136. // builtin Integer functions that must be friends
  137.  
  138.   friend long     lg (const Integer&); // floor log base 2 of abs(x)
  139.   friend double   ratio(const Integer& x, const Integer& y);
  140.                   // return x/y as a double
  141.  
  142.   friend Integer  gcd(const Integer&, const Integer&);
  143.   friend int      even(const Integer&); // true if even
  144.   friend int      odd(const Integer&); // true if odd
  145.   friend int      sign(const Integer&); // returns -1, 0, +1
  146.  
  147.   friend void     (setbit)(Integer& x, long b);   // set b'th bit of x
  148.   friend void     clearbit(Integer& x, long b); // clear b'th bit
  149.   friend int      testbit(const Integer& x, long b);  // return b'th bit
  150.  
  151. // procedural versions of operators
  152.  
  153.   friend void     abs(const Integer& x, Integer& dest);
  154.   friend void     negate(const Integer& x, Integer& dest);
  155.   friend void     complement(const Integer& x, Integer& dest);
  156.  
  157.   friend int      compare(const Integer&, const Integer&);  
  158.   friend int      ucompare(const Integer&, const Integer&); 
  159.   friend void     add(const Integer& x, const Integer& y, Integer& dest);
  160.   friend void     sub(const Integer& x, const Integer& y, Integer& dest);
  161.   friend void     mul(const Integer& x, const Integer& y, Integer& dest);
  162.   friend void     div(const Integer& x, const Integer& y, Integer& dest);
  163.   friend void     mod(const Integer& x, const Integer& y, Integer& dest);
  164.   friend void     divide(const Integer& x, const Integer& y, 
  165.                          Integer& q, Integer& r);
  166.   friend void     and(const Integer& x, const Integer& y, Integer& dest);
  167.   friend void     or(const Integer& x, const Integer& y, Integer& dest);
  168.   friend void     xor(const Integer& x, const Integer& y, Integer& dest);
  169.   friend void     lshift(const Integer& x, const Integer& y, Integer& dest);
  170.   friend void     rshift(const Integer& x, const Integer& y, Integer& dest);
  171.   friend void     pow(const Integer& x, const Integer& y, Integer& dest);
  172.  
  173.   friend int      compare(const Integer&, long);  
  174.   friend int      ucompare(const Integer&, long); 
  175.   friend void     add(const Integer& x, long y, Integer& dest);
  176.   friend void     sub(const Integer& x, long y, Integer& dest);
  177.   friend void     mul(const Integer& x, long y, Integer& dest);
  178.   friend void     div(const Integer& x, long y, Integer& dest);
  179.   friend void     mod(const Integer& x, long y, Integer& dest);
  180.   friend void     divide(const Integer& x, long y, Integer& q, long& r);
  181.   friend void     and(const Integer& x, long y, Integer& dest);
  182.   friend void     or(const Integer& x, long y, Integer& dest);
  183.   friend void     xor(const Integer& x, long y, Integer& dest);
  184.   friend void     lshift(const Integer& x, long y, Integer& dest);
  185.   friend void     rshift(const Integer& x, long y, Integer& dest);
  186.   friend void     pow(const Integer& x, long y, Integer& dest);
  187.  
  188.   friend int      compare(long, const Integer&);  
  189.   friend int      ucompare(long, const Integer&); 
  190.   friend void     add(long x, const Integer& y, Integer& dest);
  191.   friend void     sub(long x, const Integer& y, Integer& dest);
  192.   friend void     mul(long x, const Integer& y, Integer& dest);
  193.   friend void     and(long x, const Integer& y, Integer& dest);
  194.   friend void     or(long x, const Integer& y, Integer& dest);
  195.   friend void     xor(long x, const Integer& y, Integer& dest);
  196.  
  197. // coercion & conversion
  198.  
  199.   int             fits_in_long() const;
  200.   int             fits_in_double() const;
  201.  
  202.                   operator long() const;
  203.                   operator double() const;
  204.  
  205.   friend char*    Itoa(const Integer& x, int base = 10, int width = 0);
  206.   friend Integer  atoI(const char* s, int base = 10);
  207.   void          printon(ostream& s, int base = 10, int width = 0) const;
  208.   
  209.   friend istream& operator >> (istream& s, Integer& y);
  210.   friend ostream& operator << (ostream& s, const Integer& y);
  211.  
  212. // error detection
  213.  
  214.   int             initialized() const;
  215.   void   error(const char* msg) const;
  216.   int             OK() const;  
  217. };
  218.  
  219.  
  220. //  (These are declared inline)
  221.  
  222.   int      operator == (const Integer&, const Integer&);
  223.   int      operator == (const Integer&, long);
  224.   int      operator != (const Integer&, const Integer&);
  225.   int      operator != (const Integer&, long);
  226.   int      operator <  (const Integer&, const Integer&);
  227.   int      operator <  (const Integer&, long);
  228.   int      operator <= (const Integer&, const Integer&);
  229.   int      operator <= (const Integer&, long);
  230.   int      operator >  (const Integer&, const Integer&);
  231.   int      operator >  (const Integer&, long);
  232.   int      operator >= (const Integer&, const Integer&);
  233.   int      operator >= (const Integer&, long);
  234.   Integer  operator -  (const Integer&);
  235.   Integer  operator ~  (const Integer&);
  236.   Integer  operator +  (const Integer&, const Integer&);
  237.   Integer  operator +  (const Integer&, long);
  238.   Integer  operator +  (long, const Integer&);
  239.   Integer  operator -  (const Integer&, const Integer&);
  240.   Integer  operator -  (const Integer&, long);
  241.   Integer  operator -  (long, const Integer&);
  242.   Integer  operator *  (const Integer&, const Integer&);
  243.   Integer  operator *  (const Integer&, long);
  244.   Integer  operator *  (long, const Integer&);
  245.   Integer  operator /  (const Integer&, const Integer&);
  246.   Integer  operator /  (const Integer&, long);
  247.   Integer  operator %  (const Integer&, const Integer&);
  248.   Integer  operator %  (const Integer&, long);
  249.   Integer  operator << (const Integer&, const Integer&);
  250.   Integer  operator << (const Integer&, long);
  251.   Integer  operator >> (const Integer&, const Integer&);
  252.   Integer  operator >> (const Integer&, long);
  253.   Integer  operator &  (const Integer&, const Integer&);
  254.   Integer  operator &  (const Integer&, long);
  255.   Integer  operator &  (long, const Integer&);
  256.   Integer  operator |  (const Integer&, const Integer&);
  257.   Integer  operator |  (const Integer&, long);
  258.   Integer  operator |  (long, const Integer&);
  259.   Integer  operator ^  (const Integer&, const Integer&);
  260.   Integer  operator ^  (const Integer&, long);
  261.   Integer  operator ^  (long, const Integer&);
  262.  
  263.   Integer  abs(const Integer&); // absolute value
  264.   Integer  sqr(const Integer&); // square
  265.  
  266.   Integer  pow(const Integer& x, const Integer& y);
  267.   Integer  pow(const Integer& x, long y);
  268.   Integer  Ipow(long x, long y); // x to the y as Integer 
  269.  
  270.  
  271. extern char*    dec(const Integer& x, int width = 0);
  272. extern char*    oct(const Integer& x, int width = 0);
  273. extern char*    hex(const Integer& x, int width = 0);
  274. extern Integer  sqrt(const Integer&); // floor of square root
  275. extern Integer  lcm(const Integer& x, const Integer& y); // least common mult
  276.  
  277.  
  278. typedef Integer IntTmp; // for backward compatibility
  279.  
  280. inline Integer::Integer() :rep(&_ZeroRep) {}
  281.  
  282. inline Integer::Integer(IntRep* r) :rep(r) {}
  283.  
  284. inline Integer::Integer(long y) :rep(Icopy_long(0, y)) {}
  285.  
  286. inline Integer::Integer(unsigned long y) :rep(Icopy_ulong(0, y)) {}
  287.  
  288. inline Integer::Integer(const Integer&  y) :rep(Icopy(0, y.rep)) {}
  289.  
  290. inline Integer::~Integer() { if (rep && !STATIC_IntRep(rep)) delete rep; }
  291.  
  292. inline void  Integer::operator = (const Integer&  y)
  293. {
  294.   rep = Icopy(rep, y.rep);
  295. }
  296.  
  297. inline void Integer::operator = (long y)
  298. {
  299.   rep = Icopy_long(rep, y); 
  300. }
  301.  
  302. inline Integer::operator long() const
  303. { 
  304.   return Itolong(rep);
  305. }
  306.  
  307. inline int Integer::initialized() const
  308. {
  309.   return rep != 0;
  310. }
  311.  
  312. inline int Integer::fits_in_long() const
  313. {
  314.   return Iislong(rep);
  315. }
  316.  
  317. inline Integer::operator double() const
  318. { 
  319.   return Itodouble(rep);
  320. }
  321.  
  322. inline int Integer::fits_in_double() const
  323. {
  324.   return Iisdouble(rep);
  325. }
  326.  
  327. // procedural versions
  328.  
  329. inline int compare(const Integer& x, const Integer& y)
  330. {
  331.   return compare(x.rep, y.rep);
  332. }
  333.  
  334. inline int ucompare(const Integer& x, const Integer& y)
  335. {
  336.   return ucompare(x.rep, y.rep);
  337. }
  338.  
  339. inline int compare(const Integer& x, long y)
  340. {
  341.   return compare(x.rep, y);
  342. }
  343.  
  344. inline int ucompare(const Integer& x, long y)
  345. {
  346.   return ucompare(x.rep, y);
  347. }
  348.  
  349. inline int compare(long x, const Integer& y)
  350. {
  351.   return -compare(y.rep, x);
  352. }
  353.  
  354. inline int ucompare(long x, const Integer& y)
  355. {
  356.   return -ucompare(y.rep, x);
  357. }
  358.  
  359. inline void  add(const Integer& x, const Integer& y, Integer& dest)
  360. {
  361.   dest.rep = add(x.rep, 0, y.rep, 0, dest.rep);
  362. }
  363.  
  364. inline void  sub(const Integer& x, const Integer& y, Integer& dest)
  365. {
  366.   dest.rep = add(x.rep, 0, y.rep, 1, dest.rep);
  367. }
  368.  
  369. inline void  mul(const Integer& x, const Integer& y, Integer& dest)
  370. {
  371.   dest.rep = multiply(x.rep, y.rep, dest.rep);
  372. }
  373.  
  374. inline void  div(const Integer& x, const Integer& y, Integer& dest)
  375. {
  376.   dest.rep = div(x.rep, y.rep, dest.rep);
  377. }
  378.  
  379. inline void  mod(const Integer& x, const Integer& y, Integer& dest)
  380. {
  381.   dest.rep = mod(x.rep, y.rep, dest.rep);
  382. }
  383.  
  384. inline void  and(const Integer& x, const Integer& y, Integer& dest)
  385. {
  386.   dest.rep = bitop(x.rep, y.rep, dest.rep, '&');
  387. }
  388.  
  389. inline void  or(const Integer& x, const Integer& y, Integer& dest)
  390. {
  391.   dest.rep = bitop(x.rep, y.rep, dest.rep, '|');
  392. }
  393.  
  394. inline void  xor(const Integer& x, const Integer& y, Integer& dest)
  395. {
  396.   dest.rep = bitop(x.rep, y.rep, dest.rep, '^');
  397. }
  398.  
  399. inline void  lshift(const Integer& x, const Integer& y, Integer& dest)
  400. {
  401.   dest.rep = lshift(x.rep, y.rep, 0, dest.rep);
  402. }
  403.  
  404. inline void  rshift(const Integer& x, const Integer& y, Integer& dest)
  405. {
  406.   dest.rep = lshift(x.rep, y.rep, 1, dest.rep);
  407. }
  408.  
  409. inline void  pow(const Integer& x, const Integer& y, Integer& dest)
  410. {
  411.   dest.rep = power(x.rep, long(y), dest.rep); // not incorrect
  412. }
  413.  
  414. inline void  add(const Integer& x, long y, Integer& dest)
  415. {
  416.   dest.rep = add(x.rep, 0, y, dest.rep);
  417. }
  418.  
  419. inline void  sub(const Integer& x, long y, Integer& dest)
  420. {
  421.   dest.rep = add(x.rep, 0, -y, dest.rep);
  422. }
  423.  
  424. inline void  mul(const Integer& x, long y, Integer& dest)
  425. {
  426.   dest.rep = multiply(x.rep, y, dest.rep);
  427. }
  428.  
  429. inline void  div(const Integer& x, long y, Integer& dest)
  430. {
  431.   dest.rep = div(x.rep, y, dest.rep);
  432. }
  433.  
  434. inline void  mod(const Integer& x, long y, Integer& dest)
  435. {
  436.   dest.rep = mod(x.rep, y, dest.rep);
  437. }
  438.  
  439. inline void  and(const Integer& x, long y, Integer& dest)
  440. {
  441.   dest.rep = bitop(x.rep, y, dest.rep, '&');
  442. }
  443.  
  444. inline void  or(const Integer& x, long y, Integer& dest)
  445. {
  446.   dest.rep = bitop(x.rep, y, dest.rep, '|');
  447. }
  448.  
  449. inline void  xor(const Integer& x, long y, Integer& dest)
  450. {
  451.   dest.rep = bitop(x.rep, y, dest.rep, '^');
  452. }
  453.  
  454. inline void  lshift(const Integer& x, long y, Integer& dest)
  455. {
  456.   dest.rep = lshift(x.rep, y, dest.rep);
  457. }
  458.  
  459. inline void  rshift(const Integer& x, long y, Integer& dest)
  460. {
  461.   dest.rep = lshift(x.rep, -y, dest.rep);
  462. }
  463.  
  464. inline void  pow(const Integer& x, long y, Integer& dest)
  465. {
  466.   dest.rep = power(x.rep, y, dest.rep);
  467. }
  468.  
  469. inline void abs(const Integer& x, Integer& dest)
  470. {
  471.   dest.rep = abs(x.rep, dest.rep);
  472. }
  473.  
  474. inline void negate(const Integer& x, Integer& dest)
  475. {
  476.   dest.rep = negate(x.rep, dest.rep);
  477. }
  478.  
  479. inline void complement(const Integer& x, Integer& dest)
  480. {
  481.   dest.rep = compl(x.rep, dest.rep);
  482. }
  483.  
  484. inline void  add(long x, const Integer& y, Integer& dest)
  485. {
  486.   dest.rep = add(y.rep, 0, x, dest.rep);
  487. }
  488.  
  489. inline void  sub(long x, const Integer& y, Integer& dest)
  490. {
  491.   dest.rep = add(y.rep, 1, x, dest.rep);
  492. }
  493.  
  494. inline void  mul(long x, const Integer& y, Integer& dest)
  495. {
  496.   dest.rep = multiply(y.rep, x, dest.rep);
  497. }
  498.  
  499. inline void  and(long x, const Integer& y, Integer& dest)
  500. {
  501.   dest.rep = bitop(y.rep, x, dest.rep, '&');
  502. }
  503.  
  504. inline void  or(long x, const Integer& y, Integer& dest)
  505. {
  506.   dest.rep = bitop(y.rep, x, dest.rep, '|');
  507. }
  508.  
  509. inline void  xor(long x, const Integer& y, Integer& dest)
  510. {
  511.   dest.rep = bitop(y.rep, x, dest.rep, '^');
  512. }
  513.  
  514.  
  515. // operator versions
  516.  
  517. inline int operator == (const Integer&  x, const Integer&  y)
  518. {
  519.   return compare(x, y) == 0; 
  520. }
  521.  
  522. inline int operator == (const Integer&  x, long y)
  523. {
  524.   return compare(x, y) == 0; 
  525. }
  526.  
  527. inline int operator != (const Integer&  x, const Integer&  y)
  528. {
  529.   return compare(x, y) != 0; 
  530. }
  531.  
  532. inline int operator != (const Integer&  x, long y)
  533. {
  534.   return compare(x, y) != 0; 
  535. }
  536.  
  537. inline int operator <  (const Integer&  x, const Integer&  y)
  538. {
  539.   return compare(x, y) <  0; 
  540. }
  541.  
  542. inline int operator <  (const Integer&  x, long y)
  543. {
  544.   return compare(x, y) <  0; 
  545. }
  546.  
  547. inline int operator <= (const Integer&  x, const Integer&  y)
  548. {
  549.   return compare(x, y) <= 0; 
  550. }
  551.  
  552. inline int operator <= (const Integer&  x, long y)
  553. {
  554.   return compare(x, y) <= 0; 
  555. }
  556.  
  557. inline int operator >  (const Integer&  x, const Integer&  y)
  558. {
  559.   return compare(x, y) >  0; 
  560. }
  561.  
  562. inline int operator >  (const Integer&  x, long y)
  563. {
  564.   return compare(x, y) >  0; 
  565. }
  566.  
  567. inline int operator >= (const Integer&  x, const Integer&  y)
  568. {
  569.   return compare(x, y) >= 0; 
  570. }
  571.  
  572. inline int operator >= (const Integer&  x, long y)
  573. {
  574.   return compare(x, y) >= 0; 
  575. }
  576.  
  577.  
  578. inline void  Integer::operator += (const Integer& y)
  579. {
  580.   add(*this, y, *this);
  581. }
  582.  
  583. inline void  Integer::operator += (long y)
  584. {
  585.   add(*this, y, *this);
  586. }
  587.  
  588. inline void Integer::operator ++ ()
  589. {
  590.   add(*this, 1, *this);
  591. }
  592.  
  593.  
  594. inline void  Integer::operator -= (const Integer& y)
  595. {
  596.   sub(*this, y, *this);
  597. }
  598.  
  599. inline void  Integer::operator -= (long y)
  600. {
  601.   sub(*this, y, *this);
  602. }
  603.  
  604. inline void Integer::operator -- ()
  605. {
  606.   add(*this, -1, *this);
  607. }
  608.  
  609.  
  610.  
  611. inline void Integer::operator *= (const Integer& y)
  612. {
  613.   mul(*this, y, *this);
  614. }
  615.  
  616. inline void Integer::operator *= (long y)
  617. {
  618.   mul(*this, y, *this);
  619. }
  620.  
  621.  
  622. inline void  Integer::operator &= (const Integer& y)
  623. {
  624.   and(*this, y, *this);
  625. }
  626.  
  627. inline void  Integer::operator &= (long y)
  628. {
  629.   and(*this, y, *this);
  630. }
  631.  
  632. inline void  Integer::operator |= (const Integer& y)
  633. {
  634.   or(*this, y, *this);
  635. }
  636.  
  637. inline void  Integer::operator |= (long y)
  638. {
  639.   or(*this, y, *this);
  640. }
  641.  
  642.  
  643. inline void  Integer::operator ^= (const Integer& y)
  644. {
  645.   xor(*this, y, *this);
  646. }
  647.  
  648. inline void  Integer::operator ^= (long y)
  649. {
  650.   xor(*this, y, *this);
  651. }
  652.  
  653.  
  654.  
  655. inline void Integer::operator /= (const Integer& y)
  656. {
  657.   div(*this, y, *this);
  658. }
  659.  
  660. inline void Integer::operator /= (long y)
  661. {
  662.   div(*this, y, *this);
  663. }
  664.  
  665.  
  666. inline void Integer::operator %= (const Integer& y)
  667. {
  668.   *this = *this % y; // mod(*this, y, *this) doesn't work.
  669. }
  670.  
  671. inline void Integer::operator %= (long y)
  672. {
  673.   *this = *this % y; // mod(*this, y, *this) doesn't work.
  674. }
  675.  
  676.  
  677. inline void Integer::operator <<= (const Integer&  y)
  678. {
  679.   lshift(*this, y, *this);
  680. }
  681.  
  682. inline void Integer::operator <<= (long  y)
  683. {
  684.   lshift(*this, y, *this);
  685. }
  686.  
  687.  
  688. inline void Integer::operator >>= (const Integer&  y)
  689. {
  690.   rshift(*this, y, *this);
  691. }
  692.  
  693. inline void  Integer::operator >>= (long y)
  694. {
  695.   rshift(*this, y, *this);
  696. }
  697.  
  698. #ifdef __GNUG__
  699. inline Integer operator <? (const Integer& x, const Integer& y)
  700. {
  701.   return (compare(x.rep, y.rep) <= 0) ? x : y;
  702. }
  703.  
  704. inline Integer operator >? (const Integer& x, const Integer& y)
  705. {
  706.   return (compare(x.rep, y.rep) >= 0)?  x : y;
  707. }
  708. #endif
  709.  
  710.  
  711. inline void Integer::abs()
  712. {
  713.   ::abs(*this, *this);
  714. }
  715.  
  716. inline void Integer::negate()
  717. {
  718.   ::negate(*this, *this);
  719. }
  720.  
  721.  
  722. inline void Integer::complement()
  723. {
  724.   ::complement(*this, *this);
  725. }
  726.  
  727.  
  728. inline int sign(const Integer& x)
  729. {
  730.   return (x.rep->len == 0) ? 0 : ( (x.rep->sgn == 1) ? 1 : -1 );
  731. }
  732.  
  733. inline int even(const Integer& y)
  734. {
  735.   return y.rep->len == 0 || !(y.rep->s[0] & 1);
  736. }
  737.  
  738. inline int odd(const Integer& y)
  739. {
  740.   return y.rep->len > 0 && (y.rep->s[0] & 1);
  741. }
  742.  
  743. inline char* Itoa(const Integer& y, int base, int width)
  744. {
  745.   return Itoa(y.rep, base, width);
  746. }
  747.  
  748.  
  749.  
  750. inline long lg(const Integer& x) 
  751. {
  752.   return lg(x.rep);
  753. }
  754.  
  755. // constructive operations 
  756.  
  757. #if defined(__GNUG__) && !defined(NO_NRV)
  758.  
  759. inline Integer  operator +  (const Integer& x, const Integer& y) return r
  760. {
  761.   add(x, y, r);
  762. }
  763.  
  764. inline Integer  operator +  (const Integer& x, long y) return r
  765. {
  766.   add(x, y, r);
  767. }
  768.  
  769. inline Integer  operator +  (long  x, const Integer& y) return r
  770. {
  771.   add(x, y, r);
  772. }
  773.  
  774. inline Integer  operator -  (const Integer& x, const Integer& y) return r
  775. {
  776.   sub(x, y, r);
  777. }
  778.  
  779. inline Integer  operator -  (const Integer& x, long y) return r
  780. {
  781.   sub(x, y, r);
  782. }
  783.  
  784. inline Integer  operator -  (long  x, const Integer& y) return r
  785. {
  786.   sub(x, y, r);
  787. }
  788.  
  789. inline Integer  operator *  (const Integer& x, const Integer& y) return r
  790. {
  791.   mul(x, y, r);
  792. }
  793.  
  794. inline Integer  operator *  (const Integer& x, long y) return r
  795. {
  796.   mul(x, y, r);
  797. }
  798.  
  799. inline Integer  operator *  (long  x, const Integer& y) return r
  800. {
  801.   mul(x, y, r);
  802. }
  803.  
  804. inline Integer sqr(const Integer& x) return r
  805. {
  806.   mul(x, x, r);
  807. }
  808.  
  809. inline Integer  operator &  (const Integer& x, const Integer& y) return r
  810. {
  811.   and(x, y, r);
  812. }
  813.  
  814. inline Integer  operator &  (const Integer& x, long y) return r
  815. {
  816.   and(x, y, r);
  817. }
  818.  
  819. inline Integer  operator &  (long  x, const Integer& y) return r
  820. {
  821.   and(x, y, r);
  822. }
  823.  
  824. inline Integer  operator |  (const Integer& x, const Integer& y) return r
  825. {
  826.   or(x, y, r);
  827. }
  828.  
  829. inline Integer  operator |  (const Integer& x, long y) return r
  830. {
  831.   or(x, y, r);
  832. }
  833.  
  834. inline Integer  operator |  (long  x, const Integer& y) return r
  835. {
  836.   or(x, y, r);
  837. }
  838.  
  839. inline Integer  operator ^  (const Integer& x, const Integer& y) return r
  840. {
  841.   xor(x, y, r);
  842. }
  843.  
  844. inline Integer  operator ^  (const Integer& x, long y) return r
  845. {
  846.   xor(x, y, r);
  847. }
  848.  
  849. inline Integer  operator ^  (long  x, const Integer& y) return r
  850. {
  851.   xor(x, y, r);
  852. }
  853.  
  854. inline Integer  operator /  (const Integer& x, const Integer& y) return r
  855. {
  856.   div(x, y, r);
  857. }
  858.  
  859. inline Integer operator /  (const Integer& x, long y) return r
  860. {
  861.   div(x, y, r);
  862. }
  863.  
  864. inline Integer operator %  (const Integer& x, const Integer& y) return r
  865. {
  866.   mod(x, y, r);
  867. }
  868.  
  869. inline Integer operator %  (const Integer& x, long y) return r
  870. {
  871.   mod(x, y, r);
  872. }
  873.  
  874. inline Integer operator <<  (const Integer& x, const Integer& y) return r
  875. {
  876.   lshift(x, y, r);
  877. }
  878.  
  879. inline Integer operator <<  (const Integer& x, long y) return r
  880. {
  881.   lshift(x, y, r);
  882. }
  883.  
  884. inline Integer operator >>  (const Integer& x, const Integer& y) return r;
  885. {
  886.   rshift(x, y, r);
  887. }
  888.  
  889. inline Integer operator >>  (const Integer& x, long y) return r
  890. {
  891.   rshift(x, y, r);
  892. }
  893.  
  894. inline Integer pow(const Integer& x, long y) return r
  895. {
  896.   pow(x, y, r);
  897. }
  898.  
  899. inline Integer Ipow(long x, long y) return r(x)
  900. {
  901.   pow(r, y, r);
  902. }
  903.  
  904. inline Integer pow(const Integer& x, const Integer& y) return r
  905. {
  906.   pow(x, y, r);
  907. }
  908.  
  909.  
  910.  
  911. inline Integer abs(const Integer& x) return r
  912. {
  913.   abs(x, r);
  914. }
  915.  
  916. inline Integer operator - (const Integer& x) return r
  917. {
  918.   negate(x, r);
  919. }
  920.  
  921. inline Integer operator ~ (const Integer& x) return r
  922. {
  923.   complement(x, r);
  924. }
  925.  
  926. inline Integer  atoI(const char* s, int base) return r
  927. {
  928.   r.rep = atoIntRep(s, base);
  929. }
  930.  
  931. inline Integer  gcd(const Integer& x, const Integer& y) return r
  932. {
  933.   r.rep = gcd(x.rep, y.rep);
  934. }
  935.  
  936. #else /* NO_NRV */
  937.  
  938. inline Integer  operator +  (const Integer& x, const Integer& y) 
  939. {
  940.   Integer r; add(x, y, r); return r;
  941. }
  942.  
  943. inline Integer  operator +  (const Integer& x, long y) 
  944. {
  945.   Integer r; add(x, y, r); return r;
  946. }
  947.  
  948. inline Integer  operator +  (long  x, const Integer& y) 
  949. {
  950.   Integer r; add(x, y, r); return r;
  951. }
  952.  
  953. inline Integer  operator -  (const Integer& x, const Integer& y) 
  954. {
  955.   Integer r; sub(x, y, r); return r;
  956. }
  957.  
  958. inline Integer  operator -  (const Integer& x, long y) 
  959. {
  960.   Integer r; sub(x, y, r); return r;
  961. }
  962.  
  963. inline Integer  operator -  (long  x, const Integer& y) 
  964. {
  965.   Integer r; sub(x, y, r); return r;
  966. }
  967.  
  968. inline Integer  operator *  (const Integer& x, const Integer& y) 
  969. {
  970.   Integer r; mul(x, y, r); return r;
  971. }
  972.  
  973. inline Integer  operator *  (const Integer& x, long y) 
  974. {
  975.   Integer r; mul(x, y, r); return r;
  976. }
  977.  
  978. inline Integer  operator *  (long  x, const Integer& y) 
  979. {
  980.   Integer r; mul(x, y, r); return r;
  981. }
  982.  
  983. inline Integer sqr(const Integer& x) 
  984. {
  985.   Integer r; mul(x, x, r); return r;
  986. }
  987.  
  988. inline Integer  operator &  (const Integer& x, const Integer& y) 
  989. {
  990.   Integer r; and(x, y, r); return r;
  991. }
  992.  
  993. inline Integer  operator &  (const Integer& x, long y) 
  994. {
  995.   Integer r; and(x, y, r); return r;
  996. }
  997.  
  998. inline Integer  operator &  (long  x, const Integer& y) 
  999. {
  1000.   Integer r; and(x, y, r); return r;
  1001. }
  1002.  
  1003. inline Integer  operator |  (const Integer& x, const Integer& y) 
  1004. {
  1005.   Integer r; or(x, y, r); return r;
  1006. }
  1007.  
  1008. inline Integer  operator |  (const Integer& x, long y) 
  1009. {
  1010.   Integer r; or(x, y, r); return r;
  1011. }
  1012.  
  1013. inline Integer  operator |  (long  x, const Integer& y) 
  1014. {
  1015.   Integer r; or(x, y, r); return r;
  1016. }
  1017.  
  1018. inline Integer  operator ^  (const Integer& x, const Integer& y) 
  1019. {
  1020.   Integer r; xor(x, y, r); return r;
  1021. }
  1022.  
  1023. inline Integer  operator ^  (const Integer& x, long y) 
  1024. {
  1025.   Integer r; xor(x, y, r); return r;
  1026. }
  1027.  
  1028. inline Integer  operator ^  (long  x, const Integer& y) 
  1029. {
  1030.   Integer r; xor(x, y, r); return r;
  1031. }
  1032.  
  1033. inline Integer  operator /  (const Integer& x, const Integer& y) 
  1034. {
  1035.   Integer r; div(x, y, r); return r;
  1036. }
  1037.  
  1038. inline Integer operator /  (const Integer& x, long y) 
  1039. {
  1040.   Integer r; div(x, y, r); return r;
  1041. }
  1042.  
  1043. inline Integer operator %  (const Integer& x, const Integer& y) 
  1044. {
  1045.   Integer r; mod(x, y, r); return r;
  1046. }
  1047.  
  1048. inline Integer operator %  (const Integer& x, long y) 
  1049. {
  1050.   Integer r; mod(x, y, r); return r;
  1051. }
  1052.  
  1053. inline Integer operator <<  (const Integer& x, const Integer& y) 
  1054. {
  1055.   Integer r; lshift(x, y, r); return r;
  1056. }
  1057.  
  1058. inline Integer operator <<  (const Integer& x, long y) 
  1059. {
  1060.   Integer r; lshift(x, y, r); return r;
  1061. }
  1062.  
  1063. inline Integer operator >>  (const Integer& x, const Integer& y) 
  1064. {
  1065.   Integer r; rshift(x, y, r); return r;
  1066. }
  1067.  
  1068. inline Integer operator >>  (const Integer& x, long y) 
  1069. {
  1070.   Integer r; rshift(x, y, r); return r;
  1071. }
  1072.  
  1073. inline Integer pow(const Integer& x, long y) 
  1074. {
  1075.   Integer r; pow(x, y, r); return r;
  1076. }
  1077.  
  1078. inline Integer Ipow(long x, long y) 
  1079. {
  1080.   Integer r(x); pow(r, y, r); return r;
  1081. }
  1082.  
  1083. inline Integer pow(const Integer& x, const Integer& y) 
  1084. {
  1085.   Integer r; pow(x, y, r); return r;
  1086. }
  1087.  
  1088.  
  1089.  
  1090. inline Integer abs(const Integer& x) 
  1091. {
  1092.   Integer r; abs(x, r); return r;
  1093. }
  1094.  
  1095. inline Integer operator - (const Integer& x) 
  1096. {
  1097.   Integer r; negate(x, r); return r;
  1098. }
  1099.  
  1100. inline Integer operator ~ (const Integer& x) 
  1101. {
  1102.   Integer r; complement(x, r); return r;
  1103. }
  1104.  
  1105. inline Integer  atoI(const char* s, int base) 
  1106. {
  1107.   Integer r; r.rep = atoIntRep(s, base); return r;
  1108. }
  1109.  
  1110. inline Integer  gcd(const Integer& x, const Integer& y) 
  1111. {
  1112.   Integer r; r.rep = gcd(x.rep, y.rep); return r;
  1113. }
  1114.  
  1115. #endif  /* NO_NRV */
  1116. #endif /* !_Integer_h */
  1117.