操作符#

一元操作#

class graphblas.core.operator.UnaryOp#

接受一个输入并返回一个输出，可能是不同的数据类型。

内置和注册的UnaryOps位于graphblas.unary命名空间以及graphblas.ops组合命名空间中。

classmethod register_anonymous(func, name=None, *, parameterized=False, is_udt=False)#

注册一个UnaryOp，但不将其注册到graphblas.unary命名空间中。

由于它未在命名空间中注册，因此名称是可选的。

Parameters

funcFunctionType: 要编译的函数。对于所有当前的后端，这必须能够使用numba.njit进行编译。 func接受一个任意数据类型的输入参数并返回任意数据类型。
namestr, optional: 操作符的名称。这不会显示为gb.unary.{name}。
parameterizedbool, default False: 当为True时，创建一个参数化的用户定义运算符，这意味着在使用时可以将额外的参数“烘焙”到运算符中。例如，gb.binary.isclose 是一个参数化函数，它可以选择性地接受 rel_tol 和 abs_tol 参数，并且可以这样使用：A.ewise_mult(B, gb.binary.isclose(rel_tol=1e-5))。在创建参数化的用户定义运算符时，func 参数必须是一个可调用的对象，它返回一个函数，然后该函数将被编译。请参见下面的 user_isclose 示例。
is_udtbool, default False: 操作符是否旨在操作用户定义的类型。如果为True，则该函数不会为内置类型自动编译，并且在使用时将“即时”编译。

Returns

UnaryOp or ParameterizedUnaryOp

classmethod register_new(name, func, *, parameterized=False, is_udt=False, lazy=False)#

注册一个新的UnaryOp并将其保存到graphblas.unary命名空间。

Parameters

namestr: 操作符的名称。这将显示为 gb.unary.{name}。名称可能包含句点“.”，这将导致嵌套对象，例如对于名称 "x.y.z"，将显示为 gb.unary.x.y.z。
funcFunctionType: 要编译的函数。对于所有当前的后端，这必须能够使用numba.njit进行编译。 func接受一个任意数据类型的输入参数并返回任意数据类型。
parameterizedbool, default False: 当为True时，创建一个参数化的用户定义运算符，这意味着在使用时可以将额外的参数“烘焙”到运算符中。例如，gb.binary.isclose 是一个参数化函数，它可以选择性地接受 rel_tol 和 abs_tol 参数，并且可以这样使用：A.ewise_mult(B, gb.binary.isclose(rel_tol=1e-5))。在创建参数化的用户定义运算符时，func 参数必须是一个可调用的对象，它返回一个函数，然后该函数将被编译。请参见下面的 user_isclose 示例。
is_udtbool, default False: 操作符是否旨在操作用户定义的类型。如果为True，则该函数不会为内置类型自动编译，并且在使用时将“即时”编译。
lazybool, default False: 如果为False（默认值），则该函数将自动为内置类型编译（除非is_udt为True）。编译函数可能会很慢，因此您可能希望延迟编译，仅在操作符使用时进行编译，这可以通过设置lazy=True来实现。

Examples

>>> gb.core.operator.UnaryOp.register_new("plus_one", lambda x: x + 1)
>>> dir(gb.unary)
[..., 'plus_one', ...]

二元操作#

class graphblas.core.operator.BinaryOp#

接受两个输入并返回一个输出，可能是不同的数据类型。

内置和注册的BinaryOps位于graphblas.binary命名空间以及graphblas.ops组合命名空间中。

classmethod register_anonymous(func, name=None, *, parameterized=False, is_udt=False)#

注册一个BinaryOp而不在graphblas.binary命名空间中注册它。

由于它未在命名空间中注册，因此名称是可选的。

Parameters

