行¶

class sympy.geometry.line.LinearEntity(p1, p2=None, **kwargs)[源代码][源代码]¶

所有线性实体（线、射线和线段）在n维欧几里得空间中的基类。

属性:

ambient_dimension: 返回 LinearEntity 对象维度的属性方法。
direction: LinearEntity 的方向向量。
length: 线条的长度。
p1: 线性实体的第一个定义点。
p2: 线性实体的第二个定义点。
points: 用于定义此线性实体的两个点。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	子类应实现此方法，如果 other 在 self 的边界上，则应返回 True；如果不在 self 的边界上，则应返回 False；如果无法确定，则应返回 None。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
等于
is_hypergeometric

参见

sympy.geometry.entity.GeometryEntity

注释

这是一个抽象类，不打算被实例化。

property ambient_dimension¶

返回 LinearEntity 对象维度的属性方法。

参数:

p1LinearEntity

返回:

维度整数

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(1, 1)
>>> l1 = Line(p1, p2)
>>> l1.ambient_dimension
2

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
>>> l1 = Line(p1, p2)
>>> l1.ambient_dimension
3

angle_between(l2)[源代码][源代码]¶

返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。

参数:

l1LinearEntity
l2LinearEntity

返回:

角度弧度角

参见

is_perpendicular, Ray2D.closing_angle

注释

从向量 v1 和 v2 的点积可以得知：

dot(v1, v2) = |v1|*|v2|*cos(A)

其中 A 是两个向量之间形成的角度。我们可以得到两条直线的方向向量，并使用上述公式轻松找到两者之间的角度。

示例

>>> from sympy import Line
>>> e = Line((0, 0), (1, 0))
>>> ne = Line((0, 0), (1, 1))
>>> sw = Line((1, 1), (0, 0))
>>> ne.angle_between(e)
pi/4
>>> sw.angle_between(e)
3*pi/4

要获得直线交点处的非钝角，请使用 smallest_angle_between 方法：

>>> sw.smallest_angle_between(e)
pi/4

>>> from sympy import Point3D, Line3D
>>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
>>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
>>> l1.angle_between(l2)
acos(-sqrt(2)/3)
>>> l1.smallest_angle_between(l2)
acos(sqrt(2)/3)

arbitrary_point(parameter='t')[源代码][源代码]¶

线上的一个参数化点。

参数:

参数str, 可选: 用于参数化点的参数名称。默认值为 ‘t’。当此参数为 0 时，将返回用于定义线的第一个点，当其为 1 时，将返回第二个点。

返回:

点点

Raises:

ValueError: 当 参数 已经出现在线路的定义中。

参见

sympy.geometry.point.Point

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(1, 0), Point(5, 3)
>>> l1 = Line(p1, p2)
>>> l1.arbitrary_point()
Point2D(4*t + 1, 3*t)
>>> from sympy import Point3D, Line3D
>>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 1)
>>> l1 = Line3D(p1, p2)
>>> l1.arbitrary_point()
Point3D(4*t + 1, 3*t, t)

static are_concurrent(*lines)[源代码][源代码]¶

一系列线性实体是并发的吗？

如果两条或多条线性实体在单个点相交，则它们是共点的。

参数:

行: 一系列线性实体。

返回:

真如果一组线性实体相交于一点
假否则。

参见

sympy.geometry.util.intersection

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(3, 5)
>>> p3, p4 = Point(-2, -2), Point(0, 2)
>>> l1, l2, l3 = Line(p1, p2), Line(p1, p3), Line(p1, p4)
>>> Line.are_concurrent(l1, l2, l3)
True
>>> l4 = Line(p2, p3)
>>> Line.are_concurrent(l2, l3, l4)
False
>>> from sympy import Point3D, Line3D
>>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 5, 2)
>>> p3, p4 = Point3D(-2, -2, -2), Point3D(0, 2, 1)
>>> l1, l2, l3 = Line3D(p1, p2), Line3D(p1, p3), Line3D(p1, p4)
>>> Line3D.are_concurrent(l1, l2, l3)
True
>>> l4 = Line3D(p2, p3)
>>> Line3D.are_concurrent(l2, l3, l4)
False

bisectors(other)[源代码][源代码]¶

返回通过自身和其他对象在同一平面内交点的垂直线。

参数:

行Line3D

返回:

list: 两个 Line 实例

示例

>>> from sympy import Point3D, Line3D
>>> r1 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
>>> r2 = Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))
>>> r1.bisectors(r2)
[Line3D(Point3D(0, 0, 0), Point3D(1, 1, 0)), Line3D(Point3D(0, 0, 0), Point3D(1, -1, 0))]

contains(other)[源代码][源代码]¶: 子类应实现此方法，如果 other 在 self 的边界上，则应返回 True；如果不在 self 的边界上，则应返回 False；如果无法确定，则应返回 None。

property direction¶

LinearEntity 的方向向量。

返回:

p一个点；从原点到该点的射线是: \(self\) 的方向

参见

sympy.geometry.point.Point.unit

示例

>>> from sympy import Line
>>> a, b = (1, 1), (1, 3)
>>> Line(a, b).direction
Point2D(0, 2)
>>> Line(b, a).direction
Point2D(0, -2)

这可以被报告，使得从原点的距离为1：

>>> Line(b, a).direction.unit
Point2D(0, -1)

intersection(other)[源代码][源代码]¶

与另一个几何实体的交点。

参数:

o点或线性实体

返回:

交叉点几何实体列表

参见

sympy.geometry.point.Point

示例

>>> from sympy import Point, Line, Segment
>>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(7, 7)
>>> l1 = Line(p1, p2)
>>> l1.intersection(p3)
[Point2D(7, 7)]
>>> p4, p5 = Point(5, 0), Point(0, 3)
>>> l2 = Line(p4, p5)
>>> l1.intersection(l2)
[Point2D(15/8, 15/8)]
>>> p6, p7 = Point(0, 5), Point(2, 6)
>>> s1 = Segment(p6, p7)
>>> l1.intersection(s1)
[]
>>> from sympy import Point3D, Line3D, Segment3D
>>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(7, 7, 7)
>>> l1 = Line3D(p1, p2)
>>> l1.intersection(p3)
[Point3D(7, 7, 7)]
>>> l1 = Line3D(Point3D(4,19,12), Point3D(5,25,17))
>>> l2 = Line3D(Point3D(-3, -15, -19), direction_ratio=[2,8,8])
>>> l1.intersection(l2)
[Point3D(1, 1, -3)]
>>> p6, p7 = Point3D(0, 5, 2), Point3D(2, 6, 3)
>>> s1 = Segment3D(p6, p7)
>>> l1.intersection(s1)
[]

