元素#

作者：

  • David Harvey（2006-10-16）：将交换代数元素更改为派生自交换环元素而不是代数元素

  • David Harvey（2006年10月29日）：新算术体系结构

  • 威廉·斯坦因（2006-11）：算术架构——推动它直至完成。

  • Gonzalo Tornaria（2007-06）：强制的递归基扩展很多测试

  • Robert Bradshaw（2007-2010）：算术运算符和强制

  • Maarten Derickx（2010-07）：为is_square和sqrt添加了架构

  • Jeroen Demeyer（2016-08）：将所有胁迫转移到基类元素，请参阅github发行号20767

抽象元素类层次结构#

这是抽象类层次结构，也就是说，这些都是抽象基类。

Sage对象
元素
模块元素
环形元件
换向环元件
IntegralDomainElement集成域元素
Dedekind域元素
PrincipalIdealDomainElement（主体理想域元素）
欧几里得域元素
FieldElement（字段元素）
交换代数元
表达式
代数元素
矩阵
无限元素
添加组元素
矢量

单体元素
乘法组元素
具有缓存方法的元素

如何定义新元素类#

元素通常定义方法_新c例如。，

cdef公司 _新c(自己, 定义 数据):
    cdef公司 自由模块元素_通用_含义 x个
    x个 = 自由模块元素_通用_含义.__新__(自由模块元素_通用_含义)
    x个._父母 = 自己._父母
    x个._条目 = v（v）

通过定义数据快速创建新的同级具有假定属性。

元素的算术#

Sage有一个特殊的系统来处理Sage上的算术运算元素（即元素)，尤其是使用胁迫 模型。我们在这里描述了必须遵守的规则后面跟着算术实现器和调用程序。

为不耐烦的人做一个简短的总结#

对任何元素子类，重写定义 _add_（自我， 其他）方法，而不是通常的Python__添加__ 特殊方法.在_add_（自我， 其他），你可以假设自己和其他有相同的父母。

如果在给定的类别\（C\），则可以将此方法放入C.元素方法.

写作时赛马拉松代码，_添加_应为cpdef方法：cpdef（cpdef） _add_（自我， 其他）.

当使用两个具有不同父元素的元素进行算术时，这个胁迫 模型负责将它们“强制”到公共父级并对胁迫元素。

更详细的算术#

该系统的目的是提供（1）一个高效的呼叫协议来自Python和Cython，（2）跨Sage的统一强制语义，（3） 易用性，（4）代码的可读性。

我们将以加法为例；所有其他操作符都是类似的。有两个相关的函数，名称不同（单下划线与双下划线）。

  • def元素__add__（左，右）

    当二进制“+”遇到运算符。它假设至少有一个参数是一个元素.

    它有一个快速的途径来处理最常见的情况参数具有相同的父级。否则，它使用强制模型来计算如何使它们具有相同的父级。这个强制模型然后添加强制元素（技术上，它调用操作员添加). 请注意，强制的结果不是必需的成为圣人元素，它可以是普通的Python类型。

    注意，尽管此函数声明为定义，它没有具有与Python函数相关的常见开销（为来电者或为__添加__自身）。这是因为Python已针对此类特殊功能优化了呼叫协议。

  • def元素_add_（自身，其他）

    这是您应该重写以实现添加的函数在的子类中元素.

    此函数的两个参数保证具有相同的起源，但不一定是相同的Python类型。

    实施时_添加_在Cython扩展类型中，使用cpdef（cpdef） _添加_而不是定义 _添加_.

    在Cython代码中，如果您想添加两个元素，并且您知道他们的父母是一样的，我们鼓励你这样称呼他们直接使用函数，而不是使用x个 + 年。这仅在以下情况下有效Cython知道左边的参数是元素。你可以始终显式强制转换：（＜元素＞x）_加_（y）来强制执行。在普通Python中，x个 + 年总是加二的最快方法元素，因为特殊的方法__添加__已优化与常规方法不同_添加_.

参数名称的差异(左边， 正确的与自我， 其他)是故意的：自己保证是定义方法的类的实例。在Cython，我们知道至少有一个左边或正确的是类的实例但我们不知道哪一个是先验的。

Powering是一个特例：首先pow（）不支持。其次，强制模型检查是否指数看起来像一个整数。如果是，函数_电源_ int被调用。如果指数不是整数，则强制参数给共同的父母和_功率_被调用。所以，如果你的类型只有支持幂为整数指数，您应该只实现_电源_ int。如果要支持任意供电，请同时实现_功率_和_电源_ int.

对于加法、乘法和幂运算（不适用于其他运算符），使用C进行操作有一条快速路径长的例如，实施cdef公司 _add_long（自身， 长的 n）使用优化的代码自己 + n个。加法和乘法假定为可交换，因此也需要n个 + 自己或n个 * 自己.从Cython代码中，您也可以调用_添加长度（_L）或_多个长度（_L）直接。这是一个严格的优化：有一个默认值实现返回到通用算术函数。

示例#

我们需要一些起源使用：

圣人：从 sage.结构.家长 进口 起源
圣人：班 示例父级(起源):
....:    定义 __初始化__(自己, 名称, **千瓦时):
....:        起源.__初始化__(自己, **千瓦时)
....:        自己.重命名(名称)

我们从一个非常基本的Python类实现示例开始_添加_:

圣人：从 sage.结构.元件 进口 元素
圣人：班 我的元素(元素):
....:    定义 _添加_(自己, 其他):
....:        返回 42
圣人：第页 = 示例父级(“一些家长”)
圣人：x个 = 我的元素(第页)
圣人：x个 + x个
42

当涉及到两个不同的父母时，这不再有效，因为没有强迫：

圣人：q个 = 示例父级(“其他家长”)
圣人：年 = 我的元素(q个)
圣人：x个 + 年
回溯（最近一次调用）：
...
TypeError:不支持+：“Some parent”和“Other parent”的操作数父级

如果_添加_未定义，则引发错误消息，参考父母：

