NZMATH  1.2.0 About: NZMATH is a Python based number theory oriented calculation system.   Fossies Dox: NZMATH-1.2.0.tar.gz  ("inofficial" and yet experimental doxygen-generated source code documentation)
real.py
Go to the documentation of this file.
1 """
2 real -- real numbers and the real number field.
3
4 The module real provides arbitrary precision real numbers and their
5 utilities. The functions provided are corresponding to the math
6 standard module.
7 """
8
9 from __future__ import division
10 import itertools
11 import warnings
12
13 import nzmath.arith1 as arith1
14 import nzmath.rational as rational
15 import nzmath.ring as ring
16 from nzmath.plugins import MATHMODULE as math, FLOATTYPE as Float, \
17  CHECK_REAL_OR_COMPLEX as check_real_or_complex
18
19
21  """
22  Real is a class of real.
23  This class is only for consistency for other Ring object.
24  """
25
26  convertable = (Float, int, long, rational.Rational)
27
28  def __init__(self, value):
29  """
30  value will be wrapped in Float.
31  """
32  ring.FieldElement.__init__(self)
33  if isinstance(value, rational.Rational):
34  self.data = value.toFloat()
35  else:
36  self.data = Float(value)
37
39  if isinstance(other, Real):
40  result = self.data + other.data
41  elif isinstance(other, self.convertable):
42  result = self.data + other
43  else:
44  return NotImplemented
45  return self.__class__(result)
46
48  if isinstance(other, self.convertable):
49  result = other + self.data
50  else:
51  return NotImplemented
52  return self.__class__(result)
53
54  def __sub__(self, other):
55  if isinstance(other, Real):
56  result = self.data - other.data
57  elif isinstance(other, self.convertable):
58  result = self.data - other
59  else:
60  return NotImplemented
61  return self.__class__(result)
62
63  def __rsub__(self, other):
64  if isinstance(other, self.convertable):
65  result = other - self.data
66  else:
67  return NotImplemented
68  return self.__class__(result)
69
70  def __mul__(self, other):
71  if isinstance(other, Real):
72  result = self.data * other.data
73  elif isinstance(other, self.convertable):
74  result = self.data * other
75  else:
76  return NotImplemented
77  return self.__class__(result)
78
79  def __rmul__(self, other):
80  if isinstance(other, self.convertable):
81  result = other * self.data
82  else:
83  return NotImplemented
84  return self.__class__(result)
85
86  def __truediv__(self, other):
87  if isinstance(other, Real):
88  result = self.data / other.data
89  elif isinstance(other, self.convertable):
90  result = self.data / other
91  else:
92  return NotImplemented
93  return self.__class__(result)
94
95  __div__ = __truediv__
96
97  def __rtruediv__(self, other):
98  if isinstance(other, self.convertable):
99  result = other / self.data
100  else:
101  return NotImplemented
102  return self.__class__(result)
103
104  __rdiv__ = __rtruediv__
105
106  def __pow__(self, other):
107  if isinstance(other, Real):
108  result = math.pow(self.data, other.data)
109  elif isinstance(other, self.convertable):
110  result = math.pow(self.data, other)
111  return result
112
113  def __eq__(self, other):
114  if isinstance(other, Real):
115  return self.data == other.data
116  elif isinstance(other, self.convertable):
117  return self.data == other
118  else:
119  return NotImplemented
120
121  def __hash__(self):
122  return hash(self.data)
123
124  def getRing(self):
125  """
126  Return the real field instance.
127  """
128  return theRealField
129
130
132  """
133  RealField is a class of the field of real numbers.
134  The class has the single instance 'theRealField'.
135  """
136
137  def __init__(self):
138  ring.Field.__init__(self)
139  self._one = Real(1)
140  self._zero = Real(0)
141
142  def __str__(self):
143  return "R"
144
145  def __repr__(self):
146  return "%s()" % (self.__class__.__name__, )
147
148  def __contains__(self, element):
149  if isinstance(element, (int, long, float, Float, Real, rational.Rational)):
150  return True
151  else:
152  try:
153  if check_real_or_complex(element):
154  return True
155  except TypeError:
156  if hasattr(element, 'conjugate'):
157  return element == element.conjugate()
158  pass
159  if hasattr(element, 'getRing') and element.getRing().issubring(self):
160  return True
161  return False
162
163  def __eq__(self, other):
164  return isinstance(other, self.__class__)
165
166  def __ne__(self, other):
167  return not self.__eq__(other)
168
169  def __hash__(self):
170  return 2
171
172  # property one
173  def _getOne(self):
174  "getter for one"
175  return self._one
176
177  one = property(_getOne, None, None, "multiplicative unit.")
178
179  # property zero
180  def _getZero(self):
181  "getter for zero"
182  return self._zero
183
184  zero = property(_getZero, None, None, "additive unit.")
185
186  def issubring(self, aRing):
187  if isinstance(aRing, RealField):
188  return True
189  elif self.issuperring(aRing):
190  return False
191  return aRing.issuperring(self)
192
193  def issuperring(self, aRing):
194  if isinstance(aRing, RealField):
195  return True
196  elif rational.theRationalField.issuperring(aRing):
197  return True
198  return aRing.issubring(self)
199
200  def createElement(self, seed):
201  return Float(seed)
202
203  def getCharacteristic(self):
204  """
205  The characteristic of the real field is zero.
206  """
207  return 0
208
209
210 def log1piter(xx):
211  " iterator for log(1+x)."
212  d = 1
213  positive = True
214  t = rational.Rational(xx)
215  yield t
216  while True:
217  d += 1
218  positive = not positive
219  t *= xx
220  if positive:
221  yield (t / d)
222  else:
223  yield (-t / d)
224
225 def floor(x):
226  """
227  floor(x) returns the integer; if x is an integer then x itself,
228  otherwise the biggest integer less than x.
229  """
230  rx = rational.Rational(x)
231  if rx.denominator == 1:
232  return rational.Integer(rx.numerator)
233  return rx.numerator // rx.denominator
234
235 def ceil(x):
236  """
237  ceil(x) returns the integer; if x is an integer then x itself,
238  otherwise the smallest integer greater than x.
239  """
240  rx = rational.Rational(x)
241  if rx.denominator == 1:
242  return rational.Integer(rx.numerator)
243  return rx.numerator // rx.denominator + 1
244
245 def tranc(x):
246  """
247  tranc(x) returns the integer; if x is an integer then x itself,
248  otherwise the nearest integer to x. If x has the fraction part
249  1/2, then bigger one will be chosen.
250  """
251  rx = rational.Rational(x)
252  if rx.denominator == 1:
253  return rational.Integer(rx.numerator)
254  return floor(x + rational.Rational(1, 2))
255
256 def fabs(x):
257  """
258  returns absolute value of x.
259  """
260  return abs(rational.Rational(x))
261
262 def fmod(x, y):
263  """
264  returns x - n * y, where n is the quotient of x / y, rounded
265  towards zero to an integer.
266  """
267  fquot = rational.Rational(x) / y
268  if fquot < 0:
269  n = -floor(-fquot)
270  else:
271  n = floor(fquot)
272  return x - n * y
273
274 def frexp(x):
275  """
276  Return a tuple (m, e) where x = m * 2 ** e, 1/2 <= abs(m) < 1 and
277  e is an integer.
278  This function is provided as the counter-part of math.frexp, but it
279  might not be useful.
280  """
281  if x == 0:
282  return (rational.Rational(0), 0)
283  m = rational.Rational(x)
284  e = 0
285  if x > 0:
286  while m >= 1:
287  m /= 2
288  e += 1
289  while m < rational.Rational(1, 2):
290  m *= 2
291  e -= 1
292  else:
293  while m <= -1:
294  m /= 2
295  e += 1
296  while m > rational.Rational(-1, 2):
297  m *= 2
298  e -= 1
299  return (m, e)
300
301 def ldexp(x, i):
302  """
303  returns x * 2 ** i.
304  """
305  return x * 2 ** i
306
307 def EulerTransform(iterator):
308  """
309  Return an iterator which yields terms of Euler transform of the
310  given iterator.
311  """
312  stock = []
313  b = rational.Rational(1, 2)
314  l = -1
315  for term in iterator:
316  stock.append(term)
317  for i in xrange(l, -1, -1):
318  stock[i] += stock[i+1]
319  yield b * stock[0]
320  b /= 2
321  l += 1
322
323 # constants
324 theRealField = RealField()
nzmath.ring
Definition: ring.py:1
nzmath.real.RealField._one
_one
Definition: real.py:139
nzmath.real.RealField.__contains__
def __contains__(self, element)
Definition: real.py:148
nzmath.real.Real.__hash__
def __hash__(self)
Definition: real.py:121
nzmath.real.Real.__eq__
def __eq__(self, other)
Definition: real.py:113
nzmath.real.Real.__rsub__
def __rsub__(self, other)
Definition: real.py:63
nzmath.ring.Field
Definition: ring.py:190
nzmath.real.Real.__init__
def __init__(self, value)
Definition: real.py:28
nzmath.real.RealField.__init__
def __init__(self)
Definition: real.py:137
Definition: real.py:38
nzmath.real.Real.__rtruediv__
def __rtruediv__(self, other)
Definition: real.py:97
nzmath.real.tranc
def tranc(x)
Definition: real.py:245
nzmath.rational
Definition: rational.py:1
nzmath.real.frexp
def frexp(x)
Definition: real.py:274
nzmath.real.Real.convertable
tuple convertable
Definition: real.py:26
nzmath.rational.Rational
Definition: rational.py:10
nzmath.real.fmod
def fmod(x, y)
Definition: real.py:262
nzmath.real.Real.getRing
def getRing(self)
Definition: real.py:124
nzmath.real.RealField._zero
_zero
Definition: real.py:140
nzmath.real.RealField.__eq__
def __eq__(self, other)
Definition: real.py:163
nzmath.real.Real.__pow__
def __pow__(self, other)
Definition: real.py:106
nzmath.real.RealField.getCharacteristic
def getCharacteristic(self)
Definition: real.py:203
nzmath.real.floor
def floor(x)
Definition: real.py:225
nzmath.real.EulerTransform
def EulerTransform(iterator)
Definition: real.py:307
nzmath.real.Real
Definition: real.py:20
nzmath.real.log1piter
def log1piter(xx)
Definition: real.py:210
nzmath.real.RealField.__str__
def __str__(self)
Definition: real.py:142
nzmath.real.Real.data
data
Definition: real.py:34
nzmath.real.RealField.__ne__
def __ne__(self, other)
Definition: real.py:166
nzmath.arith1
Definition: arith1.py:1
nzmath.real.Real.__truediv__
def __truediv__(self, other)
Definition: real.py:86
nzmath.plugins
Definition: plugins.py:1
nzmath.real.RealField.issubring
def issubring(self, aRing)
Definition: real.py:186
nzmath.real.RealField
Definition: real.py:131
nzmath.real.Real.__sub__
def __sub__(self, other)
Definition: real.py:54
nzmath.rational.Integer
Definition: rational.py:639
nzmath.real.RealField.createElement
def createElement(self, seed)
Definition: real.py:200
Definition: real.py:47
nzmath.real.RealField._getOne
def _getOne(self)
Definition: real.py:173
nzmath.real.RealField.__hash__
def __hash__(self)
Definition: real.py:169
nzmath.real.RealField._getZero
def _getZero(self)
Definition: real.py:180
nzmath.real.RealField.issuperring
def issuperring(self, aRing)
Definition: real.py:193
nzmath.real.fabs
def fabs(x)
Definition: real.py:256
nzmath.ring.FieldElement
Definition: ring.py:343
nzmath.real.ldexp
def ldexp(x, i)
Definition: real.py:301
nzmath.real.Real.__mul__
def __mul__(self, other)
Definition: real.py:70
nzmath.real.RealField.__repr__
def __repr__(self)
Definition: real.py:145
nzmath.real.Real.__rmul__
def __rmul__(self, other)
Definition: real.py:79
nzmath.real.ceil
def ceil(x)
Definition: real.py:235