funcFunctionType: 要编译的函数。对于所有当前的后端，这必须能够使用numba.njit进行编译。 func接受两个任意数据类型的输入参数，并返回任意数据类型。
namestr, optional: 操作符的名称。这不会显示为gb.binary.{name}。
parameterizedbool, default False: 当为True时，创建一个参数化的用户定义运算符，这意味着在使用时可以将额外的参数“烘焙”到运算符中。例如，gb.binary.isclose 是一个参数化函数，它可以选择性地接受 rel_tol 和 abs_tol 参数，并且可以这样使用：A.ewise_mult(B, gb.binary.isclose(rel_tol=1e-5))。在创建参数化的用户定义运算符时，func 参数必须是一个可调用的对象，它返回一个函数，然后该函数将被编译。
is_udtbool, default False: 操作符是否旨在操作用户定义的类型。如果为True，则该函数不会为内置类型自动编译，并且在使用时将“即时”编译。当左右数据类型需要不同时，设置is_udt=True也很有帮助。

Returns

BinaryOp or ParameterizedBinaryOp

classmethod register_new(name, func, *, parameterized=False, is_udt=False, lazy=False)#

注册一个新的BinaryOp并将其保存到graphblas.binary命名空间。

Parameters

namestr: 操作符的名称。这将显示为 gb.binary.{name}。名称可能包含句点“.”，这将导致嵌套对象，例如对于名称 "x.y.z"，将显示为 gb.binary.x.y.z。
funcFunctionType: 要编译的函数。对于所有当前的后端，这必须能够使用numba.njit进行编译。 func接受两个任意数据类型的输入参数，并返回任意数据类型。
parameterizedbool, default False: 当为True时，创建一个参数化的用户定义运算符，这意味着在使用时可以将额外的参数“烘焙”到运算符中。例如，gb.binary.isclose 是一个参数化函数，它可以选择性地接受 rel_tol 和 abs_tol 参数，并且可以这样使用：A.ewise_mult(B, gb.binary.isclose(rel_tol=1e-5))。在创建参数化的用户定义运算符时，func 参数必须是一个可调用的对象，它返回一个函数，然后该函数将被编译。请参见下面的 user_isclose 示例。
is_udtbool, default False: 操作符是否旨在操作用户定义的类型。如果为True，则该函数不会为内置类型自动编译，并且在使用时将“即时”编译。当左右数据类型需要不同时，设置is_udt=True也很有帮助。
lazybool, default False: 如果为False（默认值），则该函数将自动为内置类型编译（除非is_udt为True）。编译函数可能会很慢，因此您可能希望延迟编译，仅在操作符使用时进行编译，这可以通过设置lazy=True来实现。

Examples

>>> def max_zero(x, y):
        r = 0
        if x > r:
            r = x
        if y > r:
            r = y
        return r
>>> gb.core.operator.BinaryOp.register_new("max_zero", max_zero)
>>> dir(gb.binary)
[..., 'max_zero', ...]

这是gb.binary.isclose的定义方式：

>>> def user_isclose(rel_tol=1e-7, abs_tol=0.0):
>>>     def inner(x, y):
>>>         return x == y or abs(x - y) <= max(rel_tol * max(abs(x), abs(y)), abs_tol)
>>>     return inner
>>> gb.binary.register_new("user_isclose", user_isclose, parameterized=True)

幺半群#

class graphblas.core.operator.Monoid#

接受两个输入并返回一个输出，所有输入输出的数据类型都相同。

内置和注册的Monoid位于graphblas.monoid命名空间以及graphblas.ops组合命名空间中。

classmethod register_anonymous(binaryop, identity, name=None, *, is_idempotent=False)#

注册一个Monoid，但不将其注册到graphblas.monoid命名空间中。

一个幺半群是一个二元运算符，其输入和输出具有相同的数据类型。由于它没有在命名空间中注册，名称是可选的。

Parameters

binaryop: BinaryOp or ParameterizedBinaryOp: 幺半群的二元运算符，应该能够对输入和输出使用相同的数据类型。
identity: scalar or Mapping: 幺半群的恒等元，使得对于任何x，op(x, identity) == x。identity 也可以是从dtype到标量的映射。
namestr, optional: 操作符的名称。这不会显示为gb.monoid.{name}。
is_idempotentbool, default False: 对于任何x，op(x, x) == x 是否成立？