圣人：x个 = 元素(第页)
圣人：x个._添加_(x个)
回溯（最近一次调用）：
...
属性错误：“sage.structure.element”。元素“object没有属性”_add_“。。。
圣人：x个 + x个
回溯（最近一次调用）：
...
TypeError:不支持+：“Some parent”和“Some parent”的操作数父级
圣人：年 = 元素(q个)
圣人：x个 + 年
回溯（最近一次调用）：
...
TypeError:不支持+：“Some parent”和“Other parent”的操作数父级

我们还可以在类别中通用实现算术：

圣人：班 我的类别(类别):
....:    定义 超类别（_C）(自己):
....:        返回 [集合()]
....:    班 元素方法:
....:        定义 _添加_(自己, 其他):
....:            返回 42
圣人：第页 = 示例父级(“我的类别中的家长”, 类别=我的类别())
圣人：x个 = 元素(第页)
圣人：x个 + x个
42

实施细节#

实现上述功能实际上需要一些魔法。休闲调用方和实现方可以安全地忽略它，但以下是好奇者的细节。

要实现快速运算，Cython中的快速路径至关重要呼叫_添加_Cython对象的方法。所以我们想宣布_添加_作为一个cpdef（cpdef）类的方法元素.但请记住，抽象类即将到来从后面的类别元素在方法分辨率中顺序（如果是Cython，则为假方法解析顺序类）。因此，任何_添加_在这样一个抽象类原则上会被元素_添加_.这可以通过定义元素_添加_作为一个cdef公司而不是cpdef（cpdef）方法。子类中的具体实现应该是cpdef（cpdef）或定义方法。

现在让我们看看评估后会发生什么x个 + 年什么时候x个和年是未实现的类的实例_添加_但在哪里_添加_在类别中实现。第一，x.__添加__（y）被调用，其中__添加__已实现在里面元素.假设x个和年有同一个父母，Cython打电话给x.日期（y）将完成。后者用于触发Python级别的调用x.日期（y）这将如愿以偿。

如果Python代码调用x.日期（y）直接，元素_添加_将不可见，方法查找将继续执行MRO并找到_添加_方法。

班 sage.结构.元素。添加组元素#

基础：模块元素

加法组的泛型元素。

秩序()#

返回元素的加法顺序

班 sage.结构.元素。代数元素#

基础：环形元件

班 sage.结构.元素。交换代数元#

基础：换向环元件

班 sage.结构.元素。换向环元件#

基础：环形元件

交换环元素的基类。

划分(x个)#

返回真的如果自己除以x。

示例：

圣人：P（P）.<x个> = 多项式环(QQ（QQ）)
圣人：x个.划分(x个^2)
真的
圣人：x个.划分(x个^2 + 2)
False（错误）
圣人：(x个^2 + 2).划分(x个)
False（错误）
圣人：P（P）.<x个> = 多项式环(兹)
圣人：x个.划分(x个^2)
真的
圣人：x个.划分(x个^2 + 2)
False（错误）
圣人：(x个^2 + 2).划分(x个)
False（错误）

github问题#5347已修复：

圣人：K（K） = GF公司(7)
圣人：K（K）(三).划分(1)
真的
圣人：K（K）(三).划分(K（K）(1))
真的

圣人：R（右） = 整数(128)
圣人：R（右）(0).划分(1)
False（错误）
圣人：R（右）(0).划分(0)
真的
圣人：R（右）(0).划分(R（右）(0))
真的
圣人：R（右）(1).划分(0)
真的
圣人：R（右）(121).划分(R（右）(120))
真的
圣人：R（右）(120).划分(R（右）(121))
False（错误）

如果x个与具有不同的父级自己，他们首先被迫如果可能的话，共同的父母。如果此强制失败，则返回类型错误。此修复程序github问题#5759.

圣人：Zmod公司(2)(0).划分(Zmod公司(2)(0))
真的
圣人：Zmod公司(2)(0).划分(Zmod公司(2)(1))
False（错误）
圣人：Zmod公司(5)(1).划分(Zmod公司(2)(1))
回溯（最近一次调用）：
...
TypeError:具有父级的对象没有公共规范父级：
“模5整数环”和“模2整数环”
圣人：Zmod公司(35)(4).划分(Zmod公司(7)(1))
真的
圣人：Zmod公司(35)(7).划分(Zmod公司(7)(1))
False（错误）
逆模态(我)#

返回的倒数自己模理想\（I），如果定义了，即，如果\（I）和自己共同产生单位理想。

示例：

圣人：#需要sage.rings.finite_ring
圣人：F类 = GF公司(25)
圣人：x个 = F类.消息()
圣人：z（z） = F类.零()
圣人：x个.逆模态(F类.理想的(z（z）))
2*z2+3
圣人：x个.逆模态(F类.理想的(1))
1
圣人：z（z）.逆模态(F类.理想的(1))
1
圣人：z（z）.逆模态(F类.理想的(z（z）))
回溯（最近一次调用）：
...
ValueError:真理想的元素没有理想的反模
平方（_S）(根=False（错误）)#

无论环形元件是否返回自己是一个正方形。

如果可选参数根为真的，然后也返回平方根（或无，如果不是正方形）。

输入：

  • 根-是否也返回正方形root（默认值：False（错误）)

输出：

  • 布尔–无论是否为正方形

  • 对象–（可选）实际平方根，如果找到，并且无否则。

示例：

圣人：R（右）.<x个> = 多项式环(QQ（QQ）)
圣人：（f） = 12*(x个+1)^2 * (x个+三)^2
圣人：（f）.平方（_S）()
False（错误）
圣人：（f）.平方（_S）(根=真的)
（错误，无）
圣人：小时 = （f）/三
圣人：小时.平方（_S）()
真的
圣人：小时.平方（_S）(根=真的)
（正确，2*x^2+8*x+6）

注释

这是通用的is_square实现交换环元件。它的实施是为了提高未实现错误。这里的函数定义是为了显示预期的功能并提供框架。

