| """ |
| |
| Module for the DomainScalar class. |
| |
| A DomainScalar represents an element which is in a particular |
| Domain. The idea is that the DomainScalar class provides the |
| convenience routines for unifying elements with different domains. |
| |
| It assists in Scalar Multiplication and getitem for DomainMatrix. |
| |
| """ |
| from ..constructor import construct_domain |
|
|
| from sympy.polys.domains import Domain, ZZ |
|
|
|
|
| class DomainScalar: |
| r""" |
| docstring |
| """ |
|
|
| def __new__(cls, element, domain): |
| if not isinstance(domain, Domain): |
| raise TypeError("domain should be of type Domain") |
| if not domain.of_type(element): |
| raise TypeError("element %s should be in domain %s" % (element, domain)) |
| return cls.new(element, domain) |
|
|
| @classmethod |
| def new(cls, element, domain): |
| obj = super().__new__(cls) |
| obj.element = element |
| obj.domain = domain |
| return obj |
|
|
| def __repr__(self): |
| return repr(self.element) |
|
|
| @classmethod |
| def from_sympy(cls, expr): |
| [domain, [element]] = construct_domain([expr]) |
| return cls.new(element, domain) |
|
|
| def to_sympy(self): |
| return self.domain.to_sympy(self.element) |
|
|
| def to_domain(self, domain): |
| element = domain.convert_from(self.element, self.domain) |
| return self.new(element, domain) |
|
|
| def convert_to(self, domain): |
| return self.to_domain(domain) |
|
|
| def unify(self, other): |
| domain = self.domain.unify(other.domain) |
| return self.to_domain(domain), other.to_domain(domain) |
|
|
| def __bool__(self): |
| return bool(self.element) |
|
|
| def __add__(self, other): |
| if not isinstance(other, DomainScalar): |
| return NotImplemented |
| self, other = self.unify(other) |
| return self.new(self.element + other.element, self.domain) |
|
|
| def __sub__(self, other): |
| if not isinstance(other, DomainScalar): |
| return NotImplemented |
| self, other = self.unify(other) |
| return self.new(self.element - other.element, self.domain) |
|
|
| def __mul__(self, other): |
| if not isinstance(other, DomainScalar): |
| if isinstance(other, int): |
| other = DomainScalar(ZZ(other), ZZ) |
| else: |
| return NotImplemented |
|
|
| self, other = self.unify(other) |
| return self.new(self.element * other.element, self.domain) |
|
|
| def __floordiv__(self, other): |
| if not isinstance(other, DomainScalar): |
| return NotImplemented |
| self, other = self.unify(other) |
| return self.new(self.domain.quo(self.element, other.element), self.domain) |
|
|
| def __mod__(self, other): |
| if not isinstance(other, DomainScalar): |
| return NotImplemented |
| self, other = self.unify(other) |
| return self.new(self.domain.rem(self.element, other.element), self.domain) |
|
|
| def __divmod__(self, other): |
| if not isinstance(other, DomainScalar): |
| return NotImplemented |
| self, other = self.unify(other) |
| q, r = self.domain.div(self.element, other.element) |
| return (self.new(q, self.domain), self.new(r, self.domain)) |
|
|
| def __pow__(self, n): |
| if not isinstance(n, int): |
| return NotImplemented |
| return self.new(self.element**n, self.domain) |
|
|
| def __pos__(self): |
| return self.new(+self.element, self.domain) |
|
|
| def __neg__(self): |
| return self.new(-self.element, self.domain) |
|
|
| def __eq__(self, other): |
| if not isinstance(other, DomainScalar): |
| return NotImplemented |
| return self.element == other.element and self.domain == other.domain |
|
|
| def is_zero(self): |
| return self.element == self.domain.zero |
|
|
| def is_one(self): |
| return self.element == self.domain.one |
|
|
