metagraph-dev / grblas / 2139249241

2139249241

Pull #177

github

GitHub 
Merge 1ce84217b into d9e692141
Pull Request #177: Add user-defined types

4669 of 4698 branches covered (99.38%)

Branch coverage included in aggregate %.

1021 of 1036 new or added lines in 23 files covered. (98.55%)

1 existing line in 1 file now uncovered.

14758 of 14782 relevant lines covered (99.84%)

14.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.59
/grblas/tests/test_op.py
1 
import itertools
15✔
2 









3



import numpy as np




15✔





4



import pytest




15✔





5












6



import grblas as gb




15✔





7



from grblas import agg, binary, dtypes, lib, monoid, op, operator, semiring, unary




15✔






8



from grblas.dtypes import BOOL, FP32, FP64, INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64




15✔





9



from grblas.exceptions import DomainMismatch, UdfParseError




15✔





10



from grblas.operator import BinaryOp, Monoid, Semiring, UnaryOp, get_semiring




15✔





11













12



if dtypes._supports_complex:





15✔






13



    from grblas.dtypes import FC32, FC64




11✔





14












15



from grblas import Matrix, Vector  # isort:skip




15✔





16












17












18



def orig_types(op):




15✔





19



    return op.types.keys() - op.coercions.keys()




15✔





20












21












22



def test_operator_initialized():




15✔





23



    assert operator.UnaryOp._initialized




15✔





24



    assert operator.BinaryOp._initialized




15✔





25



    assert operator.Monoid._initialized




15✔





26



    assert operator.Semiring._initialized




15✔





27












28












29



def test_op_repr():




15✔





30



    assert repr(unary.ainv) == "unary.ainv"




15✔





31



    assert repr(binary.plus) == "binary.plus"




15✔





32



    assert repr(monoid.times) == "monoid.times"




15✔





33



    assert repr(semiring.plus_times) == "semiring.plus_times"




15✔





34












35












36



def test_unaryop():




15✔





37



    assert unary.ainv["INT32"].gb_obj == lib.GrB_AINV_INT32




15✔





38



    assert unary.ainv[dtypes.UINT16].gb_obj == lib.GrB_AINV_UINT16




15✔






39



    assert orig_types(unary.positioni) == {INT32, INT64}




15✔






40



    assert orig_types(unary.positionj1) == {INT32, INT64}




15✔





41












42












43



def test_binaryop():




15✔





44



    assert binary.plus["INT32"].gb_obj == lib.GrB_PLUS_INT32




15✔





45



    assert binary.plus[dtypes.UINT16].gb_obj == lib.GrB_PLUS_UINT16




15✔






46



    assert orig_types(binary.firsti) == {INT32, INT64}




15✔






47



    assert orig_types(binary.secondj1) == {INT32, INT64}




15✔





48












49












50



def test_monoid():




15✔





51



    assert monoid.max["INT32"].gb_obj == lib.GrB_MAX_MONOID_INT32




15✔





52



    assert monoid.max[dtypes.UINT16].gb_obj == lib.GrB_MAX_MONOID_UINT16




15✔





53












54












55



def test_semiring():




15✔





56



    assert semiring.min_plus["INT32"].gb_obj == lib.GrB_MIN_PLUS_SEMIRING_INT32




15✔





57



    assert semiring.min_plus[dtypes.UINT16].gb_obj == lib.GrB_MIN_PLUS_SEMIRING_UINT16




15✔






58



    assert orig_types(semiring.min_firsti) == {INT32, INT64}




15✔





59












60












61



def test_agg():




15✔





62



    assert repr(agg.count) == "agg.count"




15✔





63



    assert repr(agg.count["INT32"]) == "agg.count[INT32]"




15✔





64



    assert "INT64" in agg.sum_of_inverses




15✔






65



    assert agg.sum_of_inverses["INT64"].return_type == FP64




15✔





66



    assert "BOOL" not in agg.sum_of_inverses




15✔





67



    with pytest.raises(KeyError, match="BOOL"):





15✔





68



        agg.sum_of_inverses["BOOL"]




15✔





69



    assert agg.varp["INT64"].return_type == "FP64"




15✔





70












71












72



def test_find_opclass_unaryop():




15✔





73



    assert operator.find_opclass(unary.minv)[1] == "UnaryOp"




15✔





74



    # assert operator.find_opclass(lib.GrB_MINV_INT64)[1] == 'UnaryOp'










75












76












77



def test_find_opclass_binaryop():




15✔





78



    assert operator.find_opclass(binary.times)[1] == "BinaryOp"




15✔





79



    # assert operator.find_opclass(lib.GrB_TIMES_INT64)[1] == 'BinaryOp'










80












81












82



def test_find_opclass_monoid():




15✔





83



    assert operator.find_opclass(monoid.max)[1] == "Monoid"




15✔





84



    # assert operator.find_opclass(lib.GxB_MAX_INT64_MONOID)[1] == 'Monoid'










85












86












87



def test_find_opclass_semiring():




15✔





88



    assert operator.find_opclass(semiring.plus_plus)[1] == "Semiring"




15✔





89



    # assert operator.find_opclass(lib.GxB_PLUS_PLUS_INT64)[1] == 'Semiring'










90












91












92



def test_find_opclass_invalid():




15✔





93



    assert operator.find_opclass("foobar")[1] == operator.UNKNOWN_OPCLASS




15✔





94



    # assert operator.find_opclass(lib.GrB_INP0)[1] == operator.UNKNOWN_OPCLASS










95












96












97



def test_get_typed_op():




15✔





98



    assert operator.get_typed_op(binary.bor, dtypes.INT64) is binary.bor[dtypes.INT64]




15✔





99



    with pytest.raises(KeyError, match="bor does not work with FP64"):





15✔





100



        operator.get_typed_op(binary.bor, dtypes.FP64)




15✔





101



    with pytest.raises(TypeError, match="Unable to get typed operator"):





15✔





102



        operator.get_typed_op(object(), dtypes.INT64)




15✔





103



    assert operator.get_typed_op("<", dtypes.INT64, kind="binary") is binary.lt["INT64"]




15✔





104



    assert operator.get_typed_op("-", dtypes.INT64, kind="unary") is unary.ainv["INT64"]




15✔





105



    assert operator.get_typed_op("+", dtypes.FP64, kind="monoid") is monoid.plus["FP64"]




15✔





106



    assert operator.get_typed_op("+[int64]", dtypes.FP64, kind="monoid") is monoid.plus["INT64"]




15✔





107



    assert operator.get_typed_op("+.*", dtypes.FP64, kind="semiring") is semiring.plus_times["FP64"]




15✔





108



    with pytest.raises(ValueError, match="Unable to get op from string"):





15✔





109



        operator.get_typed_op("+", dtypes.FP64)




15✔





110



    assert (




15✔





111



        operator.get_typed_op("+", dtypes.INT64, kind="binary|aggregator") is binary.plus["INT64"]










112



    )










113



    assert (




15✔





114



        operator.get_typed_op("count", dtypes.INT64, kind="binary|aggregator") is agg.count["INT64"]










115



    )










116



    with pytest.raises(ValueError, match="Unknown binary or aggregator"):





15✔





117



        operator.get_typed_op("bad_op_name", dtypes.INT64, kind="binary|aggregator")




15✔





118












119












120



def test_unaryop_udf():




15✔





121



    def plus_one(x):




15✔





122



        return x + 1  # pragma: no cover










123












124



    UnaryOp.register_new("plus_one", plus_one)




15✔





125



    assert hasattr(unary, "plus_one")




15✔






126



    assert unary.plus_one.orig_func is plus_one




15✔






127



    assert unary.plus_one[int].orig_func is plus_one




15✔