国防部(我)#

退回代表自己模理想I（或理想如果I不是理想，则由I的元素生成。）

示例：整数理想的5模缩减：

圣人：n个 = 5
圣人：n个.国防部(三*兹)
2

由3生成的理想模量5的缩减：

圣人：n个.国防部(三)
2

将5模缩减为由15和6生成的理想，即\((3)\).

圣人：n个.国防部([15,6])
2

示例：单变量多项式

圣人：R（右）.<x个> = 多项式环(QQ（QQ）)
圣人：（f） = x个^三 + x个 + 1
圣人：（f）.国防部(x个 + 1)
-1

减少\（\ZZ[x]\）:

圣人：R（右）.<x个> = 多项式环(兹)
圣人：（f） = x个^三 + x个 + 1
圣人：（f）.国防部(x个 + 1)
-1

当给定环的实现很少时，那么国防部可以简单地返回\（f）.

示例：多元多项式我们将二元多项式简化为模多项式和理想：

圣人：R（右）.<x个,年,z（z）> = 多项式环(QQ（QQ）, 三)
圣人：(x个^2 + 年^2 + z（z）^2).国防部(x个 + 年 + z（z）)                                      #需要sage.libs.singular
2*y^2+2*y*z+2*z^2

上述注意事项\（x \）被消除。在下一个示例中，二者都\（年\）和\（z）已消除：

圣人：(x个^2 + 年^2 + z（z）^2).国防部( (x个 - 年, 年 - z（z）) )                               #需要sage.libs.singular
3*z^2个
圣人：（f） = (x个^2 + 年^2 + z（z）^2)^2; （f）
x^4+2*x^2*y^2+y^4+2*x^2*z^2+2*y^2*z^2+z^4
圣人：（f）.国防部( (x个 - 年, 年 - z（z）) )                                               #需要sage.libs.singular
9*z^4个

在这个例子中\（年\）已消除：

圣人：(x个^2 + 年^2 + z（z）^2).国防部( (x个^三, 年 - z（z）) )                                 #需要sage.libs.singular
x^2+2*z^2
平方英尺(延伸=真的,全部的=False（错误）,名称=无)#

计算平方根。

输入：

  • 延伸–布尔值（默认值：真的); 是否制作戒指

    包含平方根的扩展如果自己不是正方形

  • 全部的–布尔值（默认值：False（错误）); 是否返回的列表

    全部平方根或仅平方根

  • 名称–当extend=真和自己不是

    正方形。这将是扩展的生成器的名称。

输出：

  • 如果all=假，平方根；如果出现以下情况，则引发错误extend=假和自己不是正方形

  • 如果all=真，所有平方根的列表（如果为空extend=假和自己不是正方形）

算法：

它使用is_square（根=真）工作中最困难的部分，剩下的部分只是包装器代码。

示例：

圣人：#需要sage.libs.pari
圣人：R（右）.<x个> = 兹[]
圣人：(x个^2).平方英尺()
x个
圣人：（f） = x个^2 - 4*x个 + 4; （f）.平方英尺(全部的=真的)
[x-2，-x+2]
圣人：平方英尺 = x个.平方英尺(名称=“y”); 平方英尺
年
圣人：平方英尺^2
x个
圣人：x个.平方英尺(全部的=真实的, 名称=“y”)
[y，-y]
圣人：x个.平方英尺(延伸=False（错误）, 全部的=真的)
[]
圣人：x个.平方英尺()
回溯（最近一次调用）：
...
TypeError:多项式不是正方形。您必须指定名称
使用默认扩展时的平方根=True
圣人：x个.平方英尺(延伸=False（错误）)
回溯（最近一次调用）：
...
ValueError:尝试在extend=False的情况下取非平方x的平方根
班 sage.结构.元素。Dedekind域元素#

基础：IntegralDomainElement集成域元素

班 sage.结构.元素。元素#

基础：Sage对象