is_parallel(l2)[源代码][源代码]¶

两条线性实体是平行的吗？

参数:

l1LinearEntity
l2LinearEntity

返回:

真如果 l1 和 l2 是平行的，
假否则。

参见

coefficients

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(1, 1)
>>> p3, p4 = Point(3, 4), Point(6, 7)
>>> l1, l2 = Line(p1, p2), Line(p3, p4)
>>> Line.is_parallel(l1, l2)
True
>>> p5 = Point(6, 6)
>>> l3 = Line(p3, p5)
>>> Line.is_parallel(l1, l3)
False
>>> from sympy import Point3D, Line3D
>>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 4, 5)
>>> p3, p4 = Point3D(2, 1, 1), Point3D(8, 9, 11)
>>> l1, l2 = Line3D(p1, p2), Line3D(p3, p4)
>>> Line3D.is_parallel(l1, l2)
True
>>> p5 = Point3D(6, 6, 6)
>>> l3 = Line3D(p3, p5)
>>> Line3D.is_parallel(l1, l3)
False

is_perpendicular(l2)[源代码][源代码]¶

两条线性实体是垂直的吗？

参数:

l1LinearEntity
l2LinearEntity

返回:

真如果 l1 和 l2 垂直，
假否则。

参见

coefficients

示例

>>> from sympy import Point, Line
>>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(-1, 1)
>>> l1, l2 = Line(p1, p2), Line(p1, p3)
>>> l1.is_perpendicular(l2)
True
>>> p4 = Point(5, 3)
>>> l3 = Line(p1, p4)
>>> l1.is_perpendicular(l3)
False
>>> from sympy import Point3D, Line3D
>>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
>>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
>>> l1.is_perpendicular(l2)
False
>>> p4 = Point3D(5, 3, 7)
>>> l3 = Line3D(p1, p4)
>>> l1.is_perpendicular(l3)
False

is_similar(other)[源代码][源代码]¶

如果 self 和 other 在同一行中，则返回 True。

示例

>>> from sympy import Point, Line
>>> p1, p2, p3 = Point(0, 1), Point(3, 4), Point(2, 3)
>>> l1 = Line(p1, p2)
>>> l2 = Line(p1, p3)
>>> l1.is_similar(l2)
True

property length¶

线条的长度。

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(3, 5)
>>> l1 = Line(p1, p2)
>>> l1.length
oo

property p1¶

线性实体的第一个定义点。

参见

sympy.geometry.point.Point

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(5, 3)
>>> l = Line(p1, p2)
>>> l.p1
Point2D(0, 0)

property p2¶

线性实体的第二个定义点。

参见

sympy.geometry.point.Point

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(5, 3)
>>> l = Line(p1, p2)
>>> l.p2
Point2D(5, 3)

parallel_line(p)[源代码][源代码]¶

创建一条与该线性实体平行并通过点 \(p\) 的新线。

参数:

p点

返回:

行行

参见

is_parallel

示例

>>> from sympy import Point, Line
>>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
>>> l1 = Line(p1, p2)
>>> l2 = l1.parallel_line(p3)
>>> p3 in l2
True
>>> l1.is_parallel(l2)
True
>>> from sympy import Point3D, Line3D
>>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
>>> l1 = Line3D(p1, p2)
>>> l2 = l1.parallel_line(p3)
>>> p3 in l2
True
>>> l1.is_parallel(l2)
True

perpendicular_line(p)[源代码][源代码]¶

创建一条垂直于该线性实体的新线，该线通过点 \(p\)。

参数:

p点

返回:

行行

参见

sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment

示例

>>> from sympy import Point3D, Line3D
>>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
>>> L = Line3D(p1, p2)
>>> P = L.perpendicular_line(p3); P
Line3D(Point3D(-2, 2, 0), Point3D(4/29, 6/29, 8/29))
>>> L.is_perpendicular(P)
True

在三维空间中，用于定义直线的第一个点是要求垂直通过的点；第二个点（任意地）包含在给定的直线中：

>>> P.p2 in L
True

perpendicular_segment(p)[源代码][源代码]¶

从 \(p\) 点创建一条垂直于该线的线段。

线段的端点是 p 和包含自身的直线中最接近的点。（如果自身不是直线，该点可能不在自身内。）

参数:

p点

返回:

段落段

参见

perpendicular_line

注释

如果 \(p\) 在这个线性实体上，则返回 \(p\) 本身。

示例

>>> from sympy import Point, Line
>>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, 2)
>>> l1 = Line(p1, p2)
>>> s1 = l1.perpendicular_segment(p3)
>>> l1.is_perpendicular(s1)
True
>>> p3 in s1
True
>>> l1.perpendicular_segment(Point(4, 0))
Segment2D(Point2D(4, 0), Point2D(2, 2))
>>> from sympy import Point3D, Line3D
>>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, 2, 0)
>>> l1 = Line3D(p1, p2)
>>> s1 = l1.perpendicular_segment(p3)
>>> l1.is_perpendicular(s1)
True
>>> p3 in s1
True
>>> l1.perpendicular_segment(Point3D(4, 0, 0))
Segment3D(Point3D(4, 0, 0), Point3D(4/3, 4/3, 4/3))

property points¶

用于定义此线性实体的两个点。

返回:

点点的元组

参见

sympy.geometry.point.Point

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(5, 11)
>>> l1 = Line(p1, p2)
>>> l1.points
(Point2D(0, 0), Point2D(5, 11))

projection(other)[源代码][源代码]¶

将一个点、线、射线或线段投影到这个线性实体上。

参数:

其他点或线性实体（线、射线、线段）

返回:

投影点或线性实体（线、射线、线段）: 返回类型与参数 other 的类型匹配。

Raises:

GeometryError: 当方法无法执行投影时。

参见

sympy.geometry.point.Point, perpendicular_line

注释

投影涉及取定义线性实体的两个点，并将这些点投影到一条线上，然后使用这些投影重新形成线性实体。点 P 投影到线 L 上是通过找到 L 上最接近 P 的点来实现的。这个点是 L 和通过 P 且垂直于 L 的线的交点。

示例