128



    comp_set = {




15✔





129



        INT8,










130



        INT16,










131



        INT32,










132



        INT64,










133



        UINT8,










134



        UINT16,










135



        UINT32,










136



        UINT64,










137



        FP32,










138



        FP64,










139



        BOOL,










140



    }










141



    if dtypes._supports_complex:





15✔






142



        comp_set.update({FC32, FC64})




11✔





143



    assert set(unary.plus_one.types) == comp_set




15✔





144



    v = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




15✔





145



    v << v.apply(unary.plus_one)




15✔





146



    result = Vector.from_values([0, 1, 3], [2, 3, -3], dtype=dtypes.INT32)




15✔





147



    assert v.isequal(result)




15✔





148



    assert "INT8" in unary.plus_one




15✔






149



    assert INT8 in unary.plus_one.types




15✔





150



    del unary.plus_one["INT8"]




15✔





151



    assert "INT8" not in unary.plus_one




15✔






152



    assert INT8 not in unary.plus_one.types




15✔





153



    with pytest.raises(TypeError, match="UDF argument must be a function"):





15✔





154



        UnaryOp.register_new("bad", object())




15✔





155



    assert not hasattr(unary, "bad")




15✔





156



    with pytest.raises(UdfParseError, match="Unable to parse function using Numba"):





15✔





157



        UnaryOp.register_new("bad", lambda x: v)





15!





158












159












160



@pytest.mark.slow




15✔





161



def test_unaryop_parameterized():




15✔





162



    def plus_x(x=0):




10✔





163



        def inner(val):




10✔





164



            return val + x  # pragma: no cover










165












166



        return inner




10✔





167












168



    op = UnaryOp.register_anonymous(plus_x, parameterized=True)




10✔





169



    v = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




10✔





170



    v0 = v.apply(op).new()




10✔





171



    assert v.isequal(v0, check_dtype=True)




10✔





172



    v0 = v.apply(op(0)).new()




10✔





173



    assert v.isequal(v0, check_dtype=True)




10✔





174



    v10 = v.apply(op(x=10)).new()




10✔





175



    r10 = Vector.from_values([0, 1, 3], [11, 12, 6], dtype=dtypes.INT32)




10✔





176



    assert r10.isequal(v10, check_dtype=True)




10✔





177



    UnaryOp._initialize()  # no-op




10✔





178



    UnaryOp.register_new("plus_x_parameterized", plus_x, parameterized=True)




10✔





179



    op = unary.plus_x_parameterized




10✔





180



    v11 = v.apply(op(x=10)["INT32"]).new()




10✔





181



    assert r10.isequal(v11, check_dtype=True)




10✔





182












183












184



@pytest.mark.slow




15✔





185



def test_binaryop_parameterized():




15✔





186



    def plus_plus_x(x=0):




10✔





187



        def inner(left, right):




10✔





188



            return left + right + x  # pragma: no cover










189












190



        return inner




10✔





191












192



    op = BinaryOp.register_anonymous(plus_plus_x, parameterized=True)




10✔





193



    assert op.monoid is None




10✔





194



    assert op(1).monoid is None




10✔





195



    v = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




10✔





196



    v0 = v.ewise_mult(v, op).new()




10✔





197



    r0 = Vector.from_values([0, 1, 3], [2, 4, -8], dtype=dtypes.INT32)




10✔





198



    assert v0.isequal(r0, check_dtype=True)




10✔





199



    v1 = v.ewise_add(v, op(1), require_monoid=False).new()




10✔





200



    r1 = Vector.from_values([0, 1, 3], [3, 5, -7], dtype=dtypes.INT32)




10✔





201



    assert v1.isequal(r1, check_dtype=True)




10✔





202












203



    w = Vector.from_values([0, 0, 1, 3], [1, 0, 2, -4], dtype=dtypes.INT32, dup_op=op)




10✔





204



    assert v.isequal(w, check_dtype=True)




10✔





205



    with pytest.raises(TypeError, match="Monoid"):





10✔





206



        assert v.reduce(op).new() == -1




10✔





207












208



    v(op) << v




10✔





209



    assert v.isequal(r0)




10✔





210



    v(accum=op) << v




10✔





211



    x = r0.ewise_mult(r0, op).new()




10✔





212



    assert v.isequal(x)




10✔





213



    v(op(1)) << v




10✔





214



    x = x.ewise_mult(x, op(1)).new()




10✔





215



    assert v.isequal(x)




10✔





216



    v(accum=op(1)) << v




10✔





217



    x = x.ewise_mult(x, op(1)).new()




10✔





218



    assert v.isequal(x)




10✔





219












220



    assert v.isequal(Vector.from_values([0, 1, 3], [19, 35, -61], dtype=dtypes.INT32))




10✔





221



    v11 = v.apply(op(1), left=10).new()




10✔





222



    r11 = Vector.from_values([0, 1, 3], [30, 46, -50], dtype=dtypes.INT32)




10✔





223



    # Should we check for dtype here?










224



    # Is it okay if the literal scalar is an INT64, which causes the output to default to INT64?










225



    assert v11.isequal(r11, check_dtype=False)




10✔





226












227



    with pytest.raises(TypeError, match="UDF argument must be a function"):





10✔





228



        BinaryOp.register_new("bad", object())




10✔





229



    assert not hasattr(binary, "bad")




10✔





230



    with pytest.raises(UdfParseError, match="Unable to parse function using Numba"):





10✔





231



        BinaryOp.register_new("bad", lambda x, y: v)





10!





232












233



    def my_add(x, y):




10✔





234



        return x + y  # pragma: no cover










235












236



    op = BinaryOp.register_anonymous(my_add)




10✔





237



    assert op.name == "my_add"




10✔





238












239












240



@pytest.mark.slow




15✔





241



def test_monoid_parameterized():




15✔





242



    def plus_plus_x(x=0):




10✔





243



        def inner(left, right):




10✔





244



            return left + right + x  # pragma: no cover










245












246



        return inner




10✔





247












248



    bin_op = BinaryOp.register_anonymous(plus_plus_x, parameterized=True)




10✔





249












250



    # signatures must match










251



    with pytest.raises(ValueError, match="Signatures"):




10✔





252



        Monoid.register_anonymous(bin_op, lambda x: -x)  # pragma: no cover










253



    with pytest.raises(ValueError, match="Signatures"):




10✔





254



        Monoid.register_anonymous(bin_op, lambda y=0: -y)  # pragma: no cover










255



    with pytest.raises(TypeError, match="binaryop must be parameterized"):





10✔





256



        operator.ParameterizedMonoid("bad_monoid", binary.plus, 0)




10✔





257












258



    def plus_plus_x_identity(x=0):




10✔





259



        return -x




10✔





260












261



    assert bin_op.monoid is None




10✔





262



    bin_op1 = bin_op(1)




10✔





263



    assert bin_op1.monoid is None




10✔





264



    monoid = Monoid.register_anonymous(bin_op, plus_plus_x_identity, name="my_monoid")




10✔





265



    assert bin_op.monoid is monoid




10✔





266



    assert bin_op(1).monoid is monoid(1)




10✔





267



    assert monoid(2) is bin_op(2).monoid




10✔





268



    # However, this still fails.










269



    # For this to work, we would need `bin_op1` to know it was created from a










270



    # ParameterizedBinaryOp. It would then need to check to see if the parameterized










271



    # parent has been associated with a monoid since the creation of `bin_op1`.










272



    assert bin_op1.monoid is None




10✔





273












274



    assert monoid.name == "my_monoid"




10✔





275



    v = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




10✔





276



    v0 = v.ewise_add(v, monoid).new()




10✔





277



    r0 = Vector.from_values([0, 1, 3], [2, 4, -8], dtype=dtypes.INT32)




10✔





278



    assert v0.isequal(r0, check_dtype=True)




10✔





279



    v1 = v.ewise_mult(v, monoid(1)).new()




10✔





