def __init__(self): r""" TESTS:: sage: from sage.rings.valuation.value_group import DiscreteValuationCodomain sage: isinstance(QQ.valuation(2).codomain(), DiscreteValuationCodomain) True """ from sage.sets.finite_enumerated_set import FiniteEnumeratedSet from sage.categories.additive_monoids import AdditiveMonoids UniqueRepresentation.__init__(self) Parent.__init__(self, facade=(QQ, FiniteEnumeratedSet([infinity, -infinity])), category=AdditiveMonoids())
def __init__(self): r""" TESTS:: sage: sys.path.append(os.getcwd()); from mac_lane import * # optional: standalone sage: isinstance(pAdicValuation(QQ, 2).codomain(), DiscreteValuationCodomain) True """ from sage.sets.finite_enumerated_set import FiniteEnumeratedSet from sage.categories.additive_monoids import AdditiveMonoids UniqueRepresentation.__init__(self) Parent.__init__(self, facade=(QQ, FiniteEnumeratedSet([infinity, -infinity])), category=AdditiveMonoids())
def __init__(self, generator): r""" TESTS:: sage: sys.path.append(os.getcwd()); from mac_lane import * # optional: standalone sage: isinstance(DiscreteValueGroup(0), DiscreteValueGroup) True """ from sage.categories.modules import Modules self._generator = generator # We can not set the facade to DiscreteValuationCodomain since there # are some issues with iterated facades currently UniqueRepresentation.__init__(self) Parent.__init__(self, facade=QQ, category=Modules(ZZ))
def __init__(self, generator): r""" TESTS:: sage: from sage.rings.valuation.value_group import DiscreteValueGroup sage: isinstance(DiscreteValueGroup(0), DiscreteValueGroup) True """ from sage.categories.modules import Modules self._generator = generator # We can not set the facade to DiscreteValuationCodomain since there # are some issues with iterated facades currently UniqueRepresentation.__init__(self) Parent.__init__(self, facade=QQ, category=Modules(ZZ))
def __init__(self, parent, base): r""" TESTS:: sage: sys.path.append(os.getcwd()); from completion import * sage: v = pAdicValuation(QQ, 2) sage: K = Completion(QQ, v) sage: R.<x> = K[] sage: L = K.extension(x^2 + x + 1) sage: f = L.vector_space()[2] sage: isinstance(f, CompletionToVectorSpace) True """ Morphism.__init__(self, parent) UniqueRepresentation.__init__(self) self._base = base
def __init__(self, parent, base): r""" TESTS:: sage: from henselization import * sage: K = QQ.henselization(2) sage: R.<x> = K[] sage: L = K.extension(x^2 + x + 1) sage: f = L.module()[2] sage: from sage.rings.padics.henselization.maps import HenselizationToVectorSpace sage: isinstance(f, HenselizationToVectorSpace) True """ Morphism.__init__(self, parent) UniqueRepresentation.__init__(self) self._base = base
def __classcall__(cls, base_ring=ZZ): """ Set the default value for the base ring. EXAMPLES:: sage: FormalSums(ZZ) == FormalSums() # indirect test True """ return UniqueRepresentation.__classcall__(cls, base_ring)
def __classcall__(cls, base_ring = ZZ): """ Set the default value for the base ring. EXAMPLES:: sage: FormalSums(ZZ) == FormalSums() # indirect test True """ return UniqueRepresentation.__classcall__(cls, base_ring)
def __classcall__(cls, scheme, base_ring=ZZ): """ Set the default value for the base ring. EXAMPLES:: sage: from sage.schemes.generic.divisor_group import DivisorGroup_generic sage: DivisorGroup_generic(Spec(ZZ),ZZ) == DivisorGroup_generic(Spec(ZZ)) # indirect test True """ # Must not call super().__classcall__()! return UniqueRepresentation.__classcall__(cls, scheme, base_ring)
def __classcall__(cls, *args): """ Normalize the input. INPUT: See :class:`RealSet`. OUTPUT: A :class:`RealSet`. EXAMPLES:: sage: R = RealSet(RealSet.open_closed(0,1), RealSet.closed_open(2,3)); R (0, 1] + [2, 3) TESTS:: sage: TestSuite(R).run() """ if len(args) == 1 and isinstance(args[0], RealSet): return args[0] # common optimization intervals = [] if len(args) == 2: # allow RealSet(0,1) interval constructor try: lower, upper = args lower.n() upper.n() args = (RealSet._prep(lower, upper), ) except (AttributeError, ValueError, TypeError): pass for arg in args: if isinstance(arg, tuple): lower, upper = RealSet._prep(*arg) intervals.append(InternalRealInterval(lower, False, upper, False)) elif isinstance(arg, list): lower, upper = RealSet._prep(*arg) intervals.append(InternalRealInterval(lower, True, upper, True)) elif isinstance(arg, InternalRealInterval): intervals.append(arg) elif isinstance(arg, RealSet): intervals.extend(arg._intervals) else: raise ValueError(str(arg) + ' does not determine real interval') intervals = RealSet.normalize(intervals) return UniqueRepresentation.__classcall__(cls, *intervals)
def __classcall__(cls, *args, **kwds): r""" TESTS:: sage: L = LaurentSeriesRing(QQ, 'q') sage: L is LaurentSeriesRing(QQ, name='q') True sage: loads(dumps(L)) is L True sage: L.variable_names() ('q',) sage: L.variable_name() 'q' """ from .power_series_ring import PowerSeriesRing, is_PowerSeriesRing if not kwds and len(args) == 1 and is_PowerSeriesRing(args[0]): power_series = args[0] else: power_series = PowerSeriesRing(*args, **kwds) return UniqueRepresentation.__classcall__(cls, power_series)
def __classcall__(cls, *args): """ Normalize the input. INPUT: See :class:`RealSet`. OUTPUT: A :class:`RealSet`. EXAMPLES:: sage: R = RealSet(RealSet.open_closed(0,1), RealSet.closed_open(2,3)); R (0, 1] + [2, 3) :: sage: RealSet(x != 0) (-oo, 0) + (0, +oo) sage: RealSet(x == pi) {pi} sage: RealSet(x < 1/2) (-oo, 1/2) sage: RealSet(1/2 < x) (1/2, +oo) sage: RealSet(1.5 <= x) [1.50000000000000, +oo) sage: RealSet(x >= -1) [-1, +oo) sage: RealSet(x > oo) {} sage: RealSet(x >= oo) {} sage: RealSet(x <= -oo) {} sage: RealSet(x < oo) (-oo, +oo) sage: RealSet(x > -oo) (-oo, +oo) sage: RealSet(x != oo) (-oo, +oo) sage: RealSet(x <= oo) Traceback (most recent call last): ... ValueError: interval cannot be closed at +oo sage: RealSet(x == oo) Traceback (most recent call last): ... ValueError: interval cannot be closed at +oo sage: RealSet(x >= -oo) Traceback (most recent call last): ... ValueError: interval cannot be closed at -oo TESTS:: sage: TestSuite(R).run() """ from sage.symbolic.expression import Expression if len(args) == 1 and isinstance(args[0], RealSet): return args[0] # common optimization intervals = [] if len(args) == 2: # allow RealSet(0,1) interval constructor try: lower, upper = args lower.n() upper.n() args = (RealSet._prep(lower, upper), ) except (AttributeError, ValueError, TypeError): pass for arg in args: if isinstance(arg, tuple): lower, upper = RealSet._prep(*arg) intervals.append(InternalRealInterval(lower, False, upper, False)) elif isinstance(arg, list): lower, upper = RealSet._prep(*arg) intervals.append(InternalRealInterval(lower, True, upper, True)) elif isinstance(arg, InternalRealInterval): intervals.append(arg) elif isinstance(arg, RealSet): intervals.extend(arg._intervals) elif isinstance(arg, Expression) and arg.is_relational(): from operator import eq, ne, lt, gt, le, ge def rel_to_interval(op, val): """ Internal helper function. """ oo = infinity try: val = val.pyobject() except AttributeError: pass val = RLF(val) if op == eq: return [InternalRealInterval(val, True, val, True)] elif op == ne: return [InternalRealInterval(-oo, False, val, False), InternalRealInterval(val, False, oo, False)] elif op == gt: return [InternalRealInterval(val, False, oo, False)] elif op == ge: return [InternalRealInterval(val, True, oo, False)] elif op == lt: return [InternalRealInterval(-oo, False, val, False)] else: return [InternalRealInterval(-oo, False, val, True)] if (arg.lhs().is_symbol() and (arg.rhs().is_numeric() or arg.rhs().is_constant()) and arg.rhs().is_real()): intervals.extend(rel_to_interval(arg.operator(), arg.rhs())) elif (arg.rhs().is_symbol() and (arg.lhs().is_numeric() or arg.lhs().is_constant()) and arg.lhs().is_real()): op = arg.operator() if op == lt: op = gt elif op == gt: op = lt elif op == le: op = ge elif op == ge: op = le intervals.extend(rel_to_interval(op, arg.lhs())) else: raise ValueError(str(arg) + ' does not determine real interval') else: raise ValueError(str(arg) + ' does not determine real interval') intervals = RealSet.normalize(intervals) return UniqueRepresentation.__classcall__(cls, *intervals)
def __classcall__(cls, *args): """ Normalize the input. INPUT: See :class:`RealSet`. OUTPUT: A :class:`RealSet`. EXAMPLES:: sage: R = RealSet(RealSet.open_closed(0,1), RealSet.closed_open(2,3)); R (0, 1] + [2, 3) :: sage: RealSet(x != 0) (-oo, 0) + (0, +oo) sage: RealSet(x == pi) {pi} sage: RealSet(x < 1/2) (-oo, 1/2) sage: RealSet(1/2 < x) (1/2, +oo) sage: RealSet(1.5 <= x) [1.50000000000000, +oo) sage: RealSet(x >= -1) [-1, +oo) sage: RealSet(x > oo) {} sage: RealSet(x >= oo) {} sage: RealSet(x <= -oo) {} sage: RealSet(x < oo) (-oo, +oo) sage: RealSet(x > -oo) (-oo, +oo) sage: RealSet(x != oo) (-oo, +oo) sage: RealSet(x <= oo) Traceback (most recent call last): ... ValueError: interval cannot be closed at +oo sage: RealSet(x == oo) Traceback (most recent call last): ... ValueError: interval cannot be closed at +oo sage: RealSet(x >= -oo) Traceback (most recent call last): ... ValueError: interval cannot be closed at -oo TESTS:: sage: TestSuite(R).run() """ from sage.symbolic.expression import Expression if len(args) == 1 and isinstance(args[0], RealSet): return args[0] # common optimization intervals = [] if len(args) == 2: # allow RealSet(0,1) interval constructor try: lower, upper = args lower.n() upper.n() args = (RealSet._prep(lower, upper), ) except (AttributeError, ValueError, TypeError): pass for arg in args: if isinstance(arg, tuple): lower, upper = RealSet._prep(*arg) intervals.append( InternalRealInterval(lower, False, upper, False)) elif isinstance(arg, list): lower, upper = RealSet._prep(*arg) intervals.append(InternalRealInterval(lower, True, upper, True)) elif isinstance(arg, InternalRealInterval): intervals.append(arg) elif isinstance(arg, RealSet): intervals.extend(arg._intervals) elif isinstance(arg, Expression) and arg.is_relational(): from operator import eq, ne, lt, gt, le, ge def rel_to_interval(op, val): """ Internal helper function. """ oo = infinity try: val = val.pyobject() except AttributeError: pass val = RLF(val) if op == eq: return [InternalRealInterval(val, True, val, True)] elif op == ne: return [ InternalRealInterval(-oo, False, val, False), InternalRealInterval(val, False, oo, False) ] elif op == gt: return [InternalRealInterval(val, False, oo, False)] elif op == ge: return [InternalRealInterval(val, True, oo, False)] elif op == lt: return [InternalRealInterval(-oo, False, val, False)] else: return [InternalRealInterval(-oo, False, val, True)] if (arg.lhs().is_symbol() and (arg.rhs().is_numeric() or arg.rhs().is_constant()) and arg.rhs().is_real()): intervals.extend(rel_to_interval(arg.operator(), arg.rhs())) elif (arg.rhs().is_symbol() and (arg.lhs().is_numeric() or arg.lhs().is_constant()) and arg.lhs().is_real()): op = arg.operator() if op == lt: op = gt elif op == gt: op = lt elif op == le: op = ge elif op == ge: op = le intervals.extend(rel_to_interval(op, arg.lhs())) else: raise ValueError( str(arg) + ' does not determine real interval') else: raise ValueError( str(arg) + ' does not determine real interval') intervals = RealSet.normalize(intervals) return UniqueRepresentation.__classcall__(cls, *intervals)