结构的泛型元素。所有其他类型的元素(环形元件,模块元素等）从该类型派生。

子类型必须调用__初始化_（）设置_父母，或可能设置_父母如果那样会更有效率的话。

_richcmp公司_(左边,正确的,操作)#

具有的元素的富比较的基本默认实现平等的父母。

它按id对进行比较==和!=.调用此默认方法<,<=,>或>=将返回未实施.

示例：

圣人：从 sage.结构.家长 进口 起源
圣人：从 sage.结构.元件 进口 元素
圣人：P（P） = 起源()
圣人：第1页 = 元素(P（P）); 第2页 = 元素(P（P）)
圣人：第1页 == 第1页    #间接文档测试
真的
圣人：第1页 == 第2页    #间接文档测试
False（错误）
圣人：第1页 < 第2页     #间接文档测试
回溯（最近一次调用）：
...
TypeError:“sage.structure.element”的实例之间不支持“<”。元素和sage.structure.Element。元素'

我们现在创建一个元素我们定义的类_richcmp公司_并检查比较是否有效：

圣人：#需要sage.misc.cython
圣人：赛马(
....:'''
....:来自sage.structure.richcmp cimport rich_to_tool
....:来自sage.structure.element cimport element
....:cdef类FloatCmp（Element）：
....:cdef浮点x
....:定义__init__（self，float v）：
....:自身.x=v
....:cpdef _richcmp_（self、other、int op）：
....:cdef浮点x1=（<FloatCmp>自身）。x个
....:cdef浮点x2=（＜浮点Cmp＞其他）。x个
....:返回rich_to_bool（op，（x1>x2）-（x1<x2））
....:''')
圣人：一 = 浮动Cmp(1)
圣人：b = 浮动Cmp(2)
圣人：一 <= b, b <= 一
（正确，错误）
__添加__(左边,正确的)#

顶级加法运算符元素调用强制模型。

请参见元素的算术.

示例：

圣人：从 sage.结构.元件 进口 元素
圣人：班 我的元素(元素):
....:    定义 _添加_(自己, 其他):
....:        返回 42
圣人：e（电子） = 我的元素(起源())
圣人：e（电子） + e（电子）
42
__子__(左边,正确的)#

的顶级减法运算符元素调用强制模型。

请参见元素的算术.

示例：

圣人：从 sage.结构.元件 进口 元素
圣人：班 我的元素(元素):
....:    定义 _子_(自己, 其他):
....:        返回 42
圣人：e（电子） = 我的元素(起源())
圣人：e（电子） - e（电子）
42
__否定__()#

的顶级求反运算符元素.

示例：

圣人：从 sage.结构.元件 进口 元素
圣人：班 我的元素(元素):
....:    定义 _否定_(自己):
....:        返回 42
圣人：e（电子） = 我的元素(起源())
圣人：-e（电子）
42
__穆尔__(左边,正确的)#

的顶级乘法运算符元素调用强制模型。

请参见元素的算术.

示例：

圣人：从 sage.结构.元件 进口 元素
圣人：班 我的元素(元素):
....:    定义 _穆尔_(自己, 其他):
....:        返回 42
圣人：e（电子） = 我的元素(起源())
圣人：e（电子） * e（电子）
42
__特鲁迪夫__(左边,正确的)#

顶级真除法运算符元素调用强制模型。

请参见元素的算术.

示例：

圣人：操作人员.特鲁迪夫(2, 三)
2/3
圣人：操作人员.特鲁迪夫(圆周率, 三)                                               #需要圣人符号
1/3*pi
圣人：x个 = 一夫多妻制(QQ（QQ）, “x”)
圣人：K（K）.<我> = 数字字段(x个^2 + 1)                                          #需要sage.rings.number_field
圣人：操作人员.特鲁迪夫(2, K（K）.理想的(我 + 1))                                   #需要sage.rings.number_field
分数理想（-i+1）

圣人：从 sage.结构.元件 进口 元素
圣人：班 我的元素(元素):
....:    定义 _div公司_(自己, 其他):
....:        返回 42
圣人：e（电子） = 我的元素(起源())
圣人：操作人员.特鲁迪夫(e（电子）, e（电子）)
42
__地板__(左边,正确的)#

顶层楼层划分操作员元素调用强制模型。

请参见元素的算术.

示例：

圣人：7 // 三
2
圣人：7 // 整数(三)
2
圣人：整数(7) // 三
2

圣人：从 sage.结构.元件 进口 元素
圣人：班 我的元素(元素):
....:    定义 _地板_(自己, 其他):
....:        返回 42
圣人：e（电子） = 我的元素(起源())
圣人：e（电子） // e（电子）
42
__模块__(左边,正确的)#

顶级模运算符元素调用强制模型。

请参见元素的算术.

示例：

圣人：7 % 三
1
圣人：7 % 整数(三)
1
圣人：整数(7) % 三
1

圣人：从 sage.结构.元件 进口 元素
圣人：班 我的元素(元素):
....:    定义 _模块_(自己, 其他):
....:        返回 42
圣人：e（电子） = 我的元素(起源())
圣人：e（电子） % e（电子）
42
基本扩展（_E）(R（右）)#
底座（_R）()#

返回此元素父元素的基环（如果有意义的话）。

类别()#
为零()#

返回真的如果自己等于self.parent（）（0）.

默认实现是回退到不 自我__布尔__.

警告

不要在子类中重新实现此方法，但实施__布尔__而不是。

n个(前c=无,数字=无,算法=无)#

的别名数字_近似（）.

示例：

圣人：(2/三).n个()                                                             #需要sage.rings.real_mpfr
0.666666666666667
数字_近似值(前c=无,数字=无,算法=无)#

返回的数值近似值自己具有前c位（或十进制数字)精度。

不能保证结果的准确性。

输入：

  • 前c–精度（位）

  • 数字–十进制数字的精度（仅在以下情况下使用前c未给出）

  • 算法–使用哪种算法来计算近似（接受的算法取决于对象）

如果两者都不存在前c也不是数字默认值为精度为53位（约16位）。

示例：

圣人：(2/三).数字_近似值()                                              #需要sage.rings.real_mpfr
0.666666666666667
圣人：圆周率.n个(数字=10)                                                       #需要圣人符号
3.141592654
圣人：圆周率.n个(前c=20)                                                         #需要圣人符号
3.1416
起源(x个=无)#

返回此元素的父级；或者，如果可选参数x为提供了将x强制为该元素的父元素的结果。

潜艇(输入（_D）=无,**千瓦时)#

在不接触时用给定值替换给定生成器其他发电机。这是一个通用包装__呼叫__.语法旨在与相应的方法兼容用于符号表达式。

输入：

  • 输入（_D）-（可选）输入字典

  • **千瓦时-命名参数

输出：

  • 如果可以替换，则为new对象，否则为self。

示例：

圣人：x个, 年 = 多项式环(兹,2,“xy”).氏族()
圣人：（f） = x个^2 + 年 + x个^2*年^2 + 5
圣人：（f）((5,年))
25*y^2+y+30
圣人：（f）.潜艇({x个:5})
25*y^2+y+30
圣人：（f）.潜艇(x个=5)
25*y^2+y+30
圣人：(1/（f）).潜艇(x个=5)
1/（25*y^2+y+30）
圣人：整数(5).潜艇(x个=4)
5
代替(*参数,**千瓦时)#

这会调用self.subs（）.

示例：

圣人：x个, 年 = 多项式环(兹, 2, “xy”).氏族()
圣人：（f） = x个^2 + 年 + x个^2*年^2 + 5
圣人：（f）((5,年))
25*y^2+y+30
圣人：（f）.代替({x个: 5})
25*y^2+y+30
圣人：（f）.代替(x个=5)
25*y^2+y+30
圣人：(1/（f）).代替(x个=5)
1/（25*y^2+y+30）
圣人：整数(5).代替(x个=4)
5
班 sage.结构.元素。具有缓存方法的元素#