280



    r1 = Vector.from_values([0, 1, 3], [3, 5, -7], dtype=dtypes.INT32)




10✔





281



    assert v1.isequal(r1, check_dtype=True)




10✔





282












283



    assert v.reduce(monoid).new() == -1




10✔





284



    assert v.reduce(monoid(1)).new() == 1




10✔





285



    # with pytest.raises(TypeError, match="BinaryOp"):  # NOW OKAY










286



    w1 = Vector.from_values([0, 0, 1, 3], [1, 0, 2, -4], dtype=dtypes.INT32, dup_op=monoid)




10✔





287



    w2 = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




10✔





288



    assert w1.isequal(w2)




10✔





289












290



    # identity may be a value










291



    def logaddexp(base):




10✔





292



        def inner(x, y):




10✔





293



            return np.log(base**x + base**y) / np.log(base)  # pragma: no cover










294












295



        return inner




10✔





296












297



    fv = v.apply(unary.identity).new(dtype=dtypes.FP64)




10✔





298



    bin_op = BinaryOp.register_anonymous(logaddexp, parameterized=True)




10✔





299



    Monoid.register_new("_user_defined_monoid", bin_op, -np.inf)




10✔





300



    monoid = gb.monoid._user_defined_monoid




10✔





301



    fv2 = fv.ewise_mult(fv, monoid(2)).new()




10✔





302



    plus1 = UnaryOp.register_anonymous(lambda x: x + 1)





10!





303



    expected = fv.apply(plus1).new()




10✔





304



    assert fv2.isclose(expected, check_dtype=True)




10✔





305



    with pytest.raises(TypeError, match="must be a BinaryOp"):





10✔





306



        Monoid.register_anonymous(monoid, 0)




10✔





307












308



    def plus_times_x(x=0):




10✔





309



        def inner(left, right):




10✔





310



            return (left + right) * x  # pragma: no cover










311












312



        return inner




10✔





313












314



    bin_op = BinaryOp.register_anonymous(plus_times_x, parameterized=True)




10✔





315












316



    def bad_identity(x=0):




10✔





317



        raise ValueError("hahaha!")




10✔





318












319



    assert bin_op.monoid is None




10✔





320



    monoid = Monoid.register_anonymous(bin_op, bad_identity, name="broken_monoid")




10✔





321



    assert bin_op.monoid is monoid




10✔





322



    assert bin_op(1).monoid is None




10✔





323












324












325



@pytest.mark.slow




15✔





326



def test_semiring_parameterized():




15✔





327



    def plus_plus_x(x=0):




10✔





328



        def inner(left, right):




10✔





329



            return left + right + x  # pragma: no cover










330












331



        return inner




10✔





332












333



    def plus_plus_x_identity(x=0):




10✔





334



        return -x




10✔





335












336



    assert Semiring.register_anonymous(monoid.min, binary.plus).name == "min_plus"




10✔





337












338



    bin_op = BinaryOp.register_anonymous(plus_plus_x, parameterized=True)




10✔





339



    mymonoid = Monoid.register_anonymous(bin_op, plus_plus_x_identity)




10✔





340



    # monoid and binaryop are both parameterized










341



    mysemiring = Semiring.register_anonymous(mymonoid, bin_op, name="my_semiring")




10✔





342



    assert mysemiring.name == "my_semiring"




10✔





343












344



    A = Matrix.from_values([0, 0, 1, 1], [0, 1, 0, 1], [1, 2, 3, 4])




10✔





345



    x = Vector.from_values([0, 1], [10, 20])




10✔





346












347



    y = A.mxv(x, mysemiring).new()




10✔





348



    assert y.isequal(A.mxv(x, semiring.plus_plus).new())




10✔





349



    assert y.isequal(x.vxm(A.T, semiring.plus_plus).new())




10✔





350



    assert y.isequal(Vector.from_values([0, 1], [33, 37]))




10✔





351












352



    y = A.mxv(x, mysemiring(1)).new()




10✔





353



    assert y.isequal(Vector.from_values([0, 1], [36, 40]))  # three extra pluses




10✔





354












355



    y = x.vxm(A.T, mysemiring(1)).new()  # same as previous




10✔





356



    assert y.isequal(Vector.from_values([0, 1], [36, 40]))




10✔





357












358



    y = x.vxm(A.T, mysemiring).new()




10✔





359



    assert y.isequal(Vector.from_values([0, 1], [33, 37]))




10✔





360












361



    B = A.mxm(A, mysemiring).new()




10✔





362



    assert B.isequal(A.mxm(A, semiring.plus_plus).new())




10✔





363



    assert B.isequal(Matrix.from_values([0, 0, 1, 1], [0, 1, 0, 1], [7, 9, 11, 13]))




10✔





364












365



    B = A.mxm(A, mysemiring(1)).new()  # three extra pluses




10✔





366



    assert B.isequal(Matrix.from_values([0, 0, 1, 1], [0, 1, 0, 1], [10, 12, 14, 16]))




10✔





367












368



    with pytest.raises(TypeError, match="Expected type: Monoid"):




10✔





369



        A.ewise_add(A, mysemiring)




10✔





370












371



    # mismatched signatures.










372



    def other_binary(y=0):  # pragma: no cover










373



        def inner(left, right):










374



            return left + right - y










375












376



        return inner










377












378



    def other_identity(y=0):




10✔





379



        return x  # pragma: no cover










380












381



    other_op = BinaryOp.register_anonymous(other_binary, parameterized=True)




10✔





382



    other_monoid = Monoid.register_anonymous(other_op, other_identity)




10✔





383



    with pytest.raises(ValueError, match="Signatures"):





10✔





384



        Monoid.register_anonymous(other_op, plus_plus_x_identity)




10✔





385



    with pytest.raises(ValueError, match="Signatures"):





10✔





386



        Monoid.register_anonymous(bin_op, other_identity)




10✔





387



    with pytest.raises(ValueError, match="Signatures"):





10✔





388



        Semiring.register_anonymous(other_monoid, bin_op)




10✔





389



    with pytest.raises(ValueError, match="Signatures"):





10✔





390



        Semiring.register_anonymous(mymonoid, other_op)




10✔





391












392



    # only monoid is parameterized










393



    Semiring.register_new("my_special_semiring", mymonoid, binary.plus)




10✔





394



    mysemiring = semiring.my_special_semiring




10✔





395



    B0 = A.mxm(A, semiring.plus_plus).new()




10✔





396



    B1 = A.mxm(A, mysemiring).new()




10✔





397



    B2 = A.mxm(A, mysemiring(0)).new()




10✔





398



    assert B0.isequal(B1)




10✔





399



    assert B0.isequal(B2)




10✔





400












401



    # only binaryop is parameterized










402



    mysemiring = Semiring.register_anonymous(monoid.plus, bin_op)




10✔





403



    B0 = A.mxm(A, semiring.plus_plus).new()




10✔





404



    B1 = A.mxm(A, mysemiring).new()




10✔





405



    B2 = A.mxm(A, mysemiring(0)).new()




10✔





406



    assert B0.isequal(B1)




10✔





407



    assert B0.isequal(B2)




10✔





408












409



    with pytest.raises(TypeError, match="must be a Monoid"):





10✔





410



        Semiring.register_anonymous(binary.plus, binary.plus)




10✔





411



    with pytest.raises(TypeError, match="must be a BinaryOp"):





10✔





412



        Semiring.register_anonymous(monoid.plus, monoid.plus)




10✔





413



    with pytest.raises(TypeError, match="At least one of"):





10✔





414



        operator.ParameterizedSemiring("bad_semiring", monoid.plus, binary.plus)




10✔





415



    with pytest.raises(TypeError, match="monoid must be of type"):





10✔





416



        operator.ParameterizedSemiring("bad_semiring", binary.plus, binary.plus)




10✔





417



    with pytest.raises(TypeError, match="binaryop must be of"):





