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

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

2 

3 

4from sympy.core.numbers import Float, I 

5from sympy.polys.domains.characteristiczero import CharacteristicZero 

6from sympy.polys.domains.field import Field 

7from sympy.polys.domains.mpelements import MPContext 

8from sympy.polys.domains.simpledomain import SimpleDomain 

9from sympy.polys.polyerrors import DomainError, CoercionFailed 

10from sympy.utilities import public 

11 

12@public 

13class ComplexField(Field, CharacteristicZero, SimpleDomain): 

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

15 

16 rep = 'CC' 

17 

18 is_ComplexField = is_CC = True 

19 

20 is_Exact = False 

21 is_Numerical = True 

22 

23 has_assoc_Ring = False 

24 has_assoc_Field = True 

25 

26 _default_precision = 53 

27 

28 @property 

29 def has_default_precision(self): 

30 return self.precision == self._default_precision 

31 

32 @property 

33 def precision(self): 

34 return self._context.prec 

35 

36 @property 

37 def dps(self): 

38 return self._context.dps 

39 

40 @property 

41 def tolerance(self): 

42 return self._context.tolerance 

43 

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

45 context = MPContext(prec, dps, tol, False) 

46 context._parent = self 

47 self._context = context 

48 

49 self.dtype = context.mpc 

50 self.zero = self.dtype(0) 

51 self.one = self.dtype(1) 

52 

53 def __eq__(self, other): 

54 return (isinstance(other, ComplexField) 

55 and self.precision == other.precision 

56 and self.tolerance == other.tolerance) 

57 

58 def __hash__(self): 

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

60 

61 def to_sympy(self, element): 

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

63 return Float(element.real, self.dps) + I*Float(element.imag, self.dps) 

64 

65 def from_sympy(self, expr): 

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

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

68 real, imag = number.as_real_imag() 

69 

70 if real.is_Number and imag.is_Number: 

71 return self.dtype(real, imag) 

72 else: 

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

74 

75 def from_ZZ(self, element, base): 

76 return self.dtype(element) 

77 

78 def from_QQ(self, element, base): 

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

80 

81 def from_ZZ_python(self, element, base): 

82 return self.dtype(element) 

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_GaussianIntegerRing(self, element, base): 

94 return self.dtype(int(element.x), int(element.y)) 

95 

96 def from_GaussianRationalField(self, element, base): 

97 x = element.x 

98 y = element.y 

99 return (self.dtype(int(x.numerator)) / int(x.denominator) + 

100 self.dtype(0, int(y.numerator)) / int(y.denominator)) 

101 

102 def from_AlgebraicField(self, element, base): 

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

104 

105 def from_RealField(self, element, base): 

106 return self.dtype(element) 

107 

108 def from_ComplexField(self, element, base): 

109 if self == base: 

110 return element 

111 else: 

112 return self.dtype(element) 

113 

114 def get_ring(self): 

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

116 raise DomainError("there is no ring associated with %s" % self) 

117 

118 def get_exact(self): 

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

120 raise DomainError("there is no exact domain associated with %s" % self) 

121 

122 def is_negative(self, element): 

123 """Returns ``False`` for any ``ComplexElement``. """ 

124 return False 

125 

126 def is_positive(self, element): 

127 """Returns ``False`` for any ``ComplexElement``. """ 

128 return False 

129 

130 def is_nonnegative(self, element): 

131 """Returns ``False`` for any ``ComplexElement``. """ 

132 return False 

133 

134 def is_nonpositive(self, element): 

135 """Returns ``False`` for any ``ComplexElement``. """ 

136 return False 

137 

138 def gcd(self, a, b): 

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

140 return self.one 

141 

142 def lcm(self, a, b): 

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

144 return a*b 

145 

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

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

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

149 

150 

151CC = ComplexField()