>>> from sympy import Point, Line, Segment, Rational
>>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(Rational(1, 2), 0)
>>> l1 = Line(p1, p2)
>>> l1.projection(p3)
Point2D(1/4, 1/4)
>>> p4, p5 = Point(10, 0), Point(12, 1)
>>> s1 = Segment(p4, p5)
>>> l1.projection(s1)
Segment2D(Point2D(5, 5), Point2D(13/2, 13/2))
>>> p1, p2, p3 = Point(0, 0, 1), Point(1, 1, 2), Point(2, 0, 1)
>>> l1 = Line(p1, p2)
>>> l1.projection(p3)
Point3D(2/3, 2/3, 5/3)
>>> p4, p5 = Point(10, 0, 1), Point(12, 1, 3)
>>> s1 = Segment(p4, p5)
>>> l1.projection(s1)
Segment3D(Point3D(10/3, 10/3, 13/3), Point3D(5, 5, 6))

random_point(seed=None)[源代码][源代码]¶

线性实体上的一个随机点。

返回:

点点

参见

sympy.geometry.point.Point

示例

>>> from sympy import Point, Line, Ray, Segment
>>> p1, p2 = Point(0, 0), Point(5, 3)
>>> line = Line(p1, p2)
>>> r = line.random_point(seed=42)  # seed value is optional
>>> r.n(3)
Point2D(-0.72, -0.432)
>>> r in line
True
>>> Ray(p1, p2).random_point(seed=42).n(3)
Point2D(0.72, 0.432)
>>> Segment(p1, p2).random_point(seed=42).n(3)
Point2D(3.2, 1.92)

smallest_angle_between(l2)[源代码][源代码]¶

返回包含线性实体的直线相交形成的最小角度。

参数:

l1LinearEntity
l2LinearEntity

返回:

角度弧度角

参见

angle_between, is_perpendicular, Ray2D.closing_angle

示例

>>> from sympy import Point, Line
>>> p1, p2, p3 = Point(0, 0), Point(0, 4), Point(2, -2)
>>> l1, l2 = Line(p1, p2), Line(p1, p3)
>>> l1.smallest_angle_between(l2)
pi/4

class sympy.geometry.line.Line(*args, **kwargs)[源代码][源代码]¶

空间中的一条无限直线。

二维直线可以通过两个不同的点、点与斜率，或一个方程来声明。三维直线可以通过一个点和方向比来定义。

参数:

p1点
p2点
斜率SymPy 表达式
direction_ratio列表
方程直线的方程

属性:

ambient_dimension: 返回 LinearEntity 对象维度的属性方法。
args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
boundary: 一个集合的边界或前沿。
bounds: 返回一个元组 (xmin, ymin, xmax, ymax)，表示几何图形的边界矩形。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
closure: 返回集合闭包的属性方法。
direction: LinearEntity 的方向向量。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
inf: self 的下确界。
interior: 返回集合内部的属性方法。
is_Complement
is_EmptySet
is_Intersection
is_UniversalSet
is_algebraic
is_antihermitian
is_closed: 一个检查集合是否闭合的属性方法。
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_empty
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_finite_set
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_open: 检查集合是否为开集的属性方法。
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
kind: 集合的种类
length: 线条的长度。
measure: self 的 (勒贝格) 测度
p1: 线性实体的第一个定义点。
p2: 线性实体的第二个定义点。
points: 用于定义此线性实体的两个点。
sup: self 的上确界。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	如果 \(other\) 在这条线上，则返回 True，否则返回 False。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`distance`(other)	计算直线与点之间的最短距离。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`equals`(other)	如果 self 和 other 是相同的数学实体，则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`plot_interval`([parameter])	默认几何线条图的绘图间隔。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

sympy.geometry.point.Point
sympy.geometry.line.Line2D
sympy.geometry.line.Line3D

注释

\(Line\) 将根据 \(p1\) 的维度自动子类化为 \(Line2D\) 或 \(Line3D\)。\(slope\) 参数仅与 \(Line2D\) 相关，而 \(direction_ratio\) 参数仅与 \(Line3D\) 相关。

点的顺序将定义线的方向，这在计算线之间的角度时使用。

示例

>>> from sympy import Line, Segment, Point, Eq
>>> from sympy.abc import x, y, a, b

>>> L = Line(Point(2,3), Point(3,5))
>>> L
Line2D(Point2D(2, 3), Point2D(3, 5))
>>> L.points
(Point2D(2, 3), Point2D(3, 5))
>>> L.equation()
-2*x + y + 1
>>> L.coefficients
(-2, 1, 1)

使用关键字 slope 实例化：

>>> Line(Point(0, 0), slope=0)
Line2D(Point2D(0, 0), Point2D(1, 0))

用另一个线性对象实例化

>>> s = Segment((0, 0), (0, 1))
>>> Line(s).equation()
x

对于方程 \(ax + by + c = 0\) 对应的直线，可以输入：

>>> Line(3*x + y + 18)
Line2D(Point2D(0, -18), Point2D(1, -21))

如果 \(x\) 或 \(y\) 有不同的名称，那么它们也可以被指定，作为字符串（匹配名称）或符号：

>>> Line(Eq(3*a + b, -18), x='a', y=b)
Line2D(Point2D(0, -18), Point2D(1, -21))

contains(other)[源代码][源代码]¶

如果 \(other\) 在这条线上，则返回 True，否则返回 False。

示例

>>> from sympy import Line,Point
>>> p1, p2 = Point(0, 1), Point(3, 4)
>>> l = Line(p1, p2)
>>> l.contains(p1)
True
>>> l.contains((0, 1))
True
>>> l.contains((0, 0))
False
>>> a = (0, 0, 0)
>>> b = (1, 1, 1)
>>> c = (2, 2, 2)
>>> l1 = Line(a, b)
>>> l2 = Line(b, a)
>>> l1 == l2
False
>>> l1 in l2
True

distance(other)[源代码][源代码]¶

计算直线与点之间的最短距离。

Raises:

如果 \(other\) 不是一个 Point，则引发 NotImplementedError

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(1, 1)
>>> s = Line(p1, p2)
>>> s.distance(Point(-1, 1))
sqrt(2)
>>> s.distance((-1, 2))
3*sqrt(2)/2
>>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
>>> s = Line(p1, p2)
>>> s.distance(Point(-1, 1, 1))
2*sqrt(6)/3
>>> s.distance((-1, 1, 1))
2*sqrt(6)/3

equals(other)[源代码][源代码]¶: 如果 self 和 other 是相同的数学实体，则返回 True。