10✔





418



        operator.ParameterizedSemiring("bad_semiring", monoid.plus, monoid.plus)




10✔





419












420



    # While we're here, let's check misc Matrix operations










421



    Adup = Matrix.from_values([0, 0, 0, 1, 1], [0, 0, 1, 0, 1], [100, 1, 2, 3, 4], dup_op=bin_op)




10✔





422



    Adup2 = Matrix.from_values(




10✔





423



        [0, 0, 0, 1, 1], [0, 0, 1, 0, 1], [100, 1, 2, 3, 4], dup_op=binary.plus










424



    )










425



    assert Adup.isequal(Adup2)




10✔





426












427



    def plus_x(x=0):




10✔





428



        def inner(y):




10✔





429



            return x + y  # pragma: no cover










430












431



        return inner




10✔





432












433



    unaryop = UnaryOp.register_anonymous(plus_x, parameterized=True)




10✔





434



    B = A.apply(unaryop).new()




10✔





435



    assert B.isequal(A)




10✔





436












437



    # SuiteSparse 4.0.1 no longer supports reduce with user-defined binary op










438



    # But, we can associate this to a monoid!










439



    x = A.reduce_rowwise(bin_op).new()




10✔





440



    assert x.isequal(A.reduce_rowwise(binary.plus).new())




10✔





441



    x = A.reduce_columnwise(bin_op).new()




10✔





442



    assert x.isequal(A.reduce_columnwise(binary.plus).new())




10✔





443












444



    s = A.reduce_scalar(mymonoid).new()




10✔





445



    assert s.value == A.reduce_scalar(monoid.plus).new()




10✔





446












447



    assert A.reduce_scalar(bin_op).new() == A.reduce_scalar(binary.plus).new()




10✔





448












449



    B = A.kronecker(A, bin_op).new()




10✔





450



    assert B.isequal(A.kronecker(A, binary.plus).new())




10✔





451












452












453



def test_unaryop_udf_bool_result():




15✔





454



    # numba has trouble compiling this, but we have a work-around










455



    def is_positive(x):




15✔





456



        return x > 0  # pragma: no cover










457












458



    UnaryOp.register_new("is_positive", is_positive)




15✔





459



    assert hasattr(unary, "is_positive")




15✔





460



    assert set(unary.is_positive.types) == {




15✔





461



        INT8,










462



        INT16,










463



        INT32,










464



        INT64,










465



        UINT8,










466



        UINT16,










467



        UINT32,










468



        UINT64,










469



        FP32,










470



        FP64,










471



        BOOL,










472



    }










473



    v = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




15✔





474



    w = v.apply(unary.is_positive).new()




15✔





475



    result = Vector.from_values([0, 1, 3], [True, True, False], dtype=dtypes.BOOL)




15✔





476



    assert w.isequal(result)




15✔





477












478












479



def test_binaryop_udf():




15✔





480



    def times_minus_sum(x, y):




15✔





481



        return x * y - (x + y)  # pragma: no cover










482












483



    BinaryOp.register_new("bin_test_func", times_minus_sum)




15✔





484



    assert hasattr(binary, "bin_test_func")




15✔





485



    comp_set = {




15✔





486



        BOOL,  # goes to INT64










487



        INT8,










488



        INT16,










489



        INT32,










490



        INT64,










491



        UINT8,










492



        UINT16,










493



        UINT32,










494



        UINT64,










495



        FP32,










496



        FP64,










497



    }










498



    if dtypes._supports_complex:





15✔






499



        comp_set.update({FC32, FC64})




11✔





500



    assert set(binary.bin_test_func.types) == comp_set




15✔





501



    v1 = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




15✔





502



    v2 = Vector.from_values([0, 2, 3], [2, 3, 7], dtype=dtypes.INT32)




15✔





503



    w = v1.ewise_add(v2, binary.bin_test_func, require_monoid=False).new()




15✔





504



    result = Vector.from_values([0, 1, 2, 3], [-1, 2, 3, -31], dtype=dtypes.INT32)




15✔





505



    assert w.isequal(result)




15✔





506












507












508



def test_monoid_udf():




15✔





509



    def plus_plus_one(x, y):




15✔





510



        return x + y + 1  # pragma: no cover










511












512



    BinaryOp.register_new("plus_plus_one", plus_plus_one)




15✔





513



    Monoid.register_new("plus_plus_one", binary.plus_plus_one, -1)




15✔





514



    assert hasattr(monoid, "plus_plus_one")




15✔





515



    assert set(monoid.plus_plus_one.types) == {




15✔





516



        INT8,










517



        INT16,










518



        INT32,










519



        INT64,










520



        UINT8,










521



        UINT16,










522



        UINT32,










523



        UINT64,










524



        FP32,










525



        FP64,










526



    }










527



    v1 = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




15✔





528



    v2 = Vector.from_values([0, 2, 3], [2, 3, 7], dtype=dtypes.INT32)




15✔





529



    w = v1.ewise_add(v2, monoid.plus_plus_one).new()




15✔





530



    result = Vector.from_values([0, 1, 2, 3], [4, 2, 3, 4], dtype=dtypes.INT32)




15✔





531



    assert w.isequal(result)




15✔





532












533



    with pytest.raises(DomainMismatch):





15✔





534



        Monoid.register_anonymous(binary.plus_plus_one, {"BOOL": True})




15✔





535



    with pytest.raises(DomainMismatch):





15✔





536



        Monoid.register_anonymous(binary.plus_plus_one, {"BOOL": -1})




15✔





537












538












539



def test_semiring_udf():




15✔





540



    def plus_plus_two(x, y):




15✔





541



        return x + y + 2  # pragma: no cover










542












543



    BinaryOp.register_new("plus_plus_two", plus_plus_two)




15✔





544



    Semiring.register_new("extra_twos", monoid.plus, binary.plus_plus_two)




15✔





545



    v = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




15✔





546



    A = Matrix.from_values(




15✔





547



        [0, 0, 0, 0, 3, 3, 3, 3],










548



        [0, 1, 2, 3, 0, 1, 2, 3],










549



        [2, 3, 4, 5, 6, 7, 8, 9],










550



        dtype=dtypes.INT32,










551



    )










552



    w = v.vxm(A, semiring.extra_twos).new()




15✔





553



    result = Vector.from_values([0, 1, 2, 3], [9, 11, 13, 15], dtype=dtypes.INT32)




15✔





554



    assert w.isequal(result)




15✔





555












556












557



def test_binary_updates():




15✔





558



    assert not hasattr(binary, "div")




15✔





559



    assert binary.cdiv["INT64"].gb_obj == lib.GrB_DIV_INT64




15✔





560



    vec1 = Vector.from_values([0], [1], dtype=dtypes.INT64)




15✔





561



    vec2 = Vector.from_values([0], [2], dtype=dtypes.INT64)




15✔





562



    result = vec1.ewise_mult(vec2, binary.truediv).new()




15✔





563



    assert result.isclose(Vector.from_values([0], [0.5], dtype=dtypes.FP64), check_dtype=True)




15✔





564



    vec4 = Vector.from_values([0], [-3], dtype=dtypes.INT64)




15✔





565



    result2 = vec4.ewise_mult(vec2, binary.cdiv).new()




15✔





566



    assert result2.isequal(Vector.from_values([0], [-1], dtype=dtypes.INT64), check_dtype=True)




15✔





567



    result3 = vec4.ewise_mult(vec2, binary.floordiv).new()




15✔





568



    assert result3.isequal(Vector.from_values([0], [-2], dtype=dtypes.INT64), check_dtype=True)




15✔





569












570












571



@pytest.mark.slow




15✔





572



def test_nested_names():




15✔





573



    def plus_three(x):




10✔





574



        return x + 3  # pragma: no cover










575












576



    UnaryOp.register_new("incrementers.plus_three", plus_three)