Returns

Monoid or ParameterizedMonoid

classmethod register_new(name, binaryop, identity, *, is_idempotent=False, lazy=False)#

注册一个新的Monoid并将其保存到graphblas.monoid命名空间。

一个幺半群是一个二元运算符，其输入和输出具有相同的数据类型。

Parameters

namestr: 操作符的名称。这将显示为 gb.monoid.{name}。名称可能包含句点“.”，这将导致嵌套对象，例如对于名称 "x.y.z"，将显示为 gb.monoid.x.y.z。
binaryop: BinaryOp or ParameterizedBinaryOp: 幺半群的二元运算符，应该能够对输入和输出使用相同的数据类型。
identity: scalar or Mapping: 幺半群的单位元，使得对于任何x，op(x, identity) == x。identity 也可以是从dtype到标量的映射。
is_idempotentbool, default False: 对于任何x，op(x, x) == x 是否成立？
lazybool, default False: 如果为False（默认值），则该函数将自动为内置类型编译（除非is_udt对于binaryop为True）。编译函数可能会很慢，因此您可能希望延迟编译，仅在操作符使用时进行编译，这可以通过设置lazy=True来实现。

Examples

>>> gb.core.operator.Monoid.register_new("max_zero", gb.binary.max_zero, 0)
>>> dir(gb.monoid)
[..., 'max_zero', ...]

property binaryop#: 与Monoid关联的BinaryOp。

property identities#: Monoid的每种数据类型的单位元值。

property is_idempotent#: 如果对于任何x，monoid(x, x) == x 为真。

半环#

class graphblas.core.operator.Semiring#

Monoid 和 BinaryOp 的组合。

半环最常用于执行矩阵乘法，其中BinaryOp取代了标准的乘法运算符，而Monoid取代了标准的加法运算符。

内置和注册的半环位于graphblas.semiring命名空间以及graphblas.ops组合命名空间中。

classmethod register_anonymous(monoid, binaryop, name=None)#

注册一个Semiring而不在graphblas.semiring命名空间中注册它。

由于它未在命名空间中注册，因此名称是可选的。

Parameters

monoidMonoid or ParameterizedMonoid: 半环的幺半群（如默认“plus_times”半环中的“plus”）。
binaryopBinaryOp or ParameterizedBinaryOp: 半环的二元操作（如默认“plus_times”半环中的“times”）。
namestr, optional: 操作符的名称。这不会显示为gb.semiring.{name}。

Returns

Semiring or ParameterizedSemiring

classmethod register_new(name, monoid, binaryop, *, lazy=False)#

注册一个新的Semiring并将其保存到graphblas.semiring命名空间。

Parameters

namestr: 操作符的名称。这将显示为 gb.semiring.{name}。名称可能包含句点“.”，这将导致嵌套对象，例如对于名称 "x.y.z"，将显示为 gb.semiring.x.y.z。
monoidMonoid or ParameterizedMonoid: 半环的幺半群（如默认“plus_times”半环中的“plus”）。
binaryopBinaryOp or ParameterizedBinaryOp: 半环的二元操作（如默认“plus_times”半环中的“times”）。
lazybool, default False: 如果为False（默认值），则该函数将自动为内置类型编译（除非is_udt为True）。编译函数可能会很慢，因此您可能希望延迟编译，仅在操作符使用时进行编译，这可以通过设置lazy=True来实现。

Examples

>>> gb.core.operator.Semiring.register_new("max_max", gb.monoid.max, gb.binary.max)
>>> dir(gb.semiring)
[..., 'max_max', ...]

property binaryop#: 与半环相关联的BinaryOp。

property monoid#: 与半环相关联的Monoid。

IndexUnaryOp#

class graphblas.core.operator.IndexUnaryOp#

接受一个输入和一个thunk，并返回一个输出，可能是不同的数据类型。除了输入值外，元素的索引也会传递给函数。