plot_interval(parameter='t')[源代码][源代码]¶

默认几何线条图的绘图间隔。给出将生成一条长度为 +/- 5 单位的线的值（其中单位是定义线条的两点之间的距离）。

参数:

参数str, 可选: 默认值是 ‘t’。

返回:

plot_interval列表 (绘图间隔): [参数, 下限, 上限]

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(5, 3)
>>> l1 = Line(p1, p2)
>>> l1.plot_interval()
[t, -5, 5]

class sympy.geometry.line.Ray(p1, p2=None, **kwargs)[源代码][源代码]¶

一条射线是空间中的一条半线，具有一个源点和方向。

参数:

p1点: Ray 的源代码
p2点值或弧度值: 这一点决定了光线传播的方向。如果给定的是角度，则以弧度解释，正方向为逆时针。

属性:

source: 光线发出的点。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	其他几何实体是否包含在此射线中？
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`distance`(other)	找到光线与点之间的最短距离。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`equals`(other)	如果 self 和 other 是相同的数学实体，则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`plot_interval`([parameter])	Ray 默认几何图的绘图间隔。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

sympy.geometry.line.Ray2D
sympy.geometry.line.Ray3D
sympy.geometry.point.Point
sympy.geometry.line.Line

注释

\(Ray\) 将根据 \(p1\) 的维度自动子类化为 \(Ray2D\) 或 \(Ray3D\)。

示例

>>> from sympy import Ray, Point, pi
>>> r = Ray(Point(2, 3), Point(3, 5))
>>> r
Ray2D(Point2D(2, 3), Point2D(3, 5))
>>> r.points
(Point2D(2, 3), Point2D(3, 5))
>>> r.source
Point2D(2, 3)
>>> r.xdirection
oo
>>> r.ydirection
oo
>>> r.slope
2
>>> Ray(Point(0, 0), angle=pi/4).slope
1

contains(other)[源代码][源代码]¶

其他几何实体是否包含在此射线中？

示例

>>> from sympy import Ray,Point,Segment
>>> p1, p2 = Point(0, 0), Point(4, 4)
>>> r = Ray(p1, p2)
>>> r.contains(p1)
True
>>> r.contains((1, 1))
True
>>> r.contains((1, 3))
False
>>> s = Segment((1, 1), (2, 2))
>>> r.contains(s)
True
>>> s = Segment((1, 2), (2, 5))
>>> r.contains(s)
False
>>> r1 = Ray((2, 2), (3, 3))
>>> r.contains(r1)
True
>>> r1 = Ray((2, 2), (3, 5))
>>> r.contains(r1)
False

distance(other)[源代码][源代码]¶

找到光线与点之间的最短距离。

Raises:

如果 \(other\) 不是一个 Point，则引发 NotImplementedError

示例

>>> from sympy import Point, Ray
>>> p1, p2 = Point(0, 0), Point(1, 1)
>>> s = Ray(p1, p2)
>>> s.distance(Point(-1, -1))
sqrt(2)
>>> s.distance((-1, 2))
3*sqrt(2)/2
>>> p1, p2 = Point(0, 0, 0), Point(1, 1, 2)
>>> s = Ray(p1, p2)
>>> s
Ray3D(Point3D(0, 0, 0), Point3D(1, 1, 2))
>>> s.distance(Point(-1, -1, 2))
4*sqrt(3)/3
>>> s.distance((-1, -1, 2))
4*sqrt(3)/3

equals(other)[源代码][源代码]¶: 如果 self 和 other 是相同的数学实体，则返回 True。

plot_interval(parameter='t')[源代码][源代码]¶

Ray 的默认几何图形绘制的绘图间隔。给出将生成一个长度为 10 个单位的射线的值（其中单位是定义射线的两个点之间的距离）。

参数:

参数str, 可选: 默认值是 ‘t’。

返回:

plot_interval列表: [参数, 下限, 上限]

示例

>>> from sympy import Ray, pi
>>> r = Ray((0, 0), angle=pi/4)
>>> r.plot_interval()
[t, 0, 10]

property source¶

光线发出的点。

参见

sympy.geometry.point.Point

示例

>>> from sympy import Point, Ray
>>> p1, p2 = Point(0, 0), Point(4, 1)
>>> r1 = Ray(p1, p2)
>>> r1.source
Point2D(0, 0)
>>> p1, p2 = Point(0, 0, 0), Point(4, 1, 5)
>>> r1 = Ray(p2, p1)
>>> r1.source
Point3D(4, 1, 5)

class sympy.geometry.line.Segment(p1, p2, **kwargs)[源代码][源代码]¶

空间中的一条线段。

参数:

p1点
p2点

属性:

length数字或 SymPy 表达式: 线段的长度。
midpoint点: 线段的中点。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	另一个 GeometryEntity 是否包含在此线段内？
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`distance`(other)	找到线段和点之间的最短距离。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`equals`(other)	如果 self 和 other 是相同的数学实体，则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_bisector`([p])	这条线段的垂直平分线。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`plot_interval`([parameter])	默认几何图形的线段的绘图间隔给出了在绘图中将生成完整线段的值。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

sympy.geometry.line.Segment2D
sympy.geometry.line.Segment3D
sympy.geometry.point.Point
sympy.geometry.line.Line

注释

如果使用2D或3D点来定义 \(Segment\)，它将自动子类化为 \(Segment2D\) 或 \(Segment3D\)。

示例

>>> from sympy import Point, Segment
>>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
Segment2D(Point2D(1, 0), Point2D(1, 1))
>>> s = Segment(Point(4, 3), Point(1, 1))
>>> s.points
(Point2D(4, 3), Point2D(1, 1))
>>> s.slope
2/3
>>> s.length
sqrt(13)
>>> s.midpoint
Point2D(5/2, 2)
>>> Segment((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
>>> s = Segment(Point(4, 3, 9), Point(1, 1, 7)); s
Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
>>> s.points
(Point3D(4, 3, 9), Point3D(1, 1, 7))
>>> s.length
sqrt(17)
>>> s.midpoint
Point3D(5/2, 2, 8)

contains(other)[源代码][源代码]¶

另一个 GeometryEntity 是否包含在此线段内？

示例

>>> from sympy import Point, Segment
>>> p1, p2 = Point(0, 1), Point(3, 4)
>>> s = Segment(p1, p2)
>>> s2 = Segment(p2, p1)
>>> s.contains(s2)
True
>>> from sympy import Point3D, Segment3D
>>> p1, p2 = Point3D(0, 1, 1), Point3D(3, 4, 5)
>>> s = Segment3D(p1, p2)
>>> s2 = Segment3D(p2, p1)
>>> s.contains(s2)
True
>>> s.contains((p1 + p2)/2)
True

distance(other)[源代码][源代码]¶

找到线段和点之间的最短距离。

Raises:

如果 \(other\) 不是一个 Point，则引发 NotImplementedError

示例

>>> from sympy import Point, Segment
>>> p1, p2 = Point(0, 1), Point(3, 4)
>>> s = Segment(p1, p2)
>>> s.distance(Point(10, 15))
sqrt(170)
>>> s.distance((0, 12))
sqrt(73)
>>> from sympy import Point3D, Segment3D
>>> p1, p2 = Point3D(0, 0, 3), Point3D(1, 1, 4)
>>> s = Segment3D(p1, p2)
>>> s.distance(Point3D(10, 15, 12))
sqrt(341)
>>> s.distance((10, 15, 12))
sqrt(341)

equals(other)[源代码][源代码]¶: 如果 self 和 other 是相同的数学实体，则返回 True。

property length¶

线段的长度。

参见

sympy.geometry.point.Point.distance

示例

>>> from sympy import Point, Segment
>>> p1, p2 = Point(0, 0), Point(4, 3)
>>> s1 = Segment(p1, p2)
>>> s1.length
5
>>> from sympy import Point3D, Segment3D
>>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
>>> s1 = Segment3D(p1, p2)
>>> s1.length
sqrt(34)

property midpoint¶

线段的中点。

参见

sympy.geometry.point.Point.midpoint

示例

>>> from sympy import Point, Segment
>>> p1, p2 = Point(0, 0), Point(4, 3)
>>> s1 = Segment(p1, p2)
>>> s1.midpoint
Point2D(2, 3/2)
>>> from sympy import Point3D, Segment3D
>>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
>>> s1 = Segment3D(p1, p2)
>>> s1.midpoint
Point3D(2, 3/2, 3/2)

perpendicular_bisector(p=None)[源代码][源代码]¶

这条线段的垂直平分线。

如果没有指定点或指定的点不在角平分线上，则返回角平分线作为一条直线。否则，返回连接指定点和角平分线与线段交点的线段。

参数:

p点

返回:

平分线线或线段

参见

LinearEntity.perpendicular_segment

示例

>>> from sympy import Point, Segment
>>> p1, p2, p3 = Point(0, 0), Point(6, 6), Point(5, 1)
>>> s1 = Segment(p1, p2)
>>> s1.perpendicular_bisector()
Line2D(Point2D(3, 3), Point2D(-3, 9))

>>> s1.perpendicular_bisector(p3)
Segment2D(Point2D(5, 1), Point2D(3, 3))

plot_interval(parameter='t')[源代码][源代码]¶

默认几何图形的线段的绘图间隔给出了在绘图中将生成完整线段的值。

参数:

参数str, 可选: 默认值是 ‘t’。

返回:

plot_interval列表: [参数, 下限, 上限]

示例

>>> from sympy import Point, Segment
>>> p1, p2 = Point(0, 0), Point(5, 3)
>>> s1 = Segment(p1, p2)
>>> s1.plot_interval()
[t, 0, 1]

class sympy.geometry.line.LinearEntity2D(p1, p2=None, **kwargs)[源代码][源代码]¶

所有二维欧几里得空间中线性实体（线、射线和线段）的基类。

属性:

p1: 线性实体的第一个定义点。
p2: 线性实体的第二个定义点。
系数
slope: 这条线性实体的斜率，如果是垂直的则为无穷大。
points: 用于定义此线性实体的两个点。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	子类应实现此方法，如果 other 在 self 的边界上，则应返回 True；如果不在 self 的边界上，则应返回 False；如果无法确定，则应返回 None。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
等于
is_hypergeometric

参见

sympy.geometry.entity.GeometryEntity

注释

这是一个抽象类，不打算被实例化。

property bounds¶: 返回一个元组 (xmin, ymin, xmax, ymax)，表示几何图形的边界矩形。

perpendicular_line(p)[源代码][源代码]¶

创建一条垂直于该线性实体的新线，该线通过点 \(p\)。

参数:

p点

返回:

行行

参见

sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment

示例

>>> from sympy import Point, Line
>>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
>>> L = Line(p1, p2)
>>> P = L.perpendicular_line(p3); P
Line2D(Point2D(-2, 2), Point2D(-5, 4))
>>> L.is_perpendicular(P)
True

在二维中，垂直线的第一个点是通过该点所需的点；第二个点是任意选择的。要得到一条明确使用线中某点的线，请从线到点的垂直线段创建一条线：

>>> Line(L.perpendicular_segment(p3))
Line2D(Point2D(-2, 2), Point2D(4/13, 6/13))

property slope¶

这条线性实体的斜率，如果是垂直的则为无穷大。

返回:

斜率数字或 SymPy 表达式

参见

coefficients

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(0, 0), Point(3, 5)
>>> l1 = Line(p1, p2)
>>> l1.slope
5/3

>>> p3 = Point(0, 4)
>>> l2 = Line(p1, p3)
>>> l2.slope
oo

class sympy.geometry.line.Line2D(p1, pt=None, slope=None, **kwargs)[源代码][源代码]¶

空间中的无限二维线。

一条线可以通过两个不同的点或一个点和斜率来声明，斜率通过关键字 \(slope\) 定义。

参数:

p1点
pt点
斜率SymPy 表达式

属性:

ambient_dimension: 返回 LinearEntity 对象维度的属性方法。
args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
boundary: 一个集合的边界或前沿。
bounds: 返回一个元组 (xmin, ymin, xmax, ymax)，表示几何图形的边界矩形。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
closure: 返回集合闭包的属性方法。
coefficients: 系数 (\(a\), \(b\), \(c\)) 用于 \(ax + by + c = 0\)。
direction: LinearEntity 的方向向量。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
inf: self 的下确界。
interior: 返回集合内部的属性方法。
is_Complement
is_EmptySet
is_Intersection
is_UniversalSet
is_algebraic
is_antihermitian
is_closed: 一个检查集合是否闭合的属性方法。
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_empty
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_finite_set
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_open: 检查集合是否为开集的属性方法。
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
kind: 集合的种类
length: 线条的长度。
measure: self 的 (勒贝格) 测度
p1: 线性实体的第一个定义点。
p2: 线性实体的第二个定义点。
points: 用于定义此线性实体的两个点。
slope: 这条线性实体的斜率，如果是垂直的则为无穷大。
sup: self 的上确界。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	如果 \(other\) 在这条线上，则返回 True，否则返回 False。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`distance`(other)	计算直线与点之间的最短距离。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`equals`(other)	如果 self 和 other 是相同的数学实体，则返回 True。
`equation`([x, y])	直线的方程式：ax + by + c。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`plot_interval`([parameter])	默认几何线条图的绘图间隔。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

sympy.geometry.point.Point

示例

>>> from sympy import Line, Segment, Point
>>> L = Line(Point(2,3), Point(3,5))
>>> L
Line2D(Point2D(2, 3), Point2D(3, 5))
>>> L.points
(Point2D(2, 3), Point2D(3, 5))
>>> L.equation()
-2*x + y + 1
>>> L.coefficients
(-2, 1, 1)

使用关键字 slope 实例化：

>>> Line(Point(0, 0), slope=0)
Line2D(Point2D(0, 0), Point2D(1, 0))

用另一个线性对象实例化

>>> s = Segment((0, 0), (0, 1))
>>> Line(s).equation()
x

property coefficients¶

系数 (\(a\), \(b\), \(c\)) 用于 \(ax + by + c = 0\)。

参见

sympy.geometry.line.Line2D.equation

示例

>>> from sympy import Point, Line
>>> from sympy.abc import x, y
>>> p1, p2 = Point(0, 0), Point(5, 3)
>>> l = Line(p1, p2)
>>> l.coefficients
(-3, 5, 0)

>>> p3 = Point(x, y)
>>> l2 = Line(p1, p3)
>>> l2.coefficients
(-y, x, 0)

equation(x='x', y='y')[源代码][源代码]¶

直线的方程式：ax + by + c。

参数:

xstr, 可选: 用于x轴的名称，默认值为’x’。
ystr, 可选: 用于 y 轴的名称，默认值为 ‘y’。

返回:

方程SymPy 表达式

参见

sympy.geometry.line.Line2D.coefficients

示例

>>> from sympy import Point, Line
>>> p1, p2 = Point(1, 0), Point(5, 3)
>>> l1 = Line(p1, p2)
>>> l1.equation()
-3*x + 4*y + 3

class sympy.geometry.line.Ray2D(p1, pt=None, angle=None, **kwargs)[源代码][源代码]¶

一条射线是空间中的一条半线，具有一个源点和方向。

参数:

p1点: Ray 的源代码
p2点值或弧度值: 这一点决定了光线传播的方向。如果给定的是角度，则以弧度解释，正方向为逆时针。

属性:

source: 光线发出的点。
xdirection: 射线的 x 方向。
ydirection: 射线的 y 方向。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`closing_angle`(r2)	返回 r2 必须旋转的角度，使其与 r1 朝向相同的方向。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	其他几何实体是否包含在此射线中？
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`distance`(other)	找到光线与点之间的最短距离。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`equals`(other)	如果 self 和 other 是相同的数学实体，则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`plot_interval`([parameter])	Ray 默认几何图的绘图间隔。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

sympy.geometry.point.Point, Line

示例

>>> from sympy import Point, pi, Ray
>>> r = Ray(Point(2, 3), Point(3, 5))
>>> r
Ray2D(Point2D(2, 3), Point2D(3, 5))
>>> r.points
(Point2D(2, 3), Point2D(3, 5))
>>> r.source
Point2D(2, 3)
>>> r.xdirection
oo
>>> r.ydirection
oo
>>> r.slope
2
>>> Ray(Point(0, 0), angle=pi/4).slope
1

closing_angle(r2)[源代码][源代码]¶

返回 r2 必须旋转的角度，使其与 r1 朝向相同的方向。

参数:

r1Ray2D
r2Ray2D

返回:

角度弧度角（逆时针角度为正）

参见

LinearEntity.angle_between

示例

>>> from sympy import Ray, pi
>>> r1 = Ray((0, 0), (1, 0))
>>> r2 = r1.rotate(-pi/2)
>>> angle = r1.closing_angle(r2); angle
pi/2
>>> r2.rotate(angle).direction.unit == r1.direction.unit
True
>>> r2.closing_angle(r1)
-pi/2

property xdirection¶

射线的 x 方向。

如果射线指向正x方向则为正无穷大，如果射线指向负x方向则为负无穷大，如果射线是垂直的则为0。

参见

ydirection

示例

>>> from sympy import Point, Ray
>>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, -1)
>>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
>>> r1.xdirection
oo
>>> r2.xdirection
0

property ydirection¶

射线的 y 方向。

如果射线指向正y方向则为正无穷大，如果射线指向负y方向则为负无穷大，如果射线是水平的则为0。

参见

xdirection

示例

>>> from sympy import Point, Ray
>>> p1, p2, p3 = Point(0, 0), Point(-1, -1), Point(-1, 0)
>>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
>>> r1.ydirection
-oo
>>> r2.ydirection
0

class sympy.geometry.line.Segment2D(p1, p2, **kwargs)[源代码][源代码]¶

二维空间中的一条线段。

参数:

p1点
p2点

属性:

length数字或 SymPy 表达式: 线段的长度。
midpoint点: 线段的中点。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	另一个 GeometryEntity 是否包含在此线段内？
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`distance`(other)	找到线段和点之间的最短距离。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`equals`(other)	如果 self 和 other 是相同的数学实体，则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_bisector`([p])	这条线段的垂直平分线。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`plot_interval`([parameter])	默认几何图形的线段的绘图间隔给出了在绘图中将生成完整线段的值。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