10✔





577



    assert hasattr(unary, "incrementers")




10✔





578



    assert type(unary.incrementers) is operator.OpPath




10✔





579



    assert hasattr(unary.incrementers, "plus_three")




10✔





580



    comp_set = {




10✔





581



        INT8,










582



        INT16,










583



        INT32,










584



        INT64,










585



        UINT8,










586



        UINT16,










587



        UINT32,










588



        UINT64,










589



        FP32,










590



        FP64,










591



        BOOL,










592



    }










593



    if dtypes._supports_complex:





10✔






594



        comp_set.update({FC32, FC64})




7✔





595



    assert set(unary.incrementers.plus_three.types) == comp_set




10✔





596












597



    v = Vector.from_values([0, 1, 3], [1, 2, -4], dtype=dtypes.INT32)




10✔





598



    v << v.apply(unary.incrementers.plus_three)




10✔





599



    result = Vector.from_values([0, 1, 3], [4, 5, -1], dtype=dtypes.INT32)




10✔





600



    assert v.isequal(result), v




10✔





601












602



    def plus_four(x):




10✔





603



        return x + 4  # pragma: no cover










604












605



    UnaryOp.register_new("incrementers.plus_four", plus_four)




10✔





606



    assert hasattr(unary.incrementers, "plus_four")




10✔





607



    assert hasattr(op.incrementers, "plus_four")  # Also save it to `grblas.op`!




10✔





608



    v << v.apply(unary.incrementers.plus_four)  # this is in addition to the plus_three earlier




10✔





609



    result2 = Vector.from_values([0, 1, 3], [8, 9, 3], dtype=dtypes.INT32)




10✔





610



    assert v.isequal(result2), v




10✔





611












612



    def bad_will_overwrite_path(x):




10✔





613



        return x + 7  # pragma: no cover










614












615



    with pytest.raises(AttributeError):





10✔





616



        UnaryOp.register_new("incrementers", bad_will_overwrite_path)




10✔





617



    with pytest.raises(AttributeError, match="already defined"):





10✔





618



        UnaryOp.register_new("identity.newfunc", bad_will_overwrite_path)




10✔





619



    with pytest.raises(AttributeError, match="already defined"):





10✔





620



        UnaryOp.register_new("incrementers.plus_four", bad_will_overwrite_path)




10✔





621












622












623



@pytest.mark.slow




15✔





624



def test_op_namespace():




15✔





625



    assert op.abs is unary.abs




10✔





626



    assert op.minus is binary.minus




10✔





627



    assert op.plus is binary.plus




10✔





628



    assert op.plus_times is semiring.plus_times




10✔





629












630



    assert op.numpy.fabs is unary.numpy.fabs




10✔





631



    assert op.numpy.subtract is binary.numpy.subtract




10✔





632



    assert op.numpy.add is binary.numpy.add




10✔





633



    assert op.numpy.add_add is semiring.numpy.add_add




10✔





634



    assert len(dir(op)) > 300




10✔





635



    assert len(dir(op.numpy)) > 500




10✔





636












637



    with pytest.raises(




10✔





638



        AttributeError, match="module 'grblas.op.numpy' has no attribute 'bad_attr'"










639



    ):










640



        op.numpy.bad_attr




10✔





641












642



    # Make sure all have been initialized so `vars` below works










643



    for key in list(op._delayed):  # pragma: no cover










644



        getattr(op, key)










645



    opnames = {





10✔





646



        key










647



        for key, val in vars(op).items()










648



        if isinstance(val, (operator.OpBase, operator.ParameterizedUdf))










649



    }










650



    unarynames = {





10✔





651



        key










652



        for key, val in vars(unary).items()










653



        if isinstance(val, (operator.OpBase, operator.ParameterizedUdf))










654



    }










655



    binarynames = {





10✔





656



        key










657



        for key, val in vars(binary).items()










658



        if isinstance(val, (operator.OpBase, operator.ParameterizedUdf))










659



    }










660



    monoidnames = {





10✔





661



        key










662



        for key, val in vars(monoid).items()










663



        if isinstance(val, (operator.OpBase, operator.ParameterizedUdf))










664



    }










665



    semiringnames = {





10✔





666



        key










667



        for key, val in vars(semiring).items()










668



        if isinstance(val, (operator.OpBase, operator.ParameterizedUdf))










669



    }










670



    assert not unarynames - opnames, unarynames - opnames




10✔





671



    assert not binarynames - opnames, binarynames - opnames




10✔





672



    assert not monoidnames - opnames, monoidnames - opnames




10✔





673



    assert not semiringnames - opnames, semiringnames - opnames




10✔





674



    assert not opnames - (unarynames | binarynames | monoidnames | semiringnames)




10✔





675












676












677



@pytest.mark.slow




15✔





678



def test_binaryop_attributes():




15✔





679



    assert binary.plus[int].monoid is monoid.plus[int]




10✔





680



    assert binary.minus[int].monoid is None




10✔





681



    assert binary.plus.monoid is monoid.plus




10✔





682



    assert binary.minus.monoid is None




10✔





683












684



    assert binary.numpy.add[int].monoid is monoid.numpy.add[int]




10✔





685



    assert binary.numpy.subtract[int].monoid is None




10✔





686



    assert binary.numpy.add.monoid is monoid.numpy.add




10✔





687



    assert binary.numpy.subtract.monoid is None




10✔





688













689



    def plus(x, y):




10✔





690



        return x + y  # pragma: no cover










691













692



    op = BinaryOp.register_anonymous(plus, name="plus")




10✔





693



    assert op.monoid is None




10✔





694



    assert op[int].monoid is None




10✔





695












696



    assert binary.plus[int].parent is binary.plus




10✔





697



    assert binary.numpy.add[int].parent is binary.numpy.add




10✔





698



    assert op[int].parent is op




10✔





699












700



    # bad type










701



    assert binary.plus[bool].monoid is None




10✔





702



    assert binary.numpy.equal[int].monoid is None




10✔





703



    assert binary.numpy.equal[bool].monoid is monoid.numpy.equal[bool]  # sanity




10✔





704












705



    for attr, val in vars(binary).items():





10✔





706



        if not isinstance(val, BinaryOp):





10✔





707



            continue




10✔





708



        print(attr)




10✔





709



        if hasattr(monoid, attr):





10✔





710



            assert val.monoid is not None




10✔





711



            assert any(val[type_].monoid is not None for type_ in val.types)





10!





712



        else:










713



            assert val.monoid is None




10✔





714



            assert all(val[type_].monoid is None for type_ in val.types)





10✔





715












716












717



@pytest.mark.slow




15✔





718



def test_monoid_attributes():




15✔





719



    assert monoid.plus[int].binaryop is binary.plus[int]




10✔





720



    assert monoid.plus[int].identity == 0




10✔





721



    assert monoid.plus.binaryop is binary.plus




10✔





722



    assert monoid.plus.identities == {typ: 0 for typ in monoid.plus.types}





10✔





723












724



    assert monoid.numpy.add[int].binaryop is binary.numpy.add[int]




10✔





725



    assert monoid.numpy.add[int].identity == 0




10✔





726



    assert monoid.numpy.add.binaryop is binary.numpy.add




10✔





727



    assert monoid.numpy.add.identities == {typ: 0 for typ in monoid.numpy.add.types}





10✔





728












729



    binop = BinaryOp.register_anonymous(lambda x, y: x + y, name="plus")





10!





730



    op = Monoid.register_anonymous(binop, 0, name="plus")




10✔





731



    assert op.binaryop is binop




10✔





732



    assert op[int].binaryop is binop[int]




10✔





733












734



    assert monoid.plus[int].parent is monoid.plus




10✔





735



    assert monoid.numpy.add[int].parent is monoid.numpy.add




10✔





736



    assert op[int].parent is op




10✔