基础：元素

完全支持缓存方法的元素类。

注：

这个缓存方法装饰器提供自动缓存计算结果的方便方法。自github问题#11115，应用于没有可选参数的方法比手写缓存快在Python中，以及没有任何参数的缓存方法（除了自己)实际上比只执行以下操作的Python方法更快返回1。缓存的方法也可以从父级继承或类别的元素类。

然而，只有在支持属性赋值的情况下，这才适用。如果在Cython中编写不接受属性的扩展类赋值，则从该类别继承的缓存方法将为较慢（用于起源)否则缓存将均衡断裂（用于元素).

如果您编写一个元素类，则应使用该类，而不能提供它具有属性赋值，但希望继承缓存方法从类别中选择。在这些条件下，您的类应该继承而不是元素。然后，缓存将工作，但肯定比属性分配慢。懒惰的属性也能工作。

示例：

我们定义了三个元素扩展类。第一个继承自元素，这节课的第二节，第三节简单地说是Python类。我们还定义了一个父类，在Python中，还定义了其元素和父类定义缓存方法的类别。

圣人：#需要sage.misc.cython
圣人：cython代码 = [“来自sage.structure.element cimport element，ElementWithCachedMethod”,
....:    “来自sage.structure.richcmp cimport richcmp”,
....:    “cdef类MyBroken Element（Element）：”,
....:    “cdef公共对象x”,
....:    “定义__init__（自我，P，x）：”,
....:    “自我.x=x”,
....:    “元素.__init__（self，P）”,
....:    “定义__neg__（自身）：”,
....:    “return MyBrokenElement（self.parent（），-self.x）”,
....:    “定义_预览_（自身）：”,
....:    “返回”<%秒>'%秒elf.x“,
....:    “定义__hash__（自身）：”,
....:    “返回散列（self.x）”,
....:    “cpdef _richcmp_（左，右，int op）：”,
....:    “return richcmp（left.x，right.x，op）”,
....:    “定义原始测试（自身）：”,
....:    “返回-自我”,
....:    “cdef类MyElement（ElementWithCachedMethod）：”,
....:    “cdef公共对象x”,
....:    “定义__init__（自我，P，x）：”,
....:    “自我.x=x”,
....:    “元素.__init__（self，P）”,
....:    “定义__neg__（自身）：”,
....:    “return MyElement（self.parent（），-self.x）”,
....:    “定义_预览_（自身）：”,
....:    “返回”<%秒>'%秒elf.x“,
....:    “定义__hash__（自身）：”,
....:    “返回散列（self.x）”,
....:    “cpdef _richcmp_（左，右，int op）：”,
....:    “return richcmp（left.x，right.x，op）”,
....:    “定义原始测试（自身）：”,
....:    “返回-自我”,
....:    “类MyPythonElement（MyBrokenElement）：传递”,
....:    “来自sage.structure.parent cimport parent”,
....:    “cdef类MyParent（父级）：”,
....:    “元素=我的元素”]
圣人：赛马('\n个'.参加(cython代码))
圣人：cython代码 = [“从sage.misc.cachefunc导入cached_method”,
....:    “从sage.misc.cachefunc导入cached_in_parent_method”,
....:    “从sage.categories.category导入类别”,
....:    “从sage.categories.objects导入对象”,
....:    “类MyCategory（类别）：”,
....:    “@cached_method”,
....:    “定义超级类别（自身）：”,
....:    “return[对象（）]”,
....:    “类ElementMethods:”,
....:    “@cached_method”,
....:    “定义元素缓存测试（自身）：”,
....:    “返回-自我”,
....:    “@cached_in_parent_method”,
....:    “定义元素_via_parent_test（自身）：”,
....:    “返回-自我”,
....:    “类ParentMethods:”,
....:    “@cached_method”,
....:    “定义一（自我）：”,
....:    “返回self.element_class（self，1）”,
....:    “@cached_method”,
....:    “def反转（self，x）：”,
....:    “返回-x”]
圣人：赛马('\n个'.参加(cython代码))
圣人：C类 = 我的类别()
圣人：P（P） = 我的父母(类别=C类)
圣人：埃布罗肯 = MyBroken元素(P（P）, 5)
圣人：e（电子） = 我的元素(P（P）, 5)

由继承的缓存方法我的元素作品：

圣人：#需要sage.misc.cython
圣人：e（电子）.元素缓存测试()
<-5>
圣人：e（电子）.元素缓存测试() 是 e（电子）.元素缓存测试()
真的
圣人：e（电子）.元素通过父测试()
<-5>
圣人：e（电子）.元素通过父测试() 是 e（电子）.元素通过父测试()
真的

另一个元素类只能继承在父对象方法中缓存，因为缓存存储在起源。事实上，相等的元素共享缓存，即使它们是不同类型：

圣人：e（电子） == 埃布罗肯                                                              #需要sage.misc.cython
真的
圣人：类型(e（电子）) == 类型(埃布罗肯)                                                  #需要sage.misc.cython
False（错误）
圣人：埃布罗肯.元素通过父测试() 是 e（电子）.元素通过父测试()          #需要sage.misc.cython
真的

然而，另一个继承方法的缓存中断，尽管该方法作为此类工程：

圣人：埃布罗肯.元素缓存测试()                                              #需要sage.misc.cython
<-5>
圣人：埃布罗肯.元素缓存测试() 是 埃布罗肯.元素缓存测试()              #需要sage.misc.cython
False（错误）

自e（电子）和埃布罗肯当我们清空一个元素时，共享缓存它对另一个也是空的：

圣人：b = 埃布罗肯.元素通过父测试()                                     #需要sage.misc.cython
圣人：e（电子）.元素通过父测试.清除缓存（_C）()                                   #需要sage.misc.cython
圣人：b 是 埃布罗肯.元素通过父测试()                                    #需要sage.misc.cython
False（错误）

请注意，缓存仅为不允许属性赋值的元素中断。Python版本的MyBroken元素因此，允许缓存方法：

