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: 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, 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, 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):
"""
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, **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)