737












738



    for attr, val in vars(monoid).items():





10✔





739



        if not isinstance(val, Monoid):





10✔





740



            continue




10✔





741



        print(attr)




10✔





742



        assert val.binaryop is not None




10✔





743



        assert val.identities is not None




10✔





744



        for type_ in val.types:





10✔





745



            x = val[type_]




10✔





746



            assert x.binaryop is not None




10✔





747



            assert x.identity is not None




10✔





748












749












750



@pytest.mark.slow




15✔





751



def test_semiring_attributes():




15✔





752



    assert semiring.min_plus[int].monoid is monoid.min[int]




10✔





753



    assert semiring.min_plus[int].binaryop is binary.plus[int]




10✔





754



    assert semiring.min_plus.monoid is monoid.min




10✔





755



    assert semiring.min_plus.binaryop is binary.plus




10✔





756












757



    assert semiring.numpy.add_subtract[int].monoid is monoid.numpy.add[int]




10✔





758



    assert semiring.numpy.add_subtract[int].binaryop is binary.numpy.subtract[int]




10✔





759



    assert semiring.numpy.add_subtract.monoid is monoid.numpy.add




10✔





760



    assert semiring.numpy.add_subtract.binaryop is binary.numpy.subtract




10✔





761













762



    def plus(x, y):




10✔





763



        return x + y  # pragma: no cover










764













765



    binop = BinaryOp.register_anonymous(plus, name="plus")




10✔





766



    mymonoid = Monoid.register_anonymous(binop, 0, name="plus")




10✔





767



    op = Semiring.register_anonymous(mymonoid, binop, name="plus_plus")




10✔





768



    assert op.binaryop is binop




10✔





769



    assert op.binaryop[int] is binop[int]




10✔





770



    assert op.monoid is mymonoid




10✔





771



    assert op.monoid[int] is mymonoid[int]




10✔





772












773



    assert semiring.min_plus[int].parent is semiring.min_plus




10✔





774



    assert semiring.numpy.add_subtract[int].parent is semiring.numpy.add_subtract




10✔





775



    assert op[int].parent is op




10✔





776












777



    for attr, val in vars(semiring).items():





10✔





778



        if not isinstance(val, Semiring):





10✔





779



            continue




10✔





780



        print(attr)




10✔





781



        assert val.binaryop is not None




10✔





782



        assert val.monoid is not None




10✔





783



        for type_ in val.types:





10✔





784



            x = val[type_]




10✔





785



            assert x.binaryop is not None




10✔





786



            assert x.monoid is not None




10✔





787












788












789



def test_binaryop_superset_monoids():




15✔





790



    monoid_names = {x for x in dir(monoid) if not x.startswith("_")}





15✔





791



    binary_names = {x for x in dir(binary) if not x.startswith("_")}





15✔





792



    diff = monoid_names - binary_names




15✔





793



    assert not diff




15✔





794



    extras = {x for x in set(dir(monoid.numpy)) - set(dir(binary.numpy)) if not x.startswith("_")}





15✔





795



    assert not extras, ", ".join(sorted(extras))




15✔





796












797












798



def test_div_semirings():




15✔





799



    assert not hasattr(semiring, "plus_div")




15✔





800



    A1 = Matrix.from_values([0, 1], [0, 0], [-1, -3])




15✔





801



    A2 = Matrix.from_values([0, 1], [0, 0], [2, 2])




15✔





802



    result = A1.T.mxm(A2, semiring.plus_cdiv).new()




15✔





803



    assert result[0, 0].new() == -1




15✔





804



    assert result.dtype == dtypes.INT64




15✔





805












806



    result = A1.T.mxm(A2, semiring.plus_truediv).new()




15✔





807



    assert result[0, 0].new() == -2




15✔





808



    assert result.dtype == dtypes.FP64




15✔





809












810



    result = A1.T.mxm(A2, semiring.plus_floordiv).new()




15✔





811



    assert result[0, 0].new() == -3




15✔





812



    assert result.dtype == dtypes.INT64




15✔





813












814












815



@pytest.mark.slow




15✔





816



def test_get_semiring():




15✔





817



    sr = get_semiring(monoid.plus, binary.times)




10✔





818



    assert sr is semiring.plus_times




10✔





819



    # Be somewhat forgiving










820



    sr = get_semiring(monoid.plus, monoid.times)




10✔





821



    assert sr is semiring.plus_times




10✔





822



    sr = get_semiring(binary.plus, binary.times)




10✔





823



    assert sr is semiring.plus_times




10✔





824



    # But not if switched










825



    with pytest.raises(TypeError, match="switch"):





10✔





826



        get_semiring(binary.plus, monoid.times)




10✔





827












828



    def myplus(x, y):




10✔





829



        return x + y  # pragma: no cover










830












831



    binop = BinaryOp.register_anonymous(myplus, name="myplus")




10✔





832



    st = get_semiring(monoid.plus, binop)




10✔





833



    assert st.monoid is monoid.plus




10✔





834



    assert st.binaryop is binop




10✔





835












836



    binop = BinaryOp.register_new("myplus", myplus)




10✔





837



    assert binop is binary.myplus




10✔





838



    st = get_semiring(monoid.plus, binop)




10✔





839



    assert st.monoid is monoid.plus




10✔





840



    assert st.binaryop is binop




10✔





841












842



    with pytest.raises(TypeError, match="Monoid"):





10✔





843



        get_semiring(None, binary.times)




10✔





844



    with pytest.raises(TypeError, match="Binary"):





10✔





845



        get_semiring(monoid.plus, None)




10✔





846












847



    sr = get_semiring(monoid.plus, binary.numpy.copysign)




10✔





848



    assert sr.monoid is monoid.plus




10✔





849



    assert sr.binaryop is binary.numpy.copysign




10✔





850












851












852



def test_create_semiring():




15✔





853



    # stress test / sanity check










854



    monoid_names = {x for x in dir(monoid) if not x.startswith("_")}





15✔





855



    binary_names = {x for x in dir(binary) if not x.startswith("_")}





15✔





856



    for monoid_name, binary_name in itertools.product(monoid_names, binary_names):





15✔





857



        cur_monoid = getattr(monoid, monoid_name)




15✔





858



        if not isinstance(cur_monoid, Monoid):





15✔





859



            continue




15✔





860



        cur_binary = getattr(binary, binary_name)




15✔





861



        if not isinstance(cur_binary, BinaryOp):





15✔





862



            continue




15✔





863



        Semiring.register_anonymous(cur_monoid, cur_binary)




15✔





864












865












866



@pytest.mark.slow




15✔





867



def test_commutes():




15✔





868



    # Untyped










869



    assert binary.plus.commutes_to is binary.plus




10✔





870



    assert binary.plus.is_commutative




10✔





871



    assert binary.first.commutes_to is binary.second




10✔





872



    assert not binary.first.is_commutative




10✔





873



    assert monoid.plus.commutes_to is monoid.plus




10✔





874



    assert monoid.plus.is_commutative




10✔





875



    assert binary.atan2.commutes_to is None




10✔





876



    assert not binary.atan2.is_commutative




10✔





877



    assert semiring.plus_times.commutes_to is semiring.plus_times




10✔





878



    assert semiring.plus_times.is_commutative




10✔





879



    assert semiring.any_first.commutes_to is semiring.any_second




10✔





880



    assert semiring.plus_times.is_commutative




10✔





881



    assert semiring.min_secondi.commutes_to is semiring.min_firstj




10✔





882



    assert semiring.plus_pow.commutes_to is semiring.plus_rpow




10✔





883



    assert not semiring.plus_pow.is_commutative




10✔





884



    assert binary.isclose.commutes_to is binary.isclose




10✔





885



    assert binary.isclose.is_commutative




10✔





886



    assert binary.isclose(0.1).commutes_to is binary.isclose(0.1)