sympy.geometry.point.Point, Line

示例

>>> from sympy import Point, Segment
>>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
Segment2D(Point2D(1, 0), Point2D(1, 1))
>>> s = Segment(Point(4, 3), Point(1, 1)); s
Segment2D(Point2D(4, 3), Point2D(1, 1))
>>> s.points
(Point2D(4, 3), Point2D(1, 1))
>>> s.slope
2/3
>>> s.length
sqrt(13)
>>> s.midpoint
Point2D(5/2, 2)

class sympy.geometry.line.LinearEntity3D(p1, p2, **kwargs)[源代码][源代码]¶

所有线性实体（线、射线和线段）在三维欧几里得空间中的基类。

属性:

p1: 线性实体的第一个定义点。
p2: 线性实体的第二个定义点。
direction_ratio: 三维空间中给定直线的方向比。
direction_cosine: 给定三维直线的归一化方向比。
points: 用于定义此线性实体的两个点。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	子类应实现此方法，如果 other 在 self 的边界上，则应返回 True；如果不在 self 的边界上，则应返回 False；如果无法确定，则应返回 None。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
等于
is_hypergeometric

注释

这是一个基类，不打算被实例化。

property direction_cosine¶

给定三维直线的归一化方向比。

参见

sympy.geometry.line.Line3D.equation