圣人：epython公司 = MyPython元素(P（P）, 5)                                           #需要sage.misc.cython
圣人：epython公司.元素缓存测试()                                              #需要sage.misc.cython
<-5>
圣人：epython公司.元素缓存测试() 是 epython公司.元素缓存测试()              #需要sage.misc.cython
真的
班 sage.结构.元素。欧几里得域元素#

基础：PrincipalIdealDomainElement（主体理想域元素）

度()#
领先_效率()#
配额（_R）(其他)#
班 sage.结构.元素。表达式#

基础：换向环元件

的抽象基类表达式.

定义此类的目的是isinstance（）测验。不应该这样实例化。

示例：

圣人：isinstance公司(SR公司.变量(“是”), 圣人.结构.要素.表达式)                #需要圣人符号
真的

根据设计，有一个独特的直接子类：

圣人：伦恩(圣人.结构.要素.表达式.__子类__()) <= 1
真的
班 sage.结构.元素。FieldElement（字段元素）#

基础：换向环元件

划分(其他)#

检查是否自己除其他字段元素。

因为这是一个字段，所以所有值都会除以所有其他值，但零不除任何非零值。

示例：

圣人：#需要sage.rings.number_field sage.symbolic
圣人：K（K）.<第3部分> = QQ（QQ）[平方英尺(三)]
圣人：K（K）(0).划分(第3部分)
False（错误）
圣人：第3部分.划分(K（K）(17))
真的
圣人：K（K）(0).划分(K（K）(0))
真的
圣人：第3部分.划分(K（K）(0))
真的
是单位（_U）()#

返回真的如果自己是其父环中的一个单元。

示例：

圣人：一 = 2/三; 一.是单位（_U）()
真的

另一方面，2不是一个单元，因为它的父级是\（\ ZZ \）.

圣人：一 = 2; 一.是单位（_U）()
False（错误）
圣人：起源(一)
整数环

然而，当被视为QQ元素时，a是一个单位：

圣人：一 = QQ（QQ）(2); 一.是单位（_U）()
真的
配额（_R）(正确的)#

返回除法所得的商和余数自己通过正确的。由于此元素位于字段中，因此余数始终为零和商是自我/权利.

班 sage.结构.元素。无限元素#

基础：环形元件

班 sage.结构.元素。IntegralDomainElement集成域元素#

基础：换向环元件

无效（_N）()#
班 sage.结构.元素。矩阵#

基础：模块元素

班 sage.结构.元素。模块元素#

基础：元素

模块的通用元素。

附加订单()#

返回self的加法顺序。

秩序()#

返回self的加法顺序。

班 sage.结构.元素。具有可变性的模块元素#

基础：模块元素

具有可变性的模块的泛型元素。

是不可变的()#

如果此向量是不可变的，即条目不能被更改。

示例：

圣人：v（v） = 矢量(QQ（QQ）[“x，y”], [1..5]); v（v）.是不可变的()                       #需要sage.模块
False（错误）
圣人：v（v）.集合_可变()                                                     #需要sage.模块
圣人：v（v）.是不可变的()                                                      #需要sage.模块
真的
可变（_M）()#

如果此向量是可变的，则返回True，即条目可以是改变。

示例：

圣人：v（v） = 矢量(QQ（QQ）[“x，y”], [1..5]); v（v）.可变（_M）()                         #需要sage.模块
真的
圣人：v（v）.集合_可变()                                                     #需要sage.模块
圣人：v（v）.可变（_M）()                                                        #需要sage.模块
False（错误）
集合_可变()#

使这个向量不可变。此操作无法撤消。

示例：

圣人：#需要sage.模块
圣人：v（v） = 矢量([1..5]); v（v）
(1, 2, 3, 4, 5)
圣人：v（v）[1] = 10
圣人：v（v）.集合_可变()
圣人：v（v）[1] = 10
回溯（最近一次调用）：
...
ValueError：向量是不可变的；请改为更改副本（使用copy（））
班 sage.结构.元素。单体元素#

基础：元素

幺半群的一般元素。

乘法顺序()#

返回self的乘法顺序。

秩序()#

返回self的乘法顺序。

权力(n个)#

返回列表\（[x^0，x^1，\ldot，x^{n-1}]\）.

示例：

圣人：G公司 = 对称组(4)                                                 #需要sage.groups
圣人：克 = G公司([2, 三, 4, 1])                                                   #需要sage.groups
圣人：克.权力(4)                                                           #需要sage.groups
[(), (1,2,3,4), (1,3)(2,4), (1,4,3,2)]
班 sage.结构.元素。乘法组元素#

基础：单体元素

乘法群的泛型元素。

秩序()#

返回self的乘法顺序。

班 sage.结构.元素。PrincipalIdealDomainElement（主体理想域元素）#

基础：Dedekind域元素

gcd公司(正确的)#

返回的最大公约数自己和其他.

生命周期管理(正确的)#

返回的最小公共倍数自己和正确的.

班 sage.结构.元素。环形元件#

基础：模块元素

防抱死制动系统()#

返回的绝对值自己.（这只是调用__防抱死制动系统__方法，因此它等效于abs（）内置功能。）

示例：

圣人：右后(-1).防抱死制动系统()
1
圣人：兹(-1).防抱死制动系统()
1
圣人：科科斯群岛(我).防抱死制动系统()
1
圣人：国防部(-15, 37).防抱死制动系统()
回溯（最近一次调用）：
...
算术错误：未在模n的整数上定义绝对值。
附加订单()#

返回的相加顺序自己.

无效（_N）()#

返回真的如果自己是幂零的，即自己为0。

是一个（_O）()#
是素数（_P）()#

是自己基本要素？

A类首要的元素是非零、非单位元素\（p\）这样，无论何时\（p\）划分\（ab）对一些人来说\（a）和\（b），然后\（p\）划分\（a）或\（p\）划分\（b）.

示例：

对于多项式环，素数与不可约数相同：

