Coverage for /usr/lib/python3/dist-packages/sympy/polys/domains/realfield.py: 63%

1"""Implementation of :class:`RealField` class. """ 

2 

3 

4from sympy.core.numbers import Float 

5from sympy.polys.domains.field import Field 

6from sympy.polys.domains.simpledomain import SimpleDomain 

7from sympy.polys.domains.characteristiczero import CharacteristicZero 

8from sympy.polys.domains.mpelements import MPContext 

9from sympy.polys.polyerrors import CoercionFailed 

10from sympy.utilities import public 

11 

12@public 

13class RealField(Field, CharacteristicZero, SimpleDomain): 

14 """Real numbers up to the given precision. """ 

15 

16 rep = 'RR' 

17 

18 is_RealField = is_RR = True 

19 

20 is_Exact = False 

21 is_Numerical = True 

22 is_PID = False 

23 

24 has_assoc_Ring = False 

25 has_assoc_Field = True 

26 

27 _default_precision = 53 

28 

29 @property 

30 def has_default_precision(self): 

31 return self.precision == self._default_precision 

32 

33 @property 

34 def precision(self): 

35 return self._context.prec 

36 

37 @property 

38 def dps(self): 

39 return self._context.dps 

40 

41 @property 

42 def tolerance(self): 

43 return self._context.tolerance 

44 

45 def __init__(self, prec=_default_precision, dps=None, tol=None): 

46 context = MPContext(prec, dps, tol, True) 

47 context._parent = self 

48 self._context = context 

49 

50 self.dtype = context.mpf 

51 self.zero = self.dtype(0) 

52 self.one = self.dtype(1) 

53 

54 def __eq__(self, other): 

55 return (isinstance(other, RealField) 

56 and self.precision == other.precision 

57 and self.tolerance == other.tolerance) 

58 

59 def __hash__(self): 

60 return hash((self.__class__.__name__, self.dtype, self.precision, self.tolerance)) 

61 

62 def to_sympy(self, element): 

63 """Convert ``element`` to SymPy number. """ 

64 return Float(element, self.dps) 

65 

66 def from_sympy(self, expr): 

67 """Convert SymPy's number to ``dtype``. """ 

68 number = expr.evalf(n=self.dps) 

69 

70 if number.is_Number: 

71 return self.dtype(number) 

72 else: 

73 raise CoercionFailed("expected real number, got %s" % expr) 

74 

75 def from_ZZ(self, element, base): 

76 return self.dtype(element) 

77 

78 def from_ZZ_python(self, element, base): 

79 return self.dtype(element) 

80 

81 def from_QQ(self, element, base): 

82 return self.dtype(element.numerator) / element.denominator 

83 

84 def from_QQ_python(self, element, base): 

85 return self.dtype(element.numerator) / element.denominator 

86 

87 def from_ZZ_gmpy(self, element, base): 

88 return self.dtype(int(element)) 

89 

90 def from_QQ_gmpy(self, element, base): 

91 return self.dtype(int(element.numerator)) / int(element.denominator) 

92 

93 def from_AlgebraicField(self, element, base): 

94 return self.from_sympy(base.to_sympy(element).evalf(self.dps)) 

95 

96 def from_RealField(self, element, base): 

97 if self == base: 

98 return element 

99 else: 

100 return self.dtype(element) 

101 

102 def from_ComplexField(self, element, base): 

103 if not element.imag: 

104 return self.dtype(element.real) 

105 

106 def to_rational(self, element, limit=True): 

107 """Convert a real number to rational number. """ 

108 return self._context.to_rational(element, limit) 

109 

110 def get_ring(self): 

111 """Returns a ring associated with ``self``. """ 

112 return self 

113 

114 def get_exact(self): 

115 """Returns an exact domain associated with ``self``. """ 

116 from sympy.polys.domains import QQ 

117 return QQ 

118 

119 def gcd(self, a, b): 

120 """Returns GCD of ``a`` and ``b``. """ 

121 return self.one 

122 

123 def lcm(self, a, b): 

124 """Returns LCM of ``a`` and ``b``. """ 

125 return a*b 

126 

127 def almosteq(self, a, b, tolerance=None): 

128 """Check if ``a`` and ``b`` are almost equal. """ 

129 return self._context.almosteq(a, b, tolerance) 

130 

131 

132RR = RealField()