Changeset 1027


Ignore:
Timestamp:
Jul 17, 2003, 4:15:17 PM (17 years ago)
Author:
pooh
Message:
  • Most long arithmetic functions implemented.
Location:
to-imperative/trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • to-imperative/trunk/library/Arithm/add.cc

    r591 r1027  
    66#include <rf_core.hh>
    77#include <rf_short_int.hh>
     8#include <rf_integer.ih>
     9#include <inttypes.h>
     10#include <gmp.h>
    811
    912namespace refal
     
    1619{
    1720
    18 RF_FUNC (_p_, (RF_ARG s_Int1, s_Int2), (RF_RES s_Int))
     21RF_FUNC (_p_, (RF_ARG s_Int1, s_Int2), (RF_RES s_Res))
    1922
    20   Term* p_Int1 = s_Int1.get_first(); 
    21   Term* p_Int2 = s_Int2.get_first(); 
    22  
    23   intptr_t int1 = 0;
    24   intptr_t int2 = 0;
    25  
    26   if (p_Int1->get_type() == type_short_int)
    27   {
    28     int1 = ((ShortInt*)p_Int1)->to_int();
    29     //Int i1 = *p_Int1;
    30     //int1 = i1.to_uint();
    31   }
    32   else
    33   if (p_Int1->get_type() == type_int)
    34   {
    35     //ShortInt i1 = *p_Int1;
    36     //int1 = i1;
    37      RF_LIB_ERROR("Invalid argument");
    38   }
    39   else
    40   {
     23  Term* p_Int1 = s_Int1.get_first();
     24  Term* p_Int2 = s_Int2.get_first();
     25
     26  if (p_Int1->get_type() == type_short_int) {
     27    intptr_t i1 = static_cast<ShortInt*>(p_Int1)->to_int();
     28    if (p_Int2->get_type() == type_short_int) {
     29      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     30      if ((((i1 > 0) && (i2 > 0)) || ((i1 < 0) && (i2 < 0))) &&
     31          imaxabs(i1) >= INTPTR_MAX - imaxabs(i2)
     32      ) {
     33        s_Res = Integer::create_expr(i1 + Integer(i2));
     34      } else {
     35        s_Res = ShortInt::create_expr(i1 + i2);
     36      }
     37    } else if (p_Int2->get_type() == type_int) {
     38      Integer* i2 = static_cast<Integer*>(p_Int2);
     39      s_Res = Integer::create_expr(i1 + (*i2));
     40    } else {
     41      RF_LIB_ERROR("Invalid argument");
     42    }
     43  } else if (p_Int1->get_type() == type_int) {
     44    Integer* i1 = static_cast<Integer*>(p_Int1);
     45    if (p_Int2->get_type() == type_short_int) {
     46      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     47      s_Res = Integer::create_expr((*i1) + i2);
     48    } else if (p_Int2->get_type() == type_int) {
     49      Integer* i2 = static_cast<Integer*>(p_Int2);
     50      s_Res = Integer::create_expr((*i1) + (*i2));
     51    } else {
     52      RF_LIB_ERROR("Invalid argument");
     53    }
     54  } else {
    4155    RF_LIB_ERROR("Invalid argument");
    4256  }
    43 
    44   if (p_Int2->get_type() == type_short_int)
    45   {
    46      int2 = ((ShortInt*)p_Int2)->to_int();
    47 
    48     //Int i2 = *p_Int2;
    49     // int2 = i2.to_uint();
    50   }
    51   else
    52   if (p_Int2->get_type() == type_int)
    53   {
    54     RF_LIB_ERROR("Invalid argument");
    55 
    56     //    ShortInt i2 = *p_Int2;
    57     //  int2 = i2;
    58   }
    59   else
    60   {
    61     RF_LIB_ERROR("Invalid argument");
    62   }
    63 
    64   if (int1 > 0)
    65   {
    66     if (int2 > 0 && int1 > INTPTR_MAX - int2)
    67       RF_LIB_ERROR("Size limit exceeded");
    68   }
    69   else
    70   if (int2 < 0 && int1 < INTPTR_MIN - int2)
    71     RF_LIB_ERROR("Size limit exceeded");
    72 
    73   s_Int = ShortInt::create_expr(int1 + int2);
    74 
    75 
    76          
    7757RF_END
    7858}
     59
    7960}
  • to-imperative/trunk/library/Arithm/div.cc

    r591 r1027  
    66#include <rf_core.hh>
    77#include <rf_short_int.hh>
     8#include <rf_integer.ih>
     9#include <inttypes.h>
     10#include <gmp.h>
    811
    912namespace refal
     
    1619{
    1720
    18 RF_FUNC (Div, (RF_ARG s_Int1, s_Int2), (RF_RES s_Quo))
     21RF_FUNC (Div, (RF_ARG s_Int1, s_Int2), (RF_RES s_Res))
    1922
    20   Term* p_Int1 = s_Int1.get_first(); 
    21   Term* p_Int2 = s_Int2.get_first(); 
    22  
    23   intptr_t int1 = 0;
    24   intptr_t int2 = 0;
     23  Term* p_Int1 = s_Int1.get_first();
     24  Term* p_Int2 = s_Int2.get_first();
    2525
    26    if (p_Int1->get_type() == type_short_int)
    27   {
    28     int1 = ((ShortInt*)p_Int1)->to_int();
    29   }
    30   else
    31   if (p_Int1->get_type() == type_int)
    32   {
     26  if (p_Int1->get_type() == type_short_int) {
     27    intptr_t i1 = static_cast<ShortInt*>(p_Int1)->to_int();
     28    if (p_Int2->get_type() == type_short_int) {
     29      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     30      s_Res = ShortInt::create_expr(i1 / i2);
     31    } else if (p_Int2->get_type() == type_int) {
     32      Integer* i2 = static_cast<Integer*>(p_Int2);
     33      s_Res = Integer::create_expr(i1 / (*i2));
     34    } else {
     35      RF_LIB_ERROR("Invalid argument");
     36    }
     37  } else if (p_Int1->get_type() == type_int) {
     38    Integer* i1 = static_cast<Integer*>(p_Int1);
     39    if (p_Int2->get_type() == type_short_int) {
     40      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     41      s_Res = Integer::create_expr((*i1) / i2);
     42    } else if (p_Int2->get_type() == type_int) {
     43      Integer* i2 = static_cast<Integer*>(p_Int2);
     44      s_Res = Integer::create_expr((*i1) / (*i2));
     45    } else {
     46      RF_LIB_ERROR("Invalid argument");
     47    }
     48  } else {
    3349    RF_LIB_ERROR("Invalid argument");
    3450  }
    35   else
    36   {
    37     RF_LIB_ERROR("Invalid argument");
    38   }
    39   if (p_Int2->get_type() == type_short_int)
    40   {
    41     int2 = ((ShortInt*)p_Int2)->to_int();
    42   }
    43   else
    44   if (p_Int2->get_type() == type_int)
    45   {
    46     RF_LIB_ERROR("Invalid argument");
    47   }
    48   else
    49   {
    50     RF_LIB_ERROR("Invalid argument");
    51   }
    52   if (!int2)
    53     RF_LIB_ERROR("DIV Divide by zero");
    54 
    55   s_Quo = ShortInt::create_expr(int1 / int2);
    56 
    5751RF_END
    5852}
     53
    5954}
  • to-imperative/trunk/library/Arithm/mult.cc

    r1010 r1027  
    1919{
    2020
    21 RF_FUNC (_a_, (RF_ARG s_Int1, s_Int2), (RF_RES s_Int))
     21RF_FUNC (_a_, (RF_ARG s_Int1, s_Int2), (RF_RES s_Res))
    2222
    2323  Term* p_Int1 = s_Int1.get_first();
    2424  Term* p_Int2 = s_Int2.get_first();
    2525
    26   intptr_t int1;
    27   intptr_t int2;
    28   Expr result;
    29 
    3026  if (p_Int1->get_type() == type_short_int) {
    31     int1 = ((ShortInt*)p_Int1)->to_int();
     27    intptr_t i1 = static_cast<ShortInt*>(p_Int1)->to_int();
    3228    if (p_Int2->get_type() == type_short_int) {
    33       int2 = ((ShortInt*)p_Int2)->to_int();
    34       if (imaxabs(int1) < INTPTR_MAX / imaxabs(int2)) {
    35         result = ShortInt::create_expr(int1 * int2);
     29      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     30      if (imaxabs(i1) < INTPTR_MAX / imaxabs(i2)) {
     31        s_Res = ShortInt::create_expr(i1 * i2);
    3632      } else {
    37         result = Integer::create_expr(int1);
    38         Integer* res = static_cast<Integer*>(result.get_first());
    39         mpz_t* resp = res->get_mpz_ptr();
    40         mpz_mul_si(*resp, *resp, int2);
     33        s_Res = Integer::create_expr(i1 * Integer(i2));
    4134      }
    4235    } else if (p_Int2->get_type() == type_int) {
    43       result = Integer::create_expr(int1);
    44       Integer* res = static_cast<Integer*>(result.get_first());
    45       mpz_t* resp = res->get_mpz_ptr();
    4636      Integer* i2 = static_cast<Integer*>(p_Int2);
    47       mpz_t* i2p = i2->get_mpz_ptr();
    48       mpz_mul(*resp, *resp, *i2p);
     37      s_Res = Integer::create_expr(i1 * (*i2));
    4938    } else {
    5039      RF_LIB_ERROR("Invalid argument");
     
    5241  } else if (p_Int1->get_type() == type_int) {
    5342    Integer* i1 = static_cast<Integer*>(p_Int1);
    54     mpz_t* i1p = i1->get_mpz_ptr();
    5543    if (p_Int2->get_type() == type_short_int) {
    56       int2 = ((ShortInt*)p_Int2)->to_int();
    57       result = Integer::create_expr(int2);
    58       Integer* res = static_cast<Integer*>(result.get_first());
    59       mpz_t* resp = res->get_mpz_ptr();
    60       mpz_mul(*resp, *resp, *i1p);
     44      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     45      s_Res = Integer::create_expr((*i1) * i2);
    6146    } else if (p_Int2->get_type() == type_int) {
    62       result = Integer::create_expr(0);
    63       Integer* res = static_cast<Integer*>(result.get_first());
    64       mpz_t* resp = res->get_mpz_ptr();
    6547      Integer* i2 = static_cast<Integer*>(p_Int2);
    66       mpz_t* i2p = i2->get_mpz_ptr();
    67       mpz_mul(*resp, *i1p, *i2p);
     48      s_Res = Integer::create_expr((*i1) * (*i2));
    6849    } else {
    6950      RF_LIB_ERROR("Invalid argument");
     
    7253    RF_LIB_ERROR("Invalid argument");
    7354  }
    74   s_Int = result;
    7555RF_END
    7656}
  • to-imperative/trunk/library/Arithm/rem.cc

    r591 r1027  
    66#include <rf_core.hh>
    77#include <rf_short_int.hh>
     8#include <rf_integer.ih>
     9#include <inttypes.h>
     10#include <gmp.h>
    811
    912namespace refal
     
    1518namespace Arithm
    1619{
    17 RF_FUNC (Rem, (RF_ARG s_Int1, s_Int2), (RF_RES s_Rem))
    1820
    19   Term* p_Int1 = s_Int1.get_first(); 
    20   Term* p_Int2 = s_Int2.get_first(); 
    21  
    22   intptr_t int1 = 0;
    23   intptr_t int2 = 0;
     21RF_FUNC (Rem, (RF_ARG s_Int1, s_Int2), (RF_RES s_Res))
    2422
    25   if (p_Int1->get_type() == type_short_int)
    26   {
    27     int1 = ((ShortInt*)p_Int1)->to_int();
    28   }
    29   else
    30   if (p_Int1->get_type() == type_int)
    31   {
     23  Term* p_Int1 = s_Int1.get_first();
     24  Term* p_Int2 = s_Int2.get_first();
     25
     26  if (p_Int1->get_type() == type_short_int) {
     27    intptr_t i1 = static_cast<ShortInt*>(p_Int1)->to_int();
     28    if (p_Int2->get_type() == type_short_int) {
     29      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     30      s_Res = ShortInt::create_expr(i1 % i2);
     31    } else if (p_Int2->get_type() == type_int) {
     32      Integer* i2 = static_cast<Integer*>(p_Int2);
     33      s_Res = Integer::create_expr(i1 % (*i2));
     34    } else {
     35      RF_LIB_ERROR("Invalid argument");
     36    }
     37  } else if (p_Int1->get_type() == type_int) {
     38    Integer* i1 = static_cast<Integer*>(p_Int1);
     39    if (p_Int2->get_type() == type_short_int) {
     40      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     41      s_Res = Integer::create_expr((*i1) % i2);
     42    } else if (p_Int2->get_type() == type_int) {
     43      Integer* i2 = static_cast<Integer*>(p_Int2);
     44      s_Res = Integer::create_expr((*i1) % (*i2));
     45    } else {
     46      RF_LIB_ERROR("Invalid argument");
     47    }
     48  } else {
    3249    RF_LIB_ERROR("Invalid argument");
    3350  }
    34   else
    35   {
    36     RF_LIB_ERROR("Invalid argument");
    37   }
    38 
    39   if (p_Int2->get_type() == type_short_int)
    40   {
    41     int2 = ((ShortInt*)p_Int2)->to_int();
    42   }
    43   else
    44   if (p_Int2->get_type() == type_int)
    45   {
    46     RF_LIB_ERROR("Invalid argument");
    47   }
    48   else
    49   {
    50     RF_LIB_ERROR("Invalid argument");
    51   }
    52   if (!int2)
    53     RF_LIB_ERROR("DIV Divide by zero");
    54  
    55   s_Rem = ShortInt::create_expr(int1 % int2);
    56 
    5751RF_END
    5852}
     53
    5954}
  • to-imperative/trunk/library/Arithm/sub.cc

    r591 r1027  
    66#include <rf_core.hh>
    77#include <rf_short_int.hh>
     8#include <rf_integer.ih>
     9#include <inttypes.h>
     10#include <gmp.h>
    811
    912namespace refal
     
    1316using namespace rftype;
    1417
    15   namespace Arithm
     18namespace Arithm
    1619{
    1720
     21RF_FUNC (_m_, (RF_ARG s_Int1, s_Int2), (RF_RES s_Res))
    1822
    19 RF_FUNC (_m_, (RF_ARG s_Int1, s_Int2), (RF_RES s_Int))
     23  Term* p_Int1 = s_Int1.get_first();
     24  Term* p_Int2 = s_Int2.get_first();
    2025
    21   Term* p_Int1 = s_Int1.get_first(); 
    22   Term* p_Int2 = s_Int2.get_first();
    23 
    24   intptr_t int1 = 0;
    25   intptr_t int2 = 0;
    26  
    27   if (p_Int1->get_type() == type_short_int)
    28   {
    29     int1 = ((ShortInt*)p_Int1)->to_int();
    30     //    Int i1 = *p_Int1;
    31     //    int1 = i1.to_uint();
    32   }
    33   else
    34   if (p_Int1->get_type() == type_int)
    35   {
    36     RF_LIB_ERROR("Invalid argument");
    37     //    ShortInt i1 = *p_Int1;
    38     //    int1 = i1;
    39   }
    40   else
    41   {
     26  if (p_Int1->get_type() == type_short_int) {
     27    intptr_t i1 = static_cast<ShortInt*>(p_Int1)->to_int();
     28    if (p_Int2->get_type() == type_short_int) {
     29      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     30      if ((((i1 > 0) && (i2 < 0)) || ((i1 < 0) && (i2 > 0))) &&
     31          imaxabs(i1) >= INTPTR_MAX - imaxabs(i2)
     32      ) {
     33        s_Res = Integer::create_expr(i1 - Integer(i2));
     34      } else {
     35        s_Res = ShortInt::create_expr(i1 - i2);
     36      }
     37    } else if (p_Int2->get_type() == type_int) {
     38      Integer* i2 = static_cast<Integer*>(p_Int2);
     39      s_Res = Integer::create_expr(i1 - (*i2));
     40    } else {
     41      RF_LIB_ERROR("Invalid argument");
     42    }
     43  } else if (p_Int1->get_type() == type_int) {
     44    Integer* i1 = static_cast<Integer*>(p_Int1);
     45    if (p_Int2->get_type() == type_short_int) {
     46      intptr_t i2 = static_cast<ShortInt*>(p_Int2)->to_int();
     47      s_Res = Integer::create_expr((*i1) - i2);
     48    } else if (p_Int2->get_type() == type_int) {
     49      Integer* i2 = static_cast<Integer*>(p_Int2);
     50      s_Res = Integer::create_expr((*i1) - (*i2));
     51    } else {
     52      RF_LIB_ERROR("Invalid argument");
     53    }
     54  } else {
    4255    RF_LIB_ERROR("Invalid argument");
    4356  }
    44 
    45   if (p_Int2->get_type() == type_short_int)
    46   {
    47     int2 = ((ShortInt*)p_Int2)->to_int();
    48     //    Int i2 = *p_Int2;
    49     //    int2 = i2.to_uint();
    50   }
    51   else
    52   if (p_Int2->get_type() == type_int)
    53   {
    54     RF_LIB_ERROR("Invalid argument");
    55     //    ShortInt i2 = *p_Int2;
    56     //    int2 = i2;
    57   }
    58   else
    59   {
    60     RF_LIB_ERROR("Invalid argument");
    61   }
    62 
    63    if (int1 > 0)
    64   {
    65     if (int2 < 0 && int1 > INTPTR_MAX + int2)
    66       RF_LIB_ERROR("Size limit exceeded");
    67   }
    68   else
    69   if (int2 > 0 && int1 < INTPTR_MIN + int2)
    70     RF_LIB_ERROR("Size limit exceeded");
    71 
    72   s_Int = ShortInt::create_expr(int1 - int2);
    73 
    7457RF_END
    7558}
     59
    7660}
  • to-imperative/trunk/runtime/rf_integer.hh

    r1010 r1027  
    2828  inline int cmp (Integer const& _n) const ;
    2929
     30  inline Integer operator + (Integer const& _n) const ;
     31  inline Integer operator + (intptr_t _n) const ;
     32  friend inline Integer operator + (intptr_t _n1, Integer const& _n2) ;
     33  inline Integer operator - (Integer const& _n) const ;
     34  inline Integer operator - (intptr_t _n) const ;
     35  friend inline Integer operator - (intptr_t _n1, Integer const& _n2) ;
     36  inline Integer operator * (Integer const& _n) const ;
     37  inline Integer operator * (intptr_t _n) const ;
     38  friend inline Integer operator * (intptr_t _n1, Integer const& _n2) ;
     39  inline Integer operator / (Integer const& _n) const ;
     40  inline Integer operator / (intptr_t _n) const ;
     41  friend inline Integer operator / (intptr_t _n1, Integer const& _n2) ;
     42  inline Integer operator % (Integer const& _n) const ;
     43  inline Integer operator % (intptr_t _n) const ;
     44  friend inline Integer operator % (intptr_t _n1, Integer const& _n2) ;
     45
    3046  inline operator pxx::WString () const ;
    3147
    3248  static inline Expr create_expr (intptr_t _n) ;
    3349  static inline Expr create_expr (pxx::WString& _str) ;
    34   inline mpz_t* get_mpz_ptr () ;
     50  static inline Expr create_expr (Integer const& _n) ;
     51  inline mpz_t* get_mpz_ptr () const ;
    3552
    3653  inline size_t get_char_len () const ;
  • to-imperative/trunk/runtime/rf_integer.ih

    r1010 r1027  
    4444inline Integer::~Integer ()
    4545{
    46   mpz_t* p = static_cast<mpz_t*>(ptr_data2);
    47   mpz_clear(*p);
    48   mpz_allocator.deallocate(p);
     46//  mpz_t* p = static_cast<mpz_t*>(ptr_data2);
     47//  mpz_clear(*p);
     48//  mpz_allocator.deallocate(p);
    4949}
    5050
     
    7070  mpz_t* q = static_cast<mpz_t*>(_n.ptr_data2);
    7171  return mpz_cmp(*p, *q);
     72}
     73
     74inline Integer Integer::operator + (Integer const& _n) const
     75{
     76  Integer res(self);
     77  mpz_t* resp = res.get_mpz_ptr();
     78  mpz_add(*resp, *resp, *(_n.get_mpz_ptr()));
     79  return res;
     80}
     81
     82inline Integer Integer::operator + (intptr_t _n) const
     83{
     84  Integer res(self);
     85  mpz_t* resp = res.get_mpz_ptr();
     86  _n >= 0 ? mpz_add_ui(*resp, *resp, _n) : mpz_sub_ui(*resp, *resp, -_n);
     87  return res;
     88}
     89
     90inline Integer operator + (intptr_t _n1, Integer const& _n2)
     91{
     92  Integer res(_n2);
     93  mpz_t* resp = res.get_mpz_ptr();
     94  _n1 >= 0 ? mpz_add_ui(*resp, *resp, _n1) : mpz_sub_ui(*resp, *resp, -_n1);
     95  return res;
     96}
     97
     98inline Integer Integer::operator - (Integer const& _n) const
     99{
     100  Integer res(self);
     101  mpz_t* resp = res.get_mpz_ptr();
     102  mpz_sub(*resp, *resp, *(_n.get_mpz_ptr()));
     103  return res;
     104}
     105
     106inline Integer Integer::operator - (intptr_t _n) const
     107{
     108  Integer res(self);
     109  mpz_t* resp = res.get_mpz_ptr();
     110  _n >= 0 ? mpz_sub_ui(*resp, *resp, _n) : mpz_add_ui(*resp, *resp, -_n);
     111  return res;
     112}
     113
     114inline Integer operator - (intptr_t _n1, Integer const& _n2)
     115{
     116  Integer res(_n2);
     117  mpz_t* resp = res.get_mpz_ptr();
     118  mpz_neg(*resp, *resp);
     119  _n1 >= 0 ? mpz_add_ui(*resp, *resp, _n1) : mpz_sub_ui(*resp, *resp, -_n1);
     120  return res;
     121}
     122
     123inline Integer Integer::operator * (Integer const& _n) const
     124{
     125  Integer res(self);
     126  mpz_t* resp = res.get_mpz_ptr();
     127  mpz_mul(*resp, *resp, *(_n.get_mpz_ptr()));
     128  return res;
     129}
     130
     131inline Integer Integer::operator * (intptr_t _n) const
     132{
     133  Integer res(self);
     134  mpz_t* resp = res.get_mpz_ptr();
     135  mpz_mul_si(*resp, *resp, _n);
     136  return res;
     137}
     138
     139inline Integer operator * (intptr_t _n1, Integer const& _n2)
     140{
     141  Integer res(_n2);
     142  mpz_t* resp = res.get_mpz_ptr();
     143  mpz_mul_si(*resp, *resp, _n1);
     144  return res;
     145}
     146
     147inline Integer Integer::operator / (Integer const& _n) const
     148{
     149  Integer res(self);
     150  mpz_t* resp = res.get_mpz_ptr();
     151  mpz_tdiv_q(*resp, *resp, *(_n.get_mpz_ptr()));
     152  return res;
     153}
     154
     155inline Integer Integer::operator / (intptr_t _n) const
     156{
     157  Integer res(self);
     158  mpz_t* resp = res.get_mpz_ptr();
     159  if (_n >= 0 ) {
     160    mpz_tdiv_q_ui(*resp, *resp, _n);
     161  } else {
     162    mpz_tdiv_q_ui(*resp, *resp, -_n);
     163    mpz_neg(*resp, *resp);
     164  }
     165  return res;
     166}
     167
     168inline Integer operator / (intptr_t _n1, Integer const& _n2)
     169{
     170  return Integer(_n1) / _n2;
     171}
     172
     173inline Integer Integer::operator % (Integer const& _n) const
     174{
     175  Integer res(self);
     176  mpz_t* resp = res.get_mpz_ptr();
     177  mpz_tdiv_r(*resp, *resp, *(_n.get_mpz_ptr()));
     178  return res;
     179}
     180
     181inline Integer Integer::operator % (intptr_t _n) const
     182{
     183  Integer res(self);
     184  mpz_t* resp = res.get_mpz_ptr();
     185  if (_n >= 0 ) {
     186    mpz_tdiv_r_ui(*resp, *resp, _n);
     187  } else {
     188    mpz_tdiv_r_ui(*resp, *resp, -_n);
     189    mpz_neg(*resp, *resp);
     190  }
     191  return res;
     192}
     193
     194inline Integer operator % (intptr_t _n1, Integer const& _n2)
     195{
     196  return Integer(_n1) % _n2;
    72197}
    73198
     
    92217}
    93218
    94 inline mpz_t* Integer::get_mpz_ptr ()
     219inline Expr Integer::create_expr (Integer const& _n)
     220{
     221  Expr e = Term::create_expr(1);
     222  new(e.get_first()) Integer(_n);
     223  return e;
     224}
     225
     226inline mpz_t* Integer::get_mpz_ptr () const
    95227{
    96228  return static_cast<mpz_t*>(ptr_data2);
Note: See TracChangeset for help on using the changeset viewer.