File size: 5,945 Bytes
ceb378e |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 |
"""Implementation of :class:`FractionField` class. """
from sympy.polys.domains.compositedomain import CompositeDomain
from sympy.polys.domains.field import Field
from sympy.polys.polyerrors import CoercionFailed, GeneratorsError
from sympy.utilities import public
@public
class FractionField(Field, CompositeDomain):
"""A class for representing multivariate rational function fields. """
is_FractionField = is_Frac = True
has_assoc_Ring = True
has_assoc_Field = True
def __init__(self, domain_or_field, symbols=None, order=None):
from sympy.polys.fields import FracField
if isinstance(domain_or_field, FracField) and symbols is None and order is None:
field = domain_or_field
else:
field = FracField(symbols, domain_or_field, order)
self.field = field
self.dtype = field.dtype
self.gens = field.gens
self.ngens = field.ngens
self.symbols = field.symbols
self.domain = field.domain
# TODO: remove this
self.dom = self.domain
def new(self, element):
return self.field.field_new(element)
@property
def zero(self):
return self.field.zero
@property
def one(self):
return self.field.one
@property
def order(self):
return self.field.order
@property
def is_Exact(self):
return self.domain.is_Exact
def get_exact(self):
return FractionField(self.domain.get_exact(), self.symbols)
def __str__(self):
return str(self.domain) + '(' + ','.join(map(str, self.symbols)) + ')'
def __hash__(self):
return hash((self.__class__.__name__, self.dtype.field, self.domain, self.symbols))
def __eq__(self, other):
"""Returns ``True`` if two domains are equivalent. """
return isinstance(other, FractionField) and \
(self.dtype.field, self.domain, self.symbols) ==\
(other.dtype.field, other.domain, other.symbols)
def to_sympy(self, a):
"""Convert ``a`` to a SymPy object. """
return a.as_expr()
def from_sympy(self, a):
"""Convert SymPy's expression to ``dtype``. """
return self.field.from_expr(a)
def from_ZZ(K1, a, K0):
"""Convert a Python ``int`` object to ``dtype``. """
return K1(K1.domain.convert(a, K0))
def from_ZZ_python(K1, a, K0):
"""Convert a Python ``int`` object to ``dtype``. """
return K1(K1.domain.convert(a, K0))
def from_QQ(K1, a, K0):
"""Convert a Python ``Fraction`` object to ``dtype``. """
dom = K1.domain
conv = dom.convert_from
if dom.is_ZZ:
return K1(conv(K0.numer(a), K0)) / K1(conv(K0.denom(a), K0))
else:
return K1(conv(a, K0))
def from_QQ_python(K1, a, K0):
"""Convert a Python ``Fraction`` object to ``dtype``. """
return K1(K1.domain.convert(a, K0))
def from_ZZ_gmpy(K1, a, K0):
"""Convert a GMPY ``mpz`` object to ``dtype``. """
return K1(K1.domain.convert(a, K0))
def from_QQ_gmpy(K1, a, K0):
"""Convert a GMPY ``mpq`` object to ``dtype``. """
return K1(K1.domain.convert(a, K0))
def from_GaussianRationalField(K1, a, K0):
"""Convert a ``GaussianRational`` object to ``dtype``. """
return K1(K1.domain.convert(a, K0))
def from_GaussianIntegerRing(K1, a, K0):
"""Convert a ``GaussianInteger`` object to ``dtype``. """
return K1(K1.domain.convert(a, K0))
def from_RealField(K1, a, K0):
"""Convert a mpmath ``mpf`` object to ``dtype``. """
return K1(K1.domain.convert(a, K0))
def from_ComplexField(K1, a, K0):
"""Convert a mpmath ``mpf`` object to ``dtype``. """
return K1(K1.domain.convert(a, K0))
def from_AlgebraicField(K1, a, K0):
"""Convert an algebraic number to ``dtype``. """
if K1.domain != K0:
a = K1.domain.convert_from(a, K0)
if a is not None:
return K1.new(a)
def from_PolynomialRing(K1, a, K0):
"""Convert a polynomial to ``dtype``. """
if a.is_ground:
return K1.convert_from(a.coeff(1), K0.domain)
try:
return K1.new(a.set_ring(K1.field.ring))
except (CoercionFailed, GeneratorsError):
# XXX: We get here if K1=ZZ(x,y) and K0=QQ[x,y]
# and the poly a in K0 has non-integer coefficients.
# It seems that K1.new can handle this but K1.new doesn't work
# when K0.domain is an algebraic field...
try:
return K1.new(a)
except (CoercionFailed, GeneratorsError):
return None
def from_FractionField(K1, a, K0):
"""Convert a rational function to ``dtype``. """
try:
return a.set_field(K1.field)
except (CoercionFailed, GeneratorsError):
return None
def get_ring(self):
"""Returns a field associated with ``self``. """
return self.field.to_ring().to_domain()
def is_positive(self, a):
"""Returns True if ``LC(a)`` is positive. """
return self.domain.is_positive(a.numer.LC)
def is_negative(self, a):
"""Returns True if ``LC(a)`` is negative. """
return self.domain.is_negative(a.numer.LC)
def is_nonpositive(self, a):
"""Returns True if ``LC(a)`` is non-positive. """
return self.domain.is_nonpositive(a.numer.LC)
def is_nonnegative(self, a):
"""Returns True if ``LC(a)`` is non-negative. """
return self.domain.is_nonnegative(a.numer.LC)
def numer(self, a):
"""Returns numerator of ``a``. """
return a.numer
def denom(self, a):
"""Returns denominator of ``a``. """
return a.denom
def factorial(self, a):
"""Returns factorial of ``a``. """
return self.dtype(self.domain.factorial(a))
|