10✔





887



    assert binary.floordiv.commutes_to is binary.rfloordiv




10✔





888



    assert not binary.floordiv.is_commutative




10✔





889



    assert binary.numpy.add.commutes_to is binary.numpy.add




10✔





890



    assert binary.numpy.add.is_commutative




10✔





891



    assert binary.numpy.less.commutes_to is binary.numpy.greater




10✔





892



    assert not binary.numpy.less.is_commutative




10✔





893












894



    # Typed










895



    assert binary.plus[int].commutes_to is binary.plus[int]




10✔





896



    assert binary.plus[int].is_commutative




10✔





897



    assert binary.first[int].commutes_to is binary.second[int]




10✔





898



    assert not binary.first[int].is_commutative




10✔





899



    assert monoid.plus[int].commutes_to is monoid.plus[int]




10✔





900



    assert monoid.plus[int].is_commutative




10✔





901



    assert binary.atan2[int].commutes_to is None




10✔





902



    assert not binary.atan2[int].is_commutative




10✔





903



    assert semiring.plus_times[int].commutes_to is semiring.plus_times[int]




10✔





904



    assert semiring.plus_times[int].is_commutative




10✔





905



    assert semiring.any_first[int].commutes_to is semiring.any_second[int]




10✔





906



    assert semiring.plus_times[int].is_commutative




10✔





907



    assert semiring.min_secondi[int].commutes_to is semiring.min_firstj[int]




10✔





908



    assert semiring.plus_pow[int].commutes_to is semiring.plus_rpow[int]




10✔





909



    assert not semiring.plus_pow[int].is_commutative




10✔





910



    assert binary.isclose(0.1)[int].commutes_to is binary.isclose(0.1)[int]




10✔





911



    assert binary.floordiv[int].commutes_to is binary.rfloordiv[int]




10✔





912



    assert not binary.floordiv[int].is_commutative




10✔





913



    assert binary.numpy.add[int].commutes_to is binary.numpy.add[int]




10✔





914



    assert binary.numpy.add[int].is_commutative




10✔





915



    assert binary.numpy.less[int].commutes_to is binary.numpy.greater[int]




10✔





916



    assert not binary.numpy.less[int].is_commutative




10✔





917












918



    # Stress test (this can create extra semirings)










919



    names = dir(semiring)




10✔





920



    for name in names:





10✔





921



        val = getattr(semiring, name)




10✔





922



        if not hasattr(val, "commutes_to"):





10✔





923



            continue




10✔





924



        assert val.commutes_to is None or isinstance(val.commutes_to, type(val))




10✔





925












926












927



def test_from_string():




15✔





928



    assert unary.from_string("-") is unary.ainv




15✔





929



    assert unary.from_string("abs[float]") is unary.abs[float]




15✔





930



    assert binary.from_string("+") is binary.plus




15✔





931



    assert binary.from_string("-[int]") is binary.minus[int]




15✔





932



    assert binary.from_string("true_divide") is binary.numpy.true_divide




15✔





933



    assert binary.from_string("//") is binary.floordiv




15✔





934



    assert binary.from_string("%") is binary.numpy.mod




15✔





935



    assert monoid.from_string("*[FP64]") is monoid.times["FP64"]




15✔





936



    assert semiring.from_string("min.plus") is semiring.min_plus




15✔





937



    assert semiring.from_string("min.+") is semiring.min_plus




15✔





938



    assert semiring.from_string("min_plus") is semiring.min_plus




15✔





939












940



    with pytest.raises(ValueError, match="does not end with"):





15✔





941



        assert binary.from_string("plus[int")




15✔





942



    with pytest.raises(ValueError, match="too many"):





15✔





943



        assert binary.from_string("plus[int][float]")




15✔





944



    with pytest.raises(ValueError, match="not matched by"):





15✔





945



        assert binary.from_string("plus][int]")




15✔





946



    with pytest.raises(ValueError, match="does not end with"):





15✔





947



        assert binary.from_string("plus[int]extra")




15✔





948



    with pytest.raises(ValueError, match="Unknown binary string"):





15✔





949



        assert binary.from_string("")




15✔





950



    with pytest.raises(ValueError, match="Unknown binary string"):





15✔





951



        assert binary.from_string("badname")




15✔





952



    with pytest.raises(ValueError, match="Bad semiring string"):





15✔





953



        assert semiring.from_string("badname")




15✔





954



    with pytest.raises(ValueError, match="Bad semiring string"):





15✔





955



        semiring.from_string("min.plus.times")




15✔





956












957



    assert op.from_string("-") is unary.ainv




15✔





958



    assert op.from_string("+") is binary.plus




15✔





959



    assert op.from_string("min.plus") is semiring.min_plus




15✔





960



    with pytest.raises(ValueError, match="Unknown op string"):





15✔





961



        op.from_string("min.plus.times")




15✔





962












963



    assert agg.from_string("count") is agg.count




15✔





964



    assert agg.from_string("|") is agg.any




15✔





965



    assert agg.from_string("+[int]") is agg.sum[int]




15✔





966



    with pytest.raises(ValueError, match="Unknown agg string"):





15✔





967



        agg.from_string("bad_agg")




15✔





968












969












970



@pytest.mark.slow




15✔





971



def test_lazy_op():




15✔






972



    UnaryOp.register_new("lazy", lambda x: x, lazy=True)  # pragma: no branch





10✔





973



    assert isinstance(op.lazy, UnaryOp)




10✔





974



    assert isinstance(unary.lazy, UnaryOp)




10✔






975



    BinaryOp.register_new("lazy", lambda x, y: x + y, lazy=True)  # pragma: no branch





10✔





976



    Monoid.register_new("lazy", "lazy", 0, lazy=True)




10✔





977



    assert isinstance(monoid.lazy, Monoid)




10✔





978



    assert isinstance(binary.lazy, BinaryOp)




10✔





979



    Monoid.register_new("lazy2", binary.lazy, 0, lazy=True)




10✔





980



    assert isinstance(op.lazy2, Monoid)




10✔





981



    assert isinstance(monoid.lazy2, Monoid)




10✔





982



    Semiring.register_new("lazy", "lazy", "lazy", lazy=True)




10✔





983



    assert isinstance(semiring.lazy, Semiring)




10✔





984



    Semiring.register_new("lazy_lazy", monoid.lazy, binary.lazy, lazy=True)




10✔





985



    assert isinstance(semiring.lazy_lazy, Semiring)




10✔





986



    # numpy











987



    UnaryOp.register_new("numpy.lazy", lambda x: x, lazy=True)  # pragma: no branch





10✔





988



    assert isinstance(unary.numpy.lazy, UnaryOp)




10✔






989



    BinaryOp.register_new("numpy.lazy", lambda x, y: x + y, lazy=True)  # pragma: no branch





10✔





990



    Monoid.register_new("numpy.lazy", "numpy.lazy", 0, lazy=True)




10✔





991



    assert isinstance(monoid.numpy.lazy, Monoid)




10✔





992



    assert isinstance(binary.numpy.lazy, BinaryOp)




10✔





993



    Monoid.register_new("numpy.lazy2", binary.numpy.lazy, 0, lazy=True)




10✔





994



    assert isinstance(operator.get_semiring(monoid.numpy.lazy2, binary.numpy.lazy), Semiring)




10✔





995



    assert isinstance(op.numpy.lazy2, Monoid)




10✔





996



    assert isinstance(monoid.numpy.lazy2, Monoid)




10✔





997



    Semiring.register_new("numpy.lazy", "numpy.lazy", "numpy.lazy", lazy=True)




10✔





998



    assert isinstance(semiring.numpy.lazy, Semiring)




10✔





999



    Semiring.register_new("numpy.lazy_lazy", monoid.numpy.lazy, binary.numpy.lazy, lazy=True)




10✔





