Subsets of the Real Line#
This module contains subsets of the real line that can be constructed as the union of a finite set of open and closed intervals.
EXAMPLES:
sage: RealSet(0,1)
(0, 1)
sage: RealSet((0,1), [2,3])
(0, 1) ∪ [2, 3]
sage: RealSet((1,3), (0,2))
(0, 3)
sage: RealSet(-oo, oo)
(-oo, +oo)
Brackets must be balanced in Python, so the naive notation for half-open intervals does not work:
sage: RealSet([0,1))
Traceback (most recent call last):
...
SyntaxError: ...
Instead, you can use the following construction functions:
sage: RealSet.open_closed(0,1)
(0, 1]
sage: RealSet.closed_open(0,1)
[0, 1)
sage: RealSet.point(1/2)
{1/2}
sage: RealSet.unbounded_below_open(0)
(-oo, 0)
sage: RealSet.unbounded_below_closed(0)
(-oo, 0]
sage: RealSet.unbounded_above_open(1)
(1, +oo)
sage: RealSet.unbounded_above_closed(1)
[1, +oo)
The lower and upper endpoints will be sorted if necessary:
sage: RealSet.interval(1, 0, lower_closed=True, upper_closed=False)
[0, 1)
Relations containing symbols and numeric values or constants:
sage: # needs sage.symbolic
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)
Note that multiple arguments are combined as union:
sage: RealSet(x >= 0, x < 1) # needs sage.symbolic
(-oo, +oo)
sage: RealSet(x >= 0, x > 1) # needs sage.symbolic
[0, +oo)
sage: RealSet(x >= 0, x > -1) # needs sage.symbolic
(-1, +oo)
AUTHORS:
Laurent Claessens (2010-12-10): Interval and ContinuousSet, posted to sage-devel at http://www.mail-archive.com/sage-support@googlegroups.com/msg21326.html.
Ares Ribo (2011-10-24): Extended the previous work defining the class RealSet.
Jordi Saludes (2011-12-10): Documentation and file reorganization.
Volker Braun (2013-06-22): Rewrite
Yueqi Li, Yuan Zhou (2022-07-31): Rewrite RealSet. Adapt faster operations by scan-line (merging) techniques from the code by Matthias Köppe et al., at https://github.com/mkoeppe/cutgeneratingfunctionology/blob/master/cutgeneratingfunctionology/igp/intervals.py
- class sage.sets.real_set.InternalRealInterval(lower, lower_closed, upper, upper_closed, check=True)#
Bases:
UniqueRepresentation
,Parent
A real interval.
You are not supposed to create
InternalRealInterval
objects yourself. Always useRealSet
instead.INPUT:
lower
– real or minus infinity; the lower bound of the interval.lower_closed
– boolean; whether the interval is closed at the lower boundupper
– real or (plus) infinity; the upper bound of the intervalupper_closed
– boolean; whether the interval is closed at the upper boundcheck
– boolean; whether to check the other arguments for validity
- boundary_points()#
Generate the boundary points of
self
EXAMPLES:
sage: list(RealSet.open_closed(-oo, 1)[0].boundary_points()) [1] sage: list(RealSet.open(1, 2)[0].boundary_points()) [1, 2]
- closure()#
Return the closure
OUTPUT:
The closure as a new
InternalRealInterval
EXAMPLES:
sage: RealSet.open(0,1)[0].closure() [0, 1] sage: RealSet.open(-oo,1)[0].closure() (-oo, 1] sage: RealSet.open(0, oo)[0].closure() [0, +oo)
- contains(x)#
Return whether \(x\) is contained in the interval
INPUT:
x
– a real number.
OUTPUT:
Boolean.
EXAMPLES:
sage: i = RealSet.open_closed(0,2)[0]; i (0, 2] sage: i.contains(0) False sage: i.contains(1) True sage: i.contains(2) True
- convex_hull(other)#
Return the convex hull of the two intervals
OUTPUT:
The convex hull as a new
InternalRealInterval
.EXAMPLES:
sage: I1 = RealSet.open(0, 1)[0]; I1 (0, 1) sage: I2 = RealSet.closed(1, 2)[0]; I2 [1, 2] sage: I1.convex_hull(I2) (0, 2] sage: I2.convex_hull(I1) (0, 2] sage: I1.convex_hull(I2.interior()) (0, 2) sage: I1.closure().convex_hull(I2.interior()) [0, 2) sage: I1.closure().convex_hull(I2) [0, 2] sage: I3 = RealSet.closed(1/2, 3/2)[0]; I3 [1/2, 3/2] sage: I1.convex_hull(I3) (0, 3/2]
- element_class#
alias of
LazyFieldElement
- interior()#
Return the interior
OUTPUT:
The interior as a new
InternalRealInterval
EXAMPLES:
sage: RealSet.closed(0, 1)[0].interior() (0, 1) sage: RealSet.open_closed(-oo, 1)[0].interior() (-oo, 1) sage: RealSet.closed_open(0, oo)[0].interior() (0, +oo)
- intersection(other)#
Return the intersection of the two intervals
INPUT:
other
– aInternalRealInterval
OUTPUT:
The intersection as a new
InternalRealInterval
EXAMPLES:
sage: I1 = RealSet.open(0, 2)[0]; I1 (0, 2) sage: I2 = RealSet.closed(1, 3)[0]; I2 [1, 3] sage: I1.intersection(I2) [1, 2) sage: I2.intersection(I1) [1, 2) sage: I1.closure().intersection(I2.interior()) (1, 2] sage: I2.interior().intersection(I1.closure()) (1, 2] sage: I3 = RealSet.closed(10, 11)[0]; I3 [10, 11] sage: I1.intersection(I3) (0, 0) sage: I3.intersection(I1) (0, 0)
- is_connected(other)#
Test whether two intervals are connected
OUTPUT:
Boolean. Whether the set-theoretic union of the two intervals has a single connected component.
EXAMPLES:
sage: I1 = RealSet.open(0, 1)[0]; I1 (0, 1) sage: I2 = RealSet.closed(1, 2)[0]; I2 [1, 2] sage: I1.is_connected(I2) True sage: I1.is_connected(I2.interior()) False sage: I1.closure().is_connected(I2.interior()) True sage: I2.is_connected(I1) True sage: I2.interior().is_connected(I1) False sage: I2.closure().is_connected(I1.interior()) True sage: I3 = RealSet.closed(1/2, 3/2)[0]; I3 [1/2, 3/2] sage: I1.is_connected(I3) True sage: I3.is_connected(I1) True
- is_empty()#
Return whether the interval is empty
The normalized form of
RealSet
has all intervals non-empty, so this method usually returnsFalse
.OUTPUT:
Boolean.
EXAMPLES:
sage: I = RealSet(0, 1)[0] sage: I.is_empty() False
- is_point()#
Return whether the interval consists of a single point
OUTPUT:
Boolean.
EXAMPLES:
sage: I = RealSet(0, 1)[0] sage: I.is_point() False
- lower()#
Return the lower bound
OUTPUT:
The lower bound as it was originally specified.
EXAMPLES:
sage: I = RealSet(0, 1)[0] sage: I.lower() 0 sage: I.upper() 1
- lower_closed()#
Return whether the interval is open at the lower bound
OUTPUT:
Boolean.
EXAMPLES:
sage: I = RealSet.open_closed(0, 1)[0]; I (0, 1] sage: I.lower_closed() False sage: I.lower_open() True sage: I.upper_closed() True sage: I.upper_open() False
- lower_open()#
Return whether the interval is closed at the upper bound
OUTPUT:
Boolean.
EXAMPLES:
sage: I = RealSet.open_closed(0, 1)[0]; I (0, 1] sage: I.lower_closed() False sage: I.lower_open() True sage: I.upper_closed() True sage: I.upper_open() False
- upper()#
Return the upper bound
OUTPUT:
The upper bound as it was originally specified.
EXAMPLES:
sage: I = RealSet(0, 1)[0] sage: I.lower() 0 sage: I.upper() 1
- upper_closed()#
Return whether the interval is closed at the lower bound
OUTPUT:
Boolean.
EXAMPLES:
sage: I = RealSet.open_closed(0, 1)[0]; I (0, 1] sage: I.lower_closed() False sage: I.lower_open() True sage: I.upper_closed() True sage: I.upper_open() False
- upper_open()#
Return whether the interval is closed at the upper bound
OUTPUT:
Boolean.
EXAMPLES:
sage: I = RealSet.open_closed(0, 1)[0]; I (0, 1] sage: I.lower_closed() False sage: I.lower_open() True sage: I.upper_closed() True sage: I.upper_open() False
- class sage.sets.real_set.RealSet(*intervals, normalized=True)#
Bases:
UniqueRepresentation
,Parent
,Set_base
,Set_boolean_operators
,Set_add_sub_operators
A subset of the real line, a finite union of intervals
INPUT:
*args
– arguments defining a real set. Possibilities are either:two extended real numbers
a, b
, to construct the open interval \((a, b)\), ora list/tuple/iterable of (not necessarily disjoint) intervals or real sets, whose union is taken. The individual intervals can be specified by either
a tuple
(a, b)
of two extended real numbers (constructing an open interval),a list
[a, b]
of two real numbers (constructing a closed interval),an
OpenInterval
.
structure
– (default:None
) ifNone
, construct the real set as an instance ofRealSet
; if"differentiable"
, construct it as a subset of an instance ofRealLine
, representing the differentiable manifold \(\RR\).ambient
– (default:None
) an instance ofRealLine
; construct a subset of it. Using this keyword impliesstructure='differentiable'
.names
orcoordinate
– coordinate symbol for the canonical chart; seeRealLine
. Using these keywords impliesstructure='differentiable'
.name
,latex_name
,start_index
– seeRealLine
.normalized
– (default:None
) ifTrue
, the input is already normalized, i.e.,*args
are the connected components (typeInternalRealInterval
) of the real set in ascending order; no other keyword is provided.
There are also specialized constructors for various types of intervals:
Constructor
Interval
\((a, b)\)
\([a, b]\)
\(\{a\}\)
\((a, b]\)
\([a, b)\)
\((-\infty, b]\)
\((-\infty, b)\)
\([a, +\infty)\)
\((a, +\infty)\)
\((-\infty, +\infty)\)
any
EXAMPLES:
sage: RealSet(0, 1) # open set from two numbers (0, 1) sage: RealSet(1, 0) # the two numbers will be sorted (0, 1) sage: s1 = RealSet((1,2)); s1 # tuple of two numbers = open set (1, 2) sage: s2 = RealSet([3,4]); s2 # list of two numbers = closed set [3, 4] sage: i1, i2 = s1[0], s2[0] sage: RealSet(i2, i1) # union of intervals (1, 2) ∪ [3, 4] sage: RealSet((-oo, 0), x > 6, i1, RealSet.point(5), # needs sage.symbolic ....: RealSet.closed_open(4, 3)) (-oo, 0) ∪ (1, 2) ∪ [3, 4) ∪ {5} ∪ (6, +oo)
Initialization from manifold objects:
sage: # needs sage.symbolic sage: R = manifolds.RealLine(); R Real number line ℝ sage: RealSet(R) (-oo, +oo) sage: I02 = manifolds.OpenInterval(0, 2); I I sage: RealSet(I02) (0, 2) sage: I01_of_R = manifolds.OpenInterval(0, 1, ambient_interval=R); I01_of_R Real interval (0, 1) sage: RealSet(I01_of_R) (0, 1) sage: RealSet(I01_of_R.closure()) [0, 1] sage: I01_of_I02 = manifolds.OpenInterval(0, 1, ....: ambient_interval=I02); I01_of_I02 Real interval (0, 1) sage: RealSet(I01_of_I02) (0, 1) sage: RealSet(I01_of_I02.closure()) (0, 1]
Real sets belong to a subcategory of topological spaces:
sage: RealSet().category() Join of Category of finite sets and Category of subobjects of sets and Category of connected topological spaces sage: RealSet.point(1).category() Join of Category of finite sets and Category of subobjects of sets and Category of connected topological spaces sage: RealSet([1, 2]).category() Join of Category of infinite sets and Category of compact topological spaces and Category of subobjects of sets and Category of connected topological spaces sage: RealSet((1, 2), (3, 4)).category() Join of Category of infinite sets and Category of subobjects of sets and Category of topological spaces
Constructing real sets as manifolds or manifold subsets by passing
structure='differentiable'
:sage: # needs sage.symbolic sage: RealSet(-oo, oo, structure='differentiable') Real number line ℝ sage: RealSet([0, 1], structure='differentiable') Subset [0, 1] of the Real number line ℝ sage: _.category() Category of subobjects of sets sage: RealSet.open_closed(0, 5, structure='differentiable') Subset (0, 5] of the Real number line ℝ
This is implied when a coordinate name is given using the keywords
coordinate
ornames
:sage: RealSet(0, 1, coordinate='λ') # needs sage.symbolic Open subset (0, 1) of the Real number line ℝ sage: _.category() # needs sage.symbolic Join of Category of smooth manifolds over Real Field with 53 bits of precision and Category of connected manifolds over Real Field with 53 bits of precision and Category of subobjects of sets
It is also implied by assigning a coordinate name using generator notation:
sage: R_xi.<ξ> = RealSet.real_line(); R_xi # needs sage.symbolic Real number line ℝ sage: R_xi.canonical_chart() # needs sage.symbolic Chart (ℝ, (ξ,))
With the keyword
ambient
, we can construct a subset of a previously constructed manifold:sage: # needs sage.symbolic sage: P_xi = RealSet(0, oo, ambient=R_xi); P_xi Open subset (0, +oo) of the Real number line ℝ sage: P_xi.default_chart() Chart ((0, +oo), (ξ,)) sage: B_xi = RealSet(0, 1, ambient=P_xi); B_xi Open subset (0, 1) of the Real number line ℝ sage: B_xi.default_chart() Chart ((0, 1), (ξ,)) sage: R_xi.subset_family() Set {(0, +oo), (0, 1), ℝ} of open subsets of the Real number line ℝ sage: F = RealSet.point(0).union(RealSet.point(1)).union(RealSet.point(2)); F {0} ∪ {1} ∪ {2} sage: F_tau = RealSet(F, names="τ"); F_tau Subset {0} ∪ {1} ∪ {2} of the Real number line ℝ sage: F_tau.manifold().canonical_chart() Chart (ℝ, (τ,))
- ambient()#
Return the ambient space (the real line).
EXAMPLES:
sage: s = RealSet(RealSet.open_closed(0,1), RealSet.closed_open(2,3)) sage: s.ambient() (-oo, +oo)
- static are_pairwise_disjoint(*real_set_collection)#
Test whether the real sets are pairwise disjoint
INPUT:
*real_set_collection
– a list/tuple/iterable ofRealSet
or data that defines one.
OUTPUT:
Boolean.
See also
EXAMPLES:
sage: s1 = RealSet((0, 1), (2, 3)) sage: s2 = RealSet((1, 2)) sage: s3 = RealSet.point(3) sage: RealSet.are_pairwise_disjoint(s1, s2, s3) True sage: RealSet.are_pairwise_disjoint(s1, s2, s3, [10,10]) True sage: RealSet.are_pairwise_disjoint(s1, s2, s3, [-1, 1/2]) False
- boundary()#
Return the topological boundary of
self
as a newRealSet
.EXAMPLES:
sage: RealSet(-oo, oo).boundary() {} sage: RealSet().boundary() {} sage: RealSet.point(2).boundary() {2} sage: RealSet([1, 2], (3, 4)).boundary() {1} ∪ {2} ∪ {3} ∪ {4} sage: RealSet((1, 2), (2, 3)).boundary() {1} ∪ {2} ∪ {3}
- cardinality()#
Return the cardinality of the subset of the real line.
OUTPUT:
Integer or infinity. The size of a discrete set is the number of points; the size of a real interval is Infinity.
EXAMPLES:
sage: RealSet([0, 0], [1, 1], [3, 3]).cardinality() 3 sage: RealSet(0,3).cardinality() +Infinity
- static closed(lower, upper, **kwds)#
Construct a closed interval
INPUT:
lower
,upper
– two real numbers or infinity. They will be sorted if necessary.**kwds
– seeRealSet
.
OUTPUT:
A new
RealSet
.EXAMPLES:
sage: RealSet.closed(1, 0) [0, 1]
- static closed_open(lower, upper, **kwds)#
Construct a half-open interval
INPUT:
lower
,upper
– two real numbers or infinity. They will be sorted if necessary.**kwds
– seeRealSet
.
OUTPUT:
A new
RealSet
that is closed at the lower bound and open at the upper bound.EXAMPLES:
sage: RealSet.closed_open(1, 0) [0, 1)
- closure()#
Return the topological closure of
self
as a newRealSet
.EXAMPLES:
sage: RealSet(-oo, oo).closure() (-oo, +oo) sage: RealSet((1, 2), (2, 3)).closure() [1, 3] sage: RealSet().closure() {}
- complement()#
Return the complement
OUTPUT:
The set-theoretic complement as a new
RealSet
.EXAMPLES:
sage: RealSet(0,1).complement() (-oo, 0] ∪ [1, +oo) sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10); s1 (0, 2) ∪ [10, +oo) sage: s1.complement() (-oo, 0] ∪ [2, 10) sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10); s2 (-oo, -10] ∪ (1, 3) sage: s2.complement() (-10, 1] ∪ [3, +oo)
- contains(x)#
Return whether \(x\) is contained in the set
INPUT:
x
– a real number.
OUTPUT:
Boolean.
EXAMPLES:
sage: s = RealSet(0,2) + RealSet.unbounded_above_closed(10); s (0, 2) ∪ [10, +oo) sage: s.contains(1) True sage: s.contains(0) False sage: s.contains(10.0) True sage: 10 in s # syntactic sugar True sage: s.contains(+oo) False sage: RealSet().contains(1) False
- static convex_hull(*real_set_collection)#
Return the convex hull of real sets.
INPUT:
*real_set_collection
– a list/tuple/iterable ofRealSet
or data that defines one.
OUTPUT:
The convex hull as a new
RealSet
.EXAMPLES:
sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10); s1 # unbounded set (0, 2) ∪ [10, +oo) sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10); s2 (-oo, -10] ∪ (1, 3) sage: s3 = RealSet((0,2), RealSet.point(8)); s3 (0, 2) ∪ {8} sage: s4 = RealSet(); s4 # empty set {} sage: RealSet.convex_hull(s1) (0, +oo) sage: RealSet.convex_hull(s2) (-oo, 3) sage: RealSet.convex_hull(s3) (0, 8] sage: RealSet.convex_hull(s4) {} sage: RealSet.convex_hull(s1, s2) (-oo, +oo) sage: RealSet.convex_hull(s2, s3) (-oo, 8] sage: RealSet.convex_hull(s2, s3, s4) (-oo, 8]
- difference(*other)#
Return
self
withother
subtractedINPUT:
other
– aRealSet
or data that defines one.
OUTPUT:
The set-theoretic difference of
self
withother
removed as a newRealSet
.EXAMPLES:
sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10); s1 (0, 2) ∪ [10, +oo) sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10); s2 (-oo, -10] ∪ (1, 3) sage: s1.difference(s2) (0, 1] ∪ [10, +oo) sage: s1 - s2 # syntactic sugar (0, 1] ∪ [10, +oo) sage: s2.difference(s1) (-oo, -10] ∪ [2, 3) sage: s2 - s1 # syntactic sugar (-oo, -10] ∪ [2, 3) sage: s1.difference(1,11) (0, 1] ∪ [11, +oo)
- get_interval(i)#
Return the
i
-th connected component.Note that the intervals representing the real set are always normalized, i.e., they are sorted, disjoint and not connected.
INPUT:
i
– integer.
OUTPUT:
The \(i\)-th connected component as a
InternalRealInterval
.EXAMPLES:
sage: s = RealSet(RealSet.open_closed(0,1), RealSet.closed_open(2,3)) sage: s.get_interval(0) (0, 1] sage: s[0] # shorthand (0, 1] sage: s.get_interval(1) [2, 3) sage: s[0] == s.get_interval(0) True
- inf()#
Return the infimum
OUTPUT:
A real number or infinity.
EXAMPLES:
sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10); s1 (0, 2) ∪ [10, +oo) sage: s1.inf() 0 sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10); s2 (-oo, -10] ∪ (1, 3) sage: s2.inf() -Infinity
- interior()#
Return the topological interior of
self
as a newRealSet
.EXAMPLES:
sage: RealSet(-oo, oo).interior() (-oo, +oo) sage: RealSet().interior() {} sage: RealSet.point(2).interior() {} sage: RealSet([1, 2], (3, 4)).interior() (1, 2) ∪ (3, 4)
- intersection(*real_set_collection)#
Return the intersection of real sets
INPUT:
*real_set_collection
– a list/tuple/iterable ofRealSet
or data that defines one.
OUTPUT:
The set-theoretic intersection as a new
RealSet
.EXAMPLES:
sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10); s1 (0, 2) ∪ [10, +oo) sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10); s2 (-oo, -10] ∪ (1, 3) sage: s1.intersection(s2) (1, 2) sage: s1 & s2 # syntactic sugar (1, 2) sage: s3 = RealSet((0, 1), (2, 3)); s3 (0, 1) ∪ (2, 3) sage: s4 = RealSet([0, 1], [2, 3]); s4 [0, 1] ∪ [2, 3] sage: s3.intersection(s4) (0, 1) ∪ (2, 3) sage: s3.intersection([1, 2]) {} sage: s4.intersection([1, 2]) {1} ∪ {2} sage: s4.intersection(1, 2) {} sage: s5 = RealSet.closed_open(1, 10); s5 [1, 10) sage: s5.intersection(-oo, +oo) [1, 10) sage: s5.intersection(x != 2, (-oo, 3), RealSet.real_line()[0]) # needs sage.symbolic [1, 2) ∪ (2, 3)
- static interval(lower, upper, lower_closed, upper_closed, **kwds)#
Construct an interval
INPUT:
lower
,upper
– two real numbers or infinity. They will be sorted if necessary.lower_closed
,upper_closed
– boolean; whether the interval is closed at the lower and upper bound of the interval, respectively.**kwds
– seeRealSet
.
OUTPUT:
A new
RealSet
.EXAMPLES:
sage: RealSet.interval(1, 0, lower_closed=True, upper_closed=False) [0, 1)
- is_closed()#
Return whether
self
is a closed set.EXAMPLES:
sage: RealSet().is_closed() True sage: RealSet.point(1).is_closed() True sage: RealSet([1, 2]).is_closed() True sage: RealSet([1, 2], (3, 4)).is_closed() False sage: RealSet(-oo, +oo).is_closed() True
- is_connected()#
Return whether
self
is a connected set.OUTPUT:
Boolean.
EXAMPLES:
sage: s1 = RealSet((1, 2), (2, 4)); s1 (1, 2) ∪ (2, 4) sage: s1.is_connected() False sage: s2 = RealSet((1, 2), (2, 4), RealSet.point(2)); s2 (1, 4) sage: s2.is_connected() True sage: s3 = RealSet(1,3) + RealSet.unbounded_below_closed(-10); s3 (-oo, -10] ∪ (1, 3) sage: s3.is_connected() False sage: RealSet(x != 0).is_connected() # needs sage.symbolic False sage: RealSet(-oo, oo).is_connected() True sage: RealSet().is_connected() False
- is_disjoint(*other)#
Test whether the two sets are disjoint
INPUT:
other
– aRealSet
or data defining one.
OUTPUT:
Boolean.
See also
EXAMPLES:
sage: s = RealSet((0, 1), (2, 3)); s (0, 1) ∪ (2, 3) sage: s.is_disjoint(RealSet([1, 2])) True sage: s.is_disjoint([3/2, 5/2]) False sage: s.is_disjoint(RealSet()) True sage: s.is_disjoint(RealSet().real_line()) False
- is_disjoint_from(*args, **kwds)#
Deprecated: Use
is_disjoint()
instead. See github issue #31927 for details.
- is_empty()#
Return whether the set is empty
EXAMPLES:
sage: RealSet(0, 1).is_empty() False sage: RealSet(0, 0).is_empty() True sage: RealSet.interval(1, 1, lower_closed=False, upper_closed=True).is_empty() True sage: RealSet.interval(1, -1, lower_closed=False, upper_closed=True).is_empty() False
- is_included_in(*args, **kwds)#
Deprecated: Use
is_subset()
instead. See github issue #31927 for details.
- is_open()#
Return whether
self
is an open set.EXAMPLES:
sage: RealSet().is_open() True sage: RealSet.point(1).is_open() False sage: RealSet((1, 2)).is_open() True sage: RealSet([1, 2], (3, 4)).is_open() False sage: RealSet(-oo, +oo).is_open() True
- is_subset(*other)#
Return whether
self
is a subset ofother
.INPUT:
*other
– aRealSet
or something that defines one.
OUTPUT:
Boolean.
EXAMPLES:
sage: I = RealSet((1,2)) sage: J = RealSet((1,3)) sage: K = RealSet((2,3)) sage: I.is_subset(J) True sage: J.is_subset(K) False
- is_universe()#
Return whether the set is the ambient space (the real line).
EXAMPLES:
sage: RealSet().ambient().is_universe() True
- lift(x)#
Lift
x
to the ambient space forself
.This version of the method just returns
x
.EXAMPLES:
sage: s = RealSet(0, 2); s (0, 2) sage: s.lift(1) 1
- n_components()#
Return the number of connected components
See also
get_interval()
EXAMPLES:
sage: s = RealSet(RealSet.open_closed(0,1), RealSet.closed_open(2,3)) sage: s.n_components() 2
- normalize(intervals)#
Bring a collection of intervals into canonical form
INPUT:
intervals
– a list/tuple/iterable of intervals.
OUTPUT:
A tuple of intervals such that
they are sorted in ascending order (by lower bound)
there is a gap between each interval
all intervals are non-empty
EXAMPLES:
sage: i1 = RealSet((0, 1))[0] sage: i2 = RealSet([1, 2])[0] sage: i3 = RealSet((2, 3))[0] sage: RealSet.normalize([i1, i2, i3]) ((0, 3),)
- static open(lower, upper, **kwds)#
Construct an open interval
INPUT:
lower
,upper
– two real numbers or infinity. They will be sorted if necessary.**kwds
– seeRealSet
.
OUTPUT:
A new
RealSet
.EXAMPLES:
sage: RealSet.open(1, 0) (0, 1)
- static open_closed(lower, upper, **kwds)#
Construct a half-open interval
INPUT:
lower
,upper
– two real numbers or infinity. They will be sorted if necessary.**kwds
– seeRealSet
.
OUTPUT:
A new
RealSet
that is open at the lower bound and closed at the upper bound.EXAMPLES:
sage: RealSet.open_closed(1, 0) (0, 1]
- static point(p, **kwds)#
Construct an interval containing a single point
INPUT:
p
– a real number.**kwds
– seeRealSet
.
OUTPUT:
A new
RealSet
.EXAMPLES:
sage: RealSet.open(1, 0) (0, 1)
- static real_line(**kwds)#
Construct the real line
INPUT:
**kwds
– seeRealSet
.
EXAMPLES:
sage: RealSet.real_line() (-oo, +oo)
- retract(x)#
Retract
x
toself
.It raises an error if
x
does not lie in the setself
.EXAMPLES:
sage: s = RealSet(0, 2); s (0, 2) sage: s.retract(1) 1 sage: s.retract(2) Traceback (most recent call last): ... ValueError: 2 is not an element of (0, 2)
- sup()#
Return the supremum
OUTPUT:
A real number or infinity.
EXAMPLES:
sage: s1 = RealSet(0,2) + RealSet.unbounded_above_closed(10); s1 (0, 2) ∪ [10, +oo) sage: s1.sup() +Infinity sage: s2 = RealSet(1,3) + RealSet.unbounded_below_closed(-10); s2 (-oo, -10] ∪ (1, 3) sage: s2.sup() 3
- symmetric_difference(*other)#
Returns the symmetric difference of
self
andother
.INPUT:
other
– aRealSet
or data that defines one.
OUTPUT:
The set-theoretic symmetric difference of
self
andother
as a newRealSet
.EXAMPLES:
sage: s1 = RealSet(0,2); s1 (0, 2) sage: s2 = RealSet.unbounded_above_open(1); s2 (1, +oo) sage: s1.symmetric_difference(s2) (0, 1] ∪ [2, +oo)
- static unbounded_above_closed(bound, **kwds)#
Construct a semi-infinite interval
INPUT:
bound
– a real number.**kwds
– seeRealSet
.
OUTPUT:
A new
RealSet
from the bound (including) to plus infinity.EXAMPLES:
sage: RealSet.unbounded_above_closed(1) [1, +oo)
- static unbounded_above_open(bound, **kwds)#
Construct a semi-infinite interval
INPUT:
bound
– a real number.**kwds
– seeRealSet
.
OUTPUT:
A new
RealSet
from the bound (excluding) to plus infinity.EXAMPLES:
sage: RealSet.unbounded_above_open(1) (1, +oo)
- static unbounded_below_closed(bound, **kwds)#
Construct a semi-infinite interval
INPUT:
bound
– a real number.
OUTPUT:
A new
RealSet
from minus infinity to the bound (including).**kwds
– seeRealSet
.
EXAMPLES:
sage: RealSet.unbounded_below_closed(1) (-oo, 1]
- static unbounded_below_open(bound, **kwds)#
Construct a semi-infinite interval
INPUT:
bound
– a real number.
OUTPUT:
A new
RealSet
from minus infinity to the bound (excluding).**kwds
– seeRealSet
.
EXAMPLES:
sage: RealSet.unbounded_below_open(1) (-oo, 1)
- union(*real_set_collection)#
Return the union of real sets
INPUT:
*real_set_collection
– a list/tuple/iterable ofRealSet
or data that defines one.
OUTPUT:
The set-theoretic union as a new
RealSet
.EXAMPLES:
sage: s1 = RealSet(0,2) sage: s2 = RealSet(1,3) sage: s1.union(s2) (0, 3) sage: s1.union(1,3) (0, 3) sage: s1 | s2 # syntactic sugar (0, 3) sage: s1 + s2 # syntactic sugar (0, 3) sage: RealSet().union(RealSet.real_line()) (-oo, +oo) sage: s = RealSet().union([1, 2], (2, 3)); s [1, 3) sage: RealSet().union((-oo, 0), x > 6, s[0], # needs sage.symbolic ....: RealSet.point(5.0), RealSet.closed_open(2, 4)) (-oo, 0) ∪ [1, 4) ∪ {5} ∪ (6, +oo)