圣人：#需要sage.libs.singular
圣人：R（右）.<x个,年> = QQ（QQ）[]
圣人：x个.是素数（_P）()
真的
圣人：(x个^2 + 年^三).是素数（_P）()
真的
圣人：(x个^2 - 年^2).是素数（_P）()
False（错误）
圣人：R（右）(0).是素数（_P）()
False（错误）
圣人：R（右）(2).是素数（_P）()
False（错误）

对于高斯整数：

圣人：#需要sage.rings.number_field
圣人：K（K）.<我> = 象限域(-1)
圣人：邮编 = K（K）.整数环()
圣人：邮编(三).是素数（_P）()
真的
圣人：邮编(5).是素数（_P）()
False（错误）
圣人：邮编(2 + 我).是素数（_P）()
真的
圣人：邮编(0).是素数（_P）()
False（错误）
圣人：邮编(1).是素数（_P）()
False（错误）

在字段中，元素永远不是质数：

圣人：右后(0).是素数（_P）()
False（错误）
圣人：右后(2).是素数（_P）()
False（错误）

对于整数，is_prime（）将质数重新定义为正面：

圣人：(-2).是素数（_P）()
False（错误）
圣人：环形元件.是素数（_P）(-2)                                              #需要sage.libs.pari
真的

同样，数字字段重新定义is_prime（）确定环中的素数整数的：

圣人：#需要sage.rings.number_field
圣人：(1 + 我).是素数（_P）()
真的
圣人：K（K）(5).是素数（_P）()
False（错误）
圣人：K（K）(7).是素数（_P）()
真的
圣人：K（K）(7/13).是素数（_P）()
False（错误）

然而，对于理性，is_prime（） 做遵循环中素元素的一般定义（即总是收益False（错误）)因为理性不是数字字段圣人：

圣人：QQ（QQ）(7).是素数（_P）()
False（错误）
乘法顺序()#

返回的乘法顺序自己，如果自己是一个单位，或提高算术错误否则。

权力(n个)#

返回列表\（[x^0，x^1，\ldot，x^{n-1}]\）.

示例：

圣人：5权力(三)
[1, 5, 25]
班 sage.结构.元素。矢量#

基础：具有可变性的模块元素

sage.结构.元素。bin_op（&O）(x个,年,操作)#
sage.结构.元素。规范的执行(x个,年)#

规范执行（x，y）是在执行之间的算术运算x个和年。它返回一对（z，w）这样的话z（z）来自x个和w个从年通过规范强制和的父母z（z）和w个都是相同的。

示例：

圣人：A类 = 矩阵([[0, 1], [1, 0]])                                              #需要sage.模块
圣人：规范的执行(A类, 1)                                                  #需要sage.模块
(
[0 1]  [1 0]
[1 0], [0 1]
)
sage.结构.元素。胁迫蛋白(方法)#

用于将强制应用于参数，然后调用方法。

考虑类别框架中的父类，\（S\），其元素类公开方法\（binop\）.如果\（a）和\（b）是的元素\（S\），然后\（a.binop（b））行为符合预期。如果\（a）和\（b）不是的元素\（S\）,而是有一个共同的父母\（T\）其元素类也公开\（binop\），我们希望\（a.binop（b））计算\（aa.binop（bb）\）,哪里\（aa=T（a）\）和\（bb=T（b）\）。此装饰器确保了该行为无需以其他方式修改\（binop\）上的元素类\（A\）.

由于将尝试对修饰方法的参数进行强制\（类型错误\）如果在元素。安\（属性错误\）或\（未实现错误\）或类似情况如果存在参数的公共父级，但其元素类，则引发不实现与修饰方法同名的方法。

示例：

稀疏多项式环的使用\（@corece_binop\）在\（gcd\）:

圣人：S公司.<x个> = 多项式环(兹, 稀疏的=真的)
圣人：（f） = x个^2
圣人：克 = x个
圣人：（f）.gcd公司(克)  #间接文档测试
x个
圣人：T型 = 多项式环(QQ（QQ）, 名称=“x”, 稀疏的=真的)
圣人：小时 = 1/2*T型(x个)
圣人：u个 = （f）.gcd公司(小时); u个  #间接文档测试
x个
圣人：u个.起源() == T型
真的

另一个真实的例子：

圣人：R1级 = QQ（QQ）[“x，y”]
圣人：R2级 = QQ（QQ）['x，y，z']
圣人：（f） = R1级(1)
圣人：克 = R1级(2)
圣人：小时 = R2级(1)
圣人：（f）.gcd公司(克)
1
圣人：（f）.gcd公司(克, 算法=“模块化”)
1
圣人：（f）.gcd公司(小时)
1
圣人：（f）.gcd公司(小时, 算法=“模块化”)
1
圣人：小时.gcd公司(（f）)
1
圣人：小时.gcd公司(（f）, “模块化”)
1

我们使用\（@corece_binop\）关于一种方法：

圣人：从 sage.结构.元件 进口 胁迫蛋白
圣人：班 我的理性(理性):
....:    定义 __初始化__(自己,价值):
....:        自己.v（v） = 价值
....:    @胁迫蛋白
....:    定义 测试_add(自己, 其他, 关键字=“z”):
....:        返回 (自己.v（v）, 其他, 关键字)

如果两个参数具有相同的父参数，则直接调用func：

圣人：x个 = 我的理性(1)
圣人：x个.测试_add(1/2)
（1，1/2，‘z’）
圣人：x个.测试_add(1/2, 关键字=三)
(1, 1/2, 3)

传递强制，如果左操作数不是相同的。如果公共父级的元素类没有同名，则引发异常：

圣人：x个.测试_add(2)
（1，2，‘z’）
圣人：x个.测试_add(2, 关键字=三)
(1, 2, 3)
圣人：x个.测试_add(科科斯群岛(2))
回溯（最近一次调用）：
...
属性错误：“sage.rings.complex_mpfr”。“ComplexNumber”对象没有属性“test_add”。。。
sage.结构.元素。强制回溯(倾倒=真的)#