示例

>>> from sympy import Point3D, Line3D
>>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
>>> l = Line3D(p1, p2)
>>> l.direction_cosine
[sqrt(35)/7, 3*sqrt(35)/35, sqrt(35)/35]
>>> sum(i**2 for i in _)
1

property direction_ratio¶

三维空间中给定直线的方向比。

参见

sympy.geometry.line.Line3D.equation

示例

>>> from sympy import Point3D, Line3D
>>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
>>> l = Line3D(p1, p2)
>>> l.direction_ratio
[5, 3, 1]

class sympy.geometry.line.Line3D(p1, pt=None, direction_ratio=(), **kwargs)[源代码][源代码]¶

空间中的无限三维直线。

一条线可以通过两个不同的点或一个点和使用关键字 \(direction_ratio\) 定义的方向比来声明。

参数:

p1Point3D
ptPoint3D
direction_ratio列表

属性:

args: 返回 ‘self’ 的参数元组。
assumptions0: 返回对象 \(type\) 假设。
boundary: 一个集合的边界或前沿。
bounds: 返回一个元组 (xmin, ymin, xmax, ymax)，表示几何图形的边界矩形。
canonical_variables: 返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。
closure: 返回集合闭包的属性方法。
direction: LinearEntity 的方向向量。
direction_cosine: 给定三维直线的归一化方向比。
direction_ratio: 三维空间中给定直线的方向比。
expr_free_symbols
free_symbols: 从自身的原子中返回那些自由符号。
func: 表达式中的顶级函数。
inf: self 的下确界。
interior: 返回集合内部的属性方法。
is_Complement
is_EmptySet
is_Intersection
is_UniversalSet
is_algebraic
is_antihermitian
is_closed: 一个检查集合是否闭合的属性方法。
is_commutative
is_comparable: 如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。
is_complex
is_composite
is_empty
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_finite_set
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_odd
is_open: 检查集合是否为开集的属性方法。
is_polar
is_positive
is_prime
is_rational
is_real
is_transcendental
is_zero
kind: 集合的种类
length: 线条的长度。
measure: self 的 (勒贝格) 测度
p1: 线性实体的第一个定义点。
p2: 线性实体的第二个定义点。
points: 用于定义此线性实体的两个点。
sup: self 的上确界。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	如果 \(other\) 在这条线上，则返回 True，否则返回 False。
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`distance`(other)	找到直线与另一个对象之间的最短距离。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`equals`(other)	如果 self 和 other 是相同的数学实体，则返回 True。
`equation`([x, y, z])	返回定义三维空间中直线的方程。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`plot_interval`([parameter])	默认几何线条图的绘图间隔。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

sympy.geometry.point.Point3D
sympy.geometry.line.Line
sympy.geometry.line.Line2D

示例

>>> from sympy import Line3D, Point3D
>>> L = Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
>>> L
Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
>>> L.points
(Point3D(2, 3, 4), Point3D(3, 5, 1))

distance(other)[源代码][源代码]¶

找到直线与另一个对象之间的最短距离。

参数:

Point3D, Line3D, Plane, tuple, list

返回:

距离

注释

此方法仅接受3D实体作为其参数

元组和列表被转换为 Point3D，因此长度必须为 3、2 或 1。

如果 \(other\) 不是指定类之一（Point3D、Line3D 或 Plane）的实例，则会引发 NotImplementedError。

示例

>>> from sympy.geometry import Line3D
>>> l1 = Line3D((0, 0, 0), (0, 0, 1))
>>> l2 = Line3D((0, 1, 0), (1, 1, 1))
>>> l1.distance(l2)
1

计算出的距离也可能是符号化的：

>>> from sympy.abc import x, y
>>> l1 = Line3D((0, 0, 0), (0, 0, 1))
>>> l2 = Line3D((0, x, 0), (y, x, 1))
>>> l1.distance(l2)
Abs(x*y)/Abs(sqrt(y**2))

equation(x='x', y='y', z='z')[源代码][源代码]¶

返回定义三维空间中直线的方程。

参数:

xstr, 可选: 用于x轴的名称，默认值为’x’。
ystr, 可选: 用于 y 轴的名称，默认值为 ‘y’。
zstr, 可选: 用于z轴的名称，默认值为’z’。

返回:

方程联立方程组

示例

>>> from sympy import Point3D, Line3D, solve
>>> from sympy.abc import x, y, z
>>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 0)
>>> l1 = Line3D(p1, p2)
>>> eq = l1.equation(x, y, z); eq
(-3*x + 4*y + 3, z)
>>> solve(eq.subs(z, 0), (x, y, z))
{x: 4*y/3 + 1}

class sympy.geometry.line.Ray3D(p1, pt=None, direction_ratio=(), **kwargs)[源代码][源代码]¶

一条射线是空间中的一条半线，具有一个源点和方向。

参数:

p1Point3D: Ray 的源代码
p2点或方向向量
direction_ratio: 确定光线传播的方向。

属性:

source: 光线发出的点。
xdirection: 射线的 x 方向。
ydirection: 射线的 y 方向。
zdirection: 射线的z方向。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	其他几何实体是否包含在此射线中？
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`distance`(other)	找到光线与点之间的最短距离。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`equals`(other)	如果 self 和 other 是相同的数学实体，则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`plot_interval`([parameter])	Ray 默认几何图的绘图间隔。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

sympy.geometry.point.Point3D, Line3D

示例

>>> from sympy import Point3D, Ray3D
>>> r = Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
>>> r
Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
>>> r.points
(Point3D(2, 3, 4), Point3D(3, 5, 0))
>>> r.source
Point3D(2, 3, 4)
>>> r.xdirection
oo
>>> r.ydirection
oo
>>> r.direction_ratio
[1, 2, -4]

property xdirection¶

射线的 x 方向。