这是一种高级的一元操作形式，例如，允许将向量的元素转换为其索引位置以构建斜坡结构。另一个用例是返回一个布尔值，指示元素是否是矩阵的上三角结构的一部分。

内置和注册的IndexUnaryOps位于graphblas.indexunary命名空间中。

classmethod register_anonymous(func, name=None, *, parameterized=False, is_udt=False)#

注册一个 IndexUnary 而不将其注册到 graphblas.indexunary 命名空间中。

由于它未在命名空间中注册，因此名称是可选的。

Parameters

funcFunctionType: 要编译的函数。对于所有当前的后端，这必须能够使用numba.njit进行编译。 func接受四个输入参数——任意数据类型、int64、int64、任意数据类型，并返回任意数据类型。第一个参数（任意数据类型）是输入矩阵或向量的值，第二个参数（int64）是矩阵的行索引或向量的索引，第三个参数（int64）是矩阵的列索引或向量的0，第四个参数（任意数据类型）是输入标量的值。
namestr, optional: 操作符的名称。这不会显示为gb.indexunary.{name}。
parameterizedbool, default False: 当为True时，创建一个参数化的用户定义运算符，这意味着在使用时可以将额外的参数“烘焙”到运算符中。例如，gb.binary.isclose是一个参数化的BinaryOp，它可以选择性地接受rel_tol和abs_tol参数，并且可以这样使用：A.ewise_mult(B, gb.binary.isclose(rel_tol=1e-5))。在创建参数化的用户定义运算符时，func参数必须是一个可调用的对象，它返回一个函数，然后该函数将被编译。
is_udtbool, default False: 操作符是否旨在操作用户定义的类型。如果为True，则该函数不会为内置类型自动编译，并且在使用时将“即时”编译。当左右数据类型需要不同时，设置is_udt=True也很有帮助。

Returns

return IndexUnaryOp or ParameterizedIndexUnaryOp

classmethod register_new(name, func, *, parameterized=False, is_udt=False, lazy=False)#

注册一个新的IndexUnaryOp并将其保存到graphblas.indexunary命名空间。

如果返回类型是布尔值，该函数也将以相同的名称注册为 SelectOp（并保存到 grablas.select 命名空间）。

Parameters

namestr: 操作符的名称。这将显示为 gb.indexunary.{name}。名称可以包含句点“.”，这将导致嵌套对象，例如对于名称 "x.y.z"，将显示为 gb.indexunary.x.y.z。
funcFunctionType: 要编译的函数。对于所有当前的后端，这必须能够使用numba.njit进行编译。 func接受四个输入参数——任意数据类型、int64、int64、任意数据类型，并返回任意数据类型。第一个参数（任意数据类型）是输入矩阵或向量的值，第二个参数（int64）是矩阵的行索引或向量的索引，第三个参数（int64）是矩阵的列索引或向量的0，第四个参数（任意数据类型）是输入标量的值。
parameterizedbool, default False: 当为True时，创建一个参数化的用户定义运算符，这意味着在使用时可以将额外的参数“烘焙”到运算符中。例如，gb.binary.isclose 是一个参数化的BinaryOp，它可以选择性地接受 rel_tol 和 abs_tol 参数，并且可以这样使用：A.ewise_mult(B, gb.binary.isclose(rel_tol=1e-5))。在创建参数化的用户定义运算符时，func 参数必须是一个可调用的对象，它返回一个函数，然后该函数将被编译。
is_udtbool, default False: 操作符是否旨在操作用户定义的类型。如果为True，则该函数不会为内置类型自动编译，并且在使用时将“即时”编译。当左右数据类型需要不同时，设置is_udt=True也很有帮助。
lazybool, default False: 如果为False（默认值），则该函数将自动为内置类型编译（除非is_udt为True）。编译函数可能会很慢，因此您可能希望延迟编译，仅在操作符使用时进行编译，这可以通过设置lazy=True来实现。

Examples

>>> gb.indexunary.register_new("row_mod", lambda x, i, j, thunk: i % max(thunk, 2))
>>> dir(gb.indexunary)
[..., 'row_mod', ...]