1000



    assert isinstance(semiring.numpy.lazy_lazy, Semiring)




10✔





1001



    # misc











1002



    UnaryOp.register_new("misc.lazy", lambda x: x, lazy=True)  # pragma: no branch





10✔





1003



    assert isinstance(unary.misc.lazy, UnaryOp)




10✔





1004



    with pytest.raises(AttributeError):





10✔





1005



        unary.misc.bad




10✔





1006



    with pytest.raises(ValueError):





10✔





1007



        unary.from_string("misc.lazy.badpath")




10✔





1008



    assert op.from_string("lazy") is unary.lazy




10✔





1009



    assert op.from_string("numpy.lazy") is unary.numpy.lazy




10✔





1010












1011












1012



def test_positional():




15✔





1013



    assert unary.positioni.is_positional




15✔





1014



    assert unary.positioni1[int].is_positional




15✔





1015



    assert unary.positionj1.is_positional




15✔





1016



    assert unary.positionj[float].is_positional




15✔





1017



    assert not unary.exp.is_positional




15✔





1018



    assert not unary.abs[bool].is_positional




15✔





1019












1020



    assert binary.firsti.is_positional




15✔





1021



    assert binary.secondj1[int].is_positional




15✔





1022



    assert not binary.plus.is_positional




15✔





1023



    assert not binary.minus[float].is_positional




15✔





1024












1025



    assert not monoid.plus.is_positional




15✔





1026



    assert not monoid.plus[int].is_positional




15✔





1027












1028



    assert semiring.any_firsti.is_positional




15✔





1029



    assert semiring.any_secondj[int].is_positional




15✔





1030



    assert not semiring.any_first.is_positional




15✔





1031



    assert not semiring.any_second[int].is_positional




15✔





1032












1033













1034



def test_udt():




15✔






1035



    record_dtype = np.dtype([("x", np.bool_), ("y", np.float64)], align=True)




15✔






1036



    udt = dtypes.register_new("TestUDT", record_dtype)




15✔






1037



    assert not udt._is_anonymous




15✔






1038



    v = Vector.new(udt, size=3)




15✔






1039



    w = Vector.new(udt, size=3)




15✔






1040



    v[:] = 0




15✔






1041



    w[:] = 1




15✔





1042













1043



    def _udt_identity(val):




15✔





1044



        return val  # pragma: no cover










1045













1046



    udt_identity = UnaryOp.register_new("udt_identity", _udt_identity, is_udt=True)




15✔






1047



    assert udt in udt_identity




15✔






1048



    assert udt in binary.eq




15✔






1049



    result = v.apply(udt_identity).new()




15✔






1050



    assert result.isequal(v)




15✔






1051



    assert dtypes.UINT8 in udt_identity




15✔






1052



    assert udt in udt_identity




15✔






1053



    assert int in udt_identity




15✔






1054



    assert operator.get_typed_op(udt_identity, udt) is udt_identity[udt]




15✔






1055



    with pytest.raises(ValueError):





15✔





1056



        "badname" in binary.eq











1057



    with pytest.raises(ValueError):





15✔





1058



        "badname" in udt_identity










1059













1060



    def _udt_getx(val):




15✔





1061



        return val["x"]  # pragma: no cover










1062













1063



    udt_getx = UnaryOp.register_anonymous(_udt_getx, "udt_getx", is_udt=True)




15✔






1064



    assert udt in udt_getx




15✔






1065



    result = v.apply(udt_getx).new()




15✔






1066



    expected = Vector.from_values([0, 1, 2], 0)




15✔






1067



    assert result.isequal(expected)




15✔





1068













1069



    def _udt_first(x, y):




15✔





1070



        return x  # pragma: no cover










1071













1072



    udt_first = BinaryOp.register_anonymous(_udt_first, "udt_first", is_udt=True)




15✔






1073



    assert udt in udt_first




15✔






1074



    assert operator.get_typed_op(udt_first, udt) is udt_first[udt]




15✔






1075



    assert udt_first(v & w).new().isequal(v)




15✔






1076



    assert udt_first(v, 1).new().isequal(v)




15✔






1077



    assert udt_first[udt, dtypes.INT64].return_type == udt




15✔






1078



    assert udt_first[dtypes.INT64, udt].return_type == dtypes.INT64




15✔





1079













1080



    udt_any = Monoid.register_new("udt_any", udt_first, (0, 0))




15✔






1081



    assert udt in udt_any




15✔






1082



    assert (udt, udt) in udt_any




15✔






1083



    assert (udt, dtypes.INT8) not in udt_any




15✔






1084



    assert operator.get_typed_op(udt_any, udt) is udt_any[udt]




15✔






1085



    assert udt_any(v | w).new().isequal(v)




15✔





1086













1087



    udt_semiring = Semiring.register_new("udt_semiring", udt_any, udt_first)




15✔






1088



    assert udt in udt_semiring




15✔






1089



    assert operator.get_typed_op(udt_semiring, udt) is udt_semiring[udt]




15✔






1090



    assert udt_semiring(v @ v).new() == (0, 0)




15✔





1091













1092



    result = v.apply(gb.unary.identity).new()




15✔






1093



    assert result.isequal(v)




15✔






1094



    result = v.apply(gb.unary.one).new()




15✔






1095



    assert result.dtype == dtypes.INT64




15✔






1096



    expected = Vector.new(int, size=v.size)




15✔






1097



    expected(result.S) << 1




15✔






1098



    assert result.isequal(expected)




15✔






1099



    result = v.apply(gb.unary.positioni).new()




15✔






1100



    expected = expected.apply(gb.unary.positioni).new()




15✔






1101



    assert result.isequal(expected)




15✔





1102













1103



    class BreakCompile:





15✔






1104



        pass




15✔





1105













1106



    def badfunc(x):




15✔






NEW


1107



        return BreakCompile(x)




×







1108













1109



    badunary = UnaryOp.register_anonymous(badfunc, is_udt=True)




15✔






1110



    assert udt not in badunary




15✔






1111



    assert int not in badunary




15✔





1112













1113



    def badfunc(x, y):




15✔






NEW


1114



        return BreakCompile(x)




×







1115













1116



    badbinary = BinaryOp.register_anonymous(badfunc, is_udt=True)




15✔






1117



    assert udt not in badbinary




15✔






1118



    assert int not in badbinary




15✔





1119












1120












1121



def test_dir():




15✔





1122



    for mod in [unary, binary, monoid, semiring, op]:





15✔





1123



        assert not set(mod._delayed) - set(dir(mod))




15✔





1124












1125












1126



def test_semiring_commute_exists():




15✔





1127



    from .conftest import orig_semirings




15✔





1128












1129



    vals = {getattr(semiring, key) for key in orig_semirings}





15✔





1130



    missing = set()




15✔





1131



    for key in orig_semirings:





15✔





1132



        val = getattr(semiring, key)




15✔





1133



        commutes_to = val.commutes_to




15✔





1134



        if commutes_to is not None and commutes_to not in vals:  # pragma: no cover










1135



            missing.add(commutes_to.name)










1136



    if missing:




15✔





1137



        raise AssertionError("Missing semirings: " + ", ".join(sorted(missing)))










1138












1139












1140



def test_binaryop_commute_exists():




15✔





1141



    from .conftest import orig_binaryops




15✔





1142












1143



    vals = {getattr(binary, key) for key in orig_binaryops}





15✔





1144



    missing = set()




15✔





1145



    for key in orig_binaryops:





15✔





1146



        val = getattr(binary, key)




15✔





1147



        commutes_to = val.commutes_to




15✔





1148



        if commutes_to is not None and commutes_to not in vals:  # pragma: no cover










1149



            missing.add(commutes_to.name)










1150



    if missing:




15✔





1151



        raise AssertionError("Missing binaryops: " + ", ".join(sorted(missing)))
























    

  • 

    •