如果射线指向正x方向则为正无穷大，如果射线指向负x方向则为负无穷大，如果射线是垂直的则为0。

参见

ydirection

示例

>>> from sympy import Point3D, Ray3D
>>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, -1, 0)
>>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
>>> r1.xdirection
oo
>>> r2.xdirection
0

property ydirection¶

射线的 y 方向。

如果射线指向正y方向则为正无穷大，如果射线指向负y方向则为负无穷大，如果射线是水平的则为0。

参见

xdirection

示例

>>> from sympy import Point3D, Ray3D
>>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
>>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
>>> r1.ydirection
-oo
>>> r2.ydirection
0

property zdirection¶

射线的z方向。

如果射线指向正z方向则为正无穷大，如果射线指向负z方向则为负无穷大，如果射线水平则为0。

参见

xdirection

示例

>>> from sympy import Point3D, Ray3D
>>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
>>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
>>> r1.ydirection
-oo
>>> r2.ydirection
0
>>> r2.zdirection
0

class sympy.geometry.line.Segment3D(p1, p2, **kwargs)[源代码][源代码]¶

三维空间中的一条线段。

参数:

p1Point3D
p2Point3D

属性:

length数字或 SymPy 表达式: 线段的长度。
midpointPoint3D: 线段的中点。

方法

`angle_between`(l2)	返回由从原点发出的射线形成的非反射角，这些射线的方向与线性实体的方向向量相同。
`arbitrary_point`([parameter])	线上的一个参数化点。
`are_concurrent`(*lines)	一系列线性实体是并发的吗？
`as_content_primitive`([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
`as_dummy`()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
`atoms`(*types)	返回构成当前对象的原子。
`bisectors`(other)	返回通过自身和其他对象在同一平面内交点的垂直线。
`class_key`()	类的好顺序。
`compare`(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
`complement`(universe)	相对于给定全集的 'self' 的补集。
`contains`(other)	另一个 GeometryEntity 是否包含在此线段内？
`count`(query)	计算匹配的子表达式的数量。
`count_ops`([visual])	用于返回操作计数的 count_ops 的包装器。
`distance`(other)	找到线段和点之间的最短距离。
`doit`(**hints)	评估默认情况下不评估的对象，如极限、积分、求和和乘积。
`dummy_eq`(other[, symbol])	比较两个表达式并处理哑符号。
`encloses`(o)	如果 o 在 self 的边界内（不在边界上或外部），则返回 True。
`equals`(other)	如果 self 和 other 是相同的数学实体，则返回 True。
`evalf`([n, subs, maxn, chop, strict, quad, ...])	将给定的公式计算到 n 位精度。
`find`(query[, group])	查找所有匹配查询的子表达式。
`fromiter`(args, **assumptions)	从可迭代对象创建一个新对象。
`has`(*patterns)	测试是否有任何子表达式匹配任何模式。
`has_free`(*patterns)	如果 self 包含对象 `x` 作为自由表达式，则返回 True，否则返回 False。
`has_xfree`(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
`intersect`(other)	返回 'self' 和 'other' 的交集。
`intersection`(other)	与另一个几何实体的交点。
`is_disjoint`(other)	如果 `self` 和 `other` 不相交，则返回 True。
`is_parallel`(l2)	两条线性实体是平行的吗？
`is_perpendicular`(l2)	两条线性实体是垂直的吗？
`is_proper_subset`(other)	如果 `self` 是 `other` 的真子集，则返回 True。
`is_proper_superset`(other)	如果 `self` 是 `other` 的真超集，则返回 True。
`is_same`(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
`is_similar`(other)	如果 self 和 other 在同一行中，则返回 True。
`is_subset`(other)	如果 `self` 是 `other` 的子集，则返回 True。
`is_superset`(other)	如果 `self` 是 `other` 的超集，则返回 True。
`isdisjoint`(other)	别名 `is_disjoint()`
`issubset`(other)	别名为 `is_subset()`
`issuperset`(other)	别名 `is_superset()`
`match`(pattern[, old])	模式匹配。
`matches`(expr[, repl_dict, old])	用于 match() 的辅助方法，用于在 self 中的通配符符号与 expr 中的表达式之间寻找匹配。
`n`([n, subs, maxn, chop, strict, quad, verbose])	将给定的公式计算到 n 位精度。
`parallel_line`(p)	创建一条与该线性实体平行并通过点 \(p\) 的新线。
`parameter_value`(other, t)	返回与给定点对应的参数。
`perpendicular_bisector`([p])	这条线段的垂直平分线。
`perpendicular_line`(p)	创建一条垂直于该线性实体的新线，该线通过点 \(p\)。
`perpendicular_segment`(p)	从 \(p\) 点创建一条垂直于该线的线段。
`plot_interval`([parameter])	默认几何图形的线段的绘图间隔给出了在绘图中将生成完整线段的值。
`powerset`()	找到 `self` 的幂集。
`projection`(other)	将一个点、线、射线或线段投影到这个线性实体上。
`random_point`([seed])	线性实体上的一个随机点。
`rcall`(*args)	通过表达式树递归应用于参数。
`refine`([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
`reflect`(line)	反映一个对象穿过一条线。
`replace`(query, value[, map, simultaneous, exact])	将 `self` 中匹配的子表达式替换为 `value`。
`rewrite`(*args[, deep])	使用定义的规则重写 self。
`rotate`(angle[, pt])	围绕点 `pt` 逆时针旋转 `angle` 弧度。
`scale`([x, y, pt])	通过将 x,y 坐标乘以 x 和 y 来缩放对象。
`simplify`(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
`smallest_angle_between`(l2)	返回包含线性实体的直线相交形成的最小角度。
`sort_key`([order])	返回一个排序键。
`subs`(args, *kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
`symmetric_difference`(other)	返回 `self` 和 `other` 的对称差集。
`translate`([x, y])	通过将 x 和 y 值添加到 x,y 坐标来移动对象。
`union`(other)	返回 `self` 和 `other` 的并集。
`xreplace`(rule)	替换表达式中对象的出现。

复制
could_extract_minus_sign
is_hypergeometric

参见

sympy.geometry.point.Point3D, Line3D

示例

>>> from sympy import Point3D, Segment3D
>>> Segment3D((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
>>> s = Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7)); s
Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
>>> s.points
(Point3D(4, 3, 9), Point3D(1, 1, 7))
>>> s.length
sqrt(17)
>>> s.midpoint
Point3D(5/2, 2, 8)