From 058b45976f00126aa2d9c1eb64c53a0917e89de7 Mon Sep 17 00:00:00 2001 From: Ata Deniz Aydin Date: Mon, 15 May 2017 10:48:33 +0300 Subject: [PATCH] update padic.py --- padic.py | 67 ++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 41 insertions(+), 26 deletions(-) diff --git a/padic.py b/padic.py index bdbbf6e..198111f 100644 --- a/padic.py +++ b/padic.py @@ -6,17 +6,19 @@ class PAdic: def __init__(self, p): self.p = p self.val = '' # current known value - self.prec = 0 # current known precision, also containing leading zeros + self.prec = 0 # current known precision, not containing trailing zeros self.order = 0 # order/valuation of number pass # initialize object as subclass perhaps - def get(self, prec): + def get(self, prec, decimal = True): 'Return value of number with given precision.' while self.prec < prec: # update val based on value - self.val = self._nextdigit() + self.val + self.val = str(int(self._nextdigit())) + self.val self.prec += 1 - return self.val # TODO add decimal point or trailing zeros + if self.order < 0: + return (self.val[:self.order] + ('.' if decimal else '') + self.val[self.order:])[-prec-1:] + return (self.val + self.order * '0')[-prec:] def _nextdigit(self): 'Calculate next digit of p-adic number.' @@ -24,15 +26,17 @@ class PAdic: def getdigit(self, index): 'Return digit at given index.' - return int(self.get(index+1)[0]) + return int(self.get(index + 1, False)[0]) #int(self.get(index+1+int(index < -self.order))[-int(index < -self.order)]) # return value with precision up to 32 bits def __int__(self): - return int(self.get(32), p) + return int(self.get(32), self.p) def __str__(self): return self.get(32) # arithmetic operations + def __neg__(self): + return PAdicNeg(self.p, self) def __add__(self, other): return PAdicAdd(self.p, self, other) def __radd__(self, other): @@ -41,21 +45,21 @@ class PAdic: return PAdicAdd(self.p, self, PAdicNeg(self.p, other)) def __rsub__(self, other): return PAdicAdd(self.p, other, PAdicNeg(self.p, self)) - def __smul__(self, other): + def __mul__(self, other): return PAdicMul(self.p, self, other) - def __rsub__(self, other): + def __rmul__(self, other): return PAdicMul(self.p, other, self) # p-adic norm def __abs__(self): if self.order == maxint: return 0 - norm = Fraction(1) + numer = denom = 1 if self.order > 0: - norm.numerator = self.p ** self.order + numer = self.p ** self.order if self.order < 0: - norm.denominator = self.p ** self.order - return norm + denom = self.p ** self.order + return Fraction(numer, denom) class PAdicConst(PAdic): def __init__(self, p, value): @@ -72,22 +76,23 @@ class PAdicConst(PAdic): self.order = 0 while not value.numerator % self.p: self.order += 1 - self.prec += 1 - value.numerator /= self.p + value /= self.p while not value.denominator % self.p: - valuation -= 1 - value.denominator /= self.p + self.order -= 1 + value *= self.p self.value = value + + self.zero = not value - def get(self, prec): - if self.value == 0: - return '0' # * prec - return PAdic.get(self, prec) + def get(self, prec, decimal = True): + if self.zero: + return '0' * prec + return PAdic.get(self, prec, decimal) def _nextdigit(self): 'Calculate next digit of p-adic number.' rem = ModP(self.p, self.value.numerator) / ModP(self.p, self.value.denominator) - self.value -= rem + self.value -= int(rem) self.value /= self.p return rem @@ -98,17 +103,23 @@ class PAdicAdd(PAdic): self.carry = 0 self.arg1 = arg1 self.arg2 = arg2 - self.order = min(arg1.order, arg2.order) # might be larger than this + self.order = self.prec = min(arg1.order, arg2.order) # might be larger than this + arg1.order -= self.order + arg2.order -= self.order # loop until first nonzero digit is found + self.index = 0 digit = self._nextdigit() while digit == 0: + self.index += 1 self.order += 1 - self.prec += 1 digit = self._nextdigit() + self.val += str(int(digit)) + self.prec = 1 def _nextdigit(self): - s = self.arg1.getdigit(self.prec) + self.arg2.getdigit(self.prec) + self.carry + s = self.arg1.getdigit(self.index) + self.arg2.getdigit(self.index) + self.carry self.carry = s // self.p + self.index += 1 return s % self.p class PAdicNeg(PAdic): @@ -121,7 +132,7 @@ class PAdicNeg(PAdic): def _nextdigit(self): if self.prec == 0: return self.p - self.arg.getdigit(0) # cannot be p, 0th digit of arg must be nonzero - return self.p - 1 - self.arg.getdigit(0) + return self.p - 1 - self.arg.getdigit(self.prec) class PAdicMul(PAdic): 'Product of two p-adic numbers.' @@ -130,8 +141,12 @@ class PAdicMul(PAdic): self.carry = 0 self.arg1 = arg1 self.arg2 = arg2 + self.order = arg1.order + arg2.order + self.arg1.order = self.arg2.order = 0 # TODO requires copy + self.index = 0 def _nextdigit(self): - s = sum(self.arg1.getdigit(i) * self.arg2.getdigit(self.prec - i) for i in xrange(self.prec + 1)) + self.carry + s = sum(self.arg1.getdigit(i) * self.arg2.getdigit(self.index - i) for i in xrange(self.index + 1)) + self.carry self.carry = s // self.p + self.index += 1 return s % self.p \ No newline at end of file