选择操作#

class graphblas.core.operator.SelectOp#

与 IndexUnaryOp 相同，但必须具有布尔返回类型。

SelectOp 专门用于从集合中选择函数返回为 True 的值的子集。

内置和注册的SelectOps位于graphblas.select命名空间中。

classmethod register_anonymous(func, name=None, *, parameterized=False, is_udt=False)#

注册一个SelectOp而不将其注册到graphblas.select命名空间中。

由于它未在命名空间中注册，名称是可选的。返回类型必须为布尔型。

Parameters

funcFunctionType: 要编译的函数。对于所有当前的后端，这必须能够使用numba.njit进行编译。 func接受四个输入参数——任意数据类型、int64、int64、任意数据类型，并返回布尔值。第一个参数（任意数据类型）是输入矩阵或向量的值，第二个参数（int64）是矩阵的行索引或向量的索引，第三个参数（int64）是矩阵的列索引或向量的0，第四个参数（任意数据类型）是输入标量的值。
namestr, optional: 操作符的名称。这不会显示为gb.select.{name}。
parameterizedbool, default False: 当为True时，创建一个参数化的用户定义运算符，这意味着在使用时可以将额外的参数“烘焙”到运算符中。例如，gb.binary.isclose是一个参数化的BinaryOp，它可以选择性地接受rel_tol和abs_tol参数，并且可以这样使用：A.ewise_mult(B, gb.binary.isclose(rel_tol=1e-5))。在创建参数化的用户定义运算符时，func参数必须是一个可调用的对象，它返回一个函数，然后该函数将被编译。
is_udtbool, default False: 操作符是否旨在操作用户定义的类型。如果为True，则该函数不会为内置类型自动编译，并且在使用时将“即时”编译。当左右数据类型需要不同时，设置is_udt=True也很有帮助。

Returns

SelectOp or ParameterizedSelectOp

classmethod register_new(name, func, *, parameterized=False, is_udt=False, lazy=False)#

注册一个新的SelectOp并将其保存到graphblas.select命名空间。

该函数也将以相同的名称注册为IndexUnaryOp。返回类型必须为Boolean。

Parameters

namestr: 操作符的名称。这将显示为 gb.select.{name}。名称可能包含句点“.”，这将导致嵌套对象，例如对于名称 "x.y.z"，将显示为 gb.select.x.y.z。
funcFunctionType: 要编译的函数。对于所有当前的后端，这必须能够使用numba.njit进行编译。 func接受四个输入参数——任意数据类型、int64、int64、任意数据类型，并返回布尔值。第一个参数（任意数据类型）是输入矩阵或向量的值，第二个参数（int64）是矩阵的行索引或向量的索引，第三个参数（int64）是矩阵的列索引或向量的0，第四个参数（任意数据类型）是输入标量的值。
parameterizedbool, default False: 当为True时，创建一个参数化的用户定义运算符，这意味着在使用时可以将额外的参数“烘焙”到运算符中。例如，gb.binary.isclose是一个参数化的BinaryOp，它可以选择性地接受rel_tol和abs_tol参数，并且可以这样使用：A.ewise_mult(B, gb.binary.isclose(rel_tol=1e-5))。在创建参数化的用户定义运算符时，func参数必须是一个可调用的对象，它返回一个函数，然后该函数将被编译。
is_udtbool, default False: 操作符是否旨在操作用户定义的类型。如果为True，则该函数不会为内置类型自动编译，并且在使用时将“即时”编译。当左右数据类型需要不同时，设置is_udt=True也很有帮助。
lazybool, default False: 如果为False（默认值），则该函数将自动为内置类型编译（除非is_udt为True）。编译函数可能会很慢，因此您可能希望延迟编译，仅在操作符使用时进行编译，这可以通过设置lazy=True来实现。

Examples

>>> gb.select.register_new("upper_left_triangle", lambda x, i, j, thunk: i + j <= thunk)
>>> dir(gb.select)
[..., 'upper_left_triangle', ...]