此函数在调试强制错误时非常有用。它会打印强制检测中捕获的所有错误的跟踪。注释该故障被缓存，因此第二次可能会忽略一些错误大约（因为它会记住由于速度原因而不重试失败的路径。

出于性能和缓存原因，异常记录必须在使用此函数之前显式启用。

示例：

圣人：厘米 = 圣人.结构.要素.获取行为模型()
圣人：厘米.记录例外情况()
圣人：1 + 1/5
6/5
圣人：强制回溯()  #应该是空的，因为一切顺利。
圣人：1/5 + GF公司(5).消息()
回溯（最近一次调用）：
...
TypeError:不支持+的操作数父级：
“有理字段”和“大小为5的有限字段”
圣人：强制回溯()
回溯（最近一次调用）：
...
TypeError:具有父级的对象没有公共规范父级：
“有理字段”和“大小为5的有限字段”
sage.结构.元素。获取行为模型()#

返回全局强制模型。

示例：

圣人：进口 sage.结构.元件 作为 e（电子）
圣人：厘米 = e（电子）.获取行为模型()
圣人：厘米
<sage.structure.coerce。位于…>的强制模型对象
圣人：厘米 是 矫顽力模型
真的
sage.结构.元素。有名字的父母(左边,正确的)#

返回真的当且仅当左边和正确的拥有同一父母。

警告

此函数假定至少有一个参数是圣人元素。如果有疑问，请使用较慢的父（左） 是 父（右）而不是。

示例：

圣人：从 sage.结构.元件 进口 有名字的父母
圣人：有名字的父母(1, 三)
真的
圣人：有名字的父母(1, 1/2)
False（错误）
圣人：有名字的父母(缺口(1), 缺口(1/2))                                        #需要sage.libs.gap
真的

这些类型不同，但父级相同：

圣人：一 = RLF公司(2)
圣人：b = 经验(一)
圣人：类型(一)
<... 'sage.rings.real_lazy公司。懒散包装器'>
圣人：类型(b)
<... 'sage.rings.real_lazy公司。LazyNamedUnop'>
圣人：有名字的父母(一, b)
真的
sage.结构.元素。是AdditiveGroupElement(x个)#

返回真的如果x是Additive GroupElement类型。

sage.结构.元素。is_代数元素(x个)#

返回真的如果x是AlgebraElement类型。

sage.结构.元素。is_交换代数元素(x个)#

返回真的如果x是交换代数元素类型。

sage.结构.元素。is_CommutativeRing元素(x个)#

返回真的如果x的类型是CommutativeRingElement。

sage.结构.元素。is_Dedekind域元素(x个)#

返回真的如果x是DedekindDomainElement类型。

sage.结构.元素。是元素（_E）(x个)#

返回真的如果x是Element类型。

示例：

圣人：从 sage.结构.元件 进口 是元素（_E）
圣人：是元素（_E）(2/三)
真的
圣人：是元素（_E）(QQ（QQ）^三)                                                          #需要sage.模块
False（错误）
sage.结构.元素。is_核素域元素(x个)#

返回真的如果x是EuclideanDomainElement类型。

sage.结构.元素。is_Field元素(x个)#

返回真的如果x是FieldElement类型。

sage.结构.元素。is_Infinity元素(x个)#

返回真的如果x是InfinityElement类型。

sage.结构.元素。is_IntegralDomainElement（集成域元素）(x个)#

返回真的如果x是IntegralDomainElement类型。

sage.结构.元素。是矩阵（_M）(x个)#
sage.结构.元素。is_Module元素(x个)#

返回真的如果x是ModuleElement类型。

这甚至比使用isinstance内联更快。

示例：

圣人：从 sage.结构.元件 进口 is_Module元素
圣人：is_Module元素(2/三)
真的
圣人：is_Module元素((QQ（QQ）^三).0)                                                #需要sage.模块
真的
圣人：is_Module元素(“a”)
False（错误）
sage.结构.元素。is_Monoid元素(x个)#

返回真的如果x是MonoidElement类型。

sage.结构.元素。is_MultiplicativeGroupElement（多重组元素）(x个)#

返回真的如果x是MultiplicativeGroupElement类型。

sage.结构.元素。is_PrincipalIdealDomainElement（主理想域元素）(x个)#

返回真的如果x的类型为PrincipalIdealDomainElement。

sage.结构.元素。is_Ring元素(x个)#

返回真的如果x是RingElement类型。

sage.结构.元素。是矢量（_V）(x个)#
sage.结构.元素。make元素（_E）(_类,_字典,起源)#

此函数仅用于支持旧泡菜。

酸洗功能移至元素。{__getstate__，__setstate__}功能。

sage.结构.元素。起源(x个)#

返回元素的父级x个.

通常，这意味着其数学对象x个是一个元素。

输入：

  • x个–一个元素

输出：

  • 如果x个是圣人元素，返回x.父母（）.

  • 否则，返回类型（x）.

另请参见

父母、皈依和胁迫圣人教程中的章节

示例：

圣人：一 = 42
圣人：起源(一)
整数环
圣人：b = 42/1
圣人：起源(b)
有理字段
圣人：c = 42
圣人：起源(c)                                                                 #需要sage.rings.real_mpfr
53位精度的实字段

一些更复杂的例子：

圣人：x个 = 分区([三,2,1,1,1])                                                #需要sage.combinat
圣人：起源(x个)                                                                 #需要sage.combinat
分区
圣人：v（v） = 矢量(RDF公司, [1,2,三])                                                  #需要sage.模块
圣人：起源(v（v）)                                                                 #需要sage.模块
实双域上的3维向量空间

以下内容不被视为元素，因此类型为返回：

圣人：d日 = 整数(42)  #Python内部
圣人：起源(d日)
<... '整型'>
圣人：L（左） = 列表(范围(10))
圣人：起源(L（左）)
<... '列表'>