From 7f151aa69905a03977e9a0bedd7e40c03f63f7c4 Mon Sep 17 00:00:00 2001 From: mhmerrill Date: Fri, 20 Sep 2019 22:30:42 -0400 Subject: [PATCH] cleaned up some tests --- test/UnitTestargsortDRS.chpl | 61 -- test/argsortDRS_test.chpl | 24 - test/groupby_test.chpl | 43 -- tests/operator_log.txt | 1138 ---------------------------------- 4 files changed, 1266 deletions(-) delete mode 100644 test/UnitTestargsortDRS.chpl delete mode 100644 test/argsortDRS_test.chpl delete mode 100644 test/groupby_test.chpl delete mode 100644 tests/operator_log.txt diff --git a/test/UnitTestargsortDRS.chpl b/test/UnitTestargsortDRS.chpl deleted file mode 100644 index d6faa7b369..0000000000 --- a/test/UnitTestargsortDRS.chpl +++ /dev/null @@ -1,61 +0,0 @@ -module UnitTestargsortDRS -{ - use ArgsortDRS; - - // fill a with integers from interval aMin..(aMax-1) - proc fillRandInt(a: [?aD] int, aMin: int, aMax: int) { - - var t1 = Time.getCurrentTime(); - coforall loc in Locales { - on loc { - var R = new owned RandomStream(real); R.getNext(); - [i in a.localSubdomain()] a[i] = (R.getNext() * (aMax - aMin) + aMin):int; - } - } - writeln("compute time = ",Time.getCurrentTime() - t1,"sec"); try! stdout.flush(); - - } - proc isSorted(A:[?D] ?t): bool { - var sorted: bool; - sorted = true; - forall (a,i) in zip(A,D) with (&& reduce sorted) { - if i > D.low { - sorted &&= (A[i-1] <= a); - } - } - return sorted; - } - - proc test_argsort(n: int, nVals: int) { - const blockDom = newBlockDom({0..#n}); - var a: [blockDom] int; - - var aMin = 0; - var aMax = nVals-1; - writeln((n, nVals)); - // fill an array with random ints from a range - fillRandInt(a, aMin, aMax+1); - - var localCopy:[0..#n] int = a; - - writeln(">>> argsortDRS"); - var t1 = Time.getCurrentTime(); - // returns a perm vector - var iv = argsortDRS(a, aMin, aMax); - writeln("sort time = ",Time.getCurrentTime() - t1,"sec"); try! stdout.flush(); - - // permute into sorted order - var sorted: [a.domain] int = a[iv]; - - // check to see if we successfully sorted a - writeln("<<< isSorted = ", isSorted(sorted)); - } - - config const N = 1000; - config const NVALS = 8192; - - proc main() { - test_argsort(N, NVALS); - } - -} diff --git a/test/argsortDRS_test.chpl b/test/argsortDRS_test.chpl deleted file mode 100644 index b5750b8688..0000000000 --- a/test/argsortDRS_test.chpl +++ /dev/null @@ -1,24 +0,0 @@ -use ArgsortDRS; -use Sort only isSorted; -use BlockDist; -use Random; -use Math only abs; - -config const LEN = 1_000_000; - -writeln("Initializing..."); -var D = {0..#LEN}; -var DD: domain(1) dmapped Block(boundingBox=D) = D; -var A: [DD] int; -fillRandom(A); -// Squeeze values into [0, 2**32) -A = abs(A) % 2**32; -var aMin = min reduce A; -var aMax = max reduce A; -writeln("A = ", A[0..#5]); -writeln("aMin = ", aMin, ", aMax = ", aMax); - -writeln("Sorting with argsortDRS..."); -var iv = argsortDRS(A, aMin, aMax); -var B = A[iv]; -writeln("Result is sorted? ", isSorted(B)); \ No newline at end of file diff --git a/test/groupby_test.chpl b/test/groupby_test.chpl deleted file mode 100644 index d3c5ce80c6..0000000000 --- a/test/groupby_test.chpl +++ /dev/null @@ -1,43 +0,0 @@ -use ReductionMsg; -use MultiTypeSymEntry; - -proc main() { - var unique_keys = [ 0, 1, 2, 4, 5, 7, 9, 10, 11]; - var perm_keys = [ 0, 9, 10, - 0, 4, 5, - 1, 2, 7, - 2, 5, 11]; - var keyD = makeDistArray(perm_keys.size, int); - keyD = perm_keys; - var segments = [ 0, 1, 1, 1, 1, 1, 1, 2, 3, - 3, 4, 4, 4, 5, 6, 6, 6, 6, - 6, 6, 7, 8, 8, 8, 9, 9, 9, - 9, 9, 9, 10, 10, 11, 11, 11, 11]; - var segD = makeDistArray(segments.size, int); - segD = segments; - var values = [ 2, 1, 0, - 4, 3, 5, - 6, 7, 8, - 9, 11, 10]; - var valD = makeDistArray(values.size, int); - valD = values; - writeln("segD = ", segD); - writeln("valD = ", valD); - - write_result("count", unique_keys, perLocCount(segD, valD.size)); - write_result("sum", unique_keys, perLocSum(valD, segD)); - write_result("prod", unique_keys, perLocProduct(keyD, valD, segD)); - write_result("mean", unique_keys, perLocMean(valD, segD)); - write_result("min", unique_keys, perLocMin(keyD, valD, segD)); - write_result("max", unique_keys, perLocMax(keyD, valD, segD)); - write_result("argmin", unique_keys, perLocArgmin(keyD, valD, segD)); - write_result("argmax", unique_keys, perLocArgmax(keyD, valD, segD)); - write_result("nunique", unique_keys, perLocNumUnique(valD, segD)); -} - -proc write_result(op, keys, vals) { - writeln(op); - for (k, v) in zip(keys, vals) { - writeln(k, ": ", v); - } -} \ No newline at end of file diff --git a/tests/operator_log.txt b/tests/operator_log.txt deleted file mode 100644 index a84d31dc16..0000000000 --- a/tests/operator_log.txt +++ /dev/null @@ -1,1138 +0,0 @@ -./operator_tests.py:72: UserWarning: Error computing int64(array) % float64(array) -Error: binopvv: int64 % float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) % float64(scalar) -Error: binopvs: int64 % float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) % float64(array) -Error: binopsv: int64 % float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:96: UserWarning: result mismatch: int64(array) // float64(array) = -np: [nan 18. 13. 12. 11. 10. 10. 10. 10. 10.] -ak: [inf 18. 13. 12. 11. 10. 10. 10. 10. 10.] - warnings.warn("result mismatch: {} =\n{}".format(expression, res)) -./operator_tests.py:96: UserWarning: result mismatch: int64(scalar) // float64(array) = -np: [nan 45. 22. 15. 11. 8. 7. 6. 5. 5.] -ak: [inf 45. 22. 15. 11. 9. 7. 6. 5. 5.] - warnings.warn("result mismatch: {} =\n{}".format(expression, res)) -./operator_tests.py:1: RuntimeWarning: divide by zero encountered in true_divide - #!/usr/bin/env python3 -./operator_tests.py:72: UserWarning: Error computing int64(array) == bool(array) -Error: binopvv: int64 == bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) == bool(scalar) -Error: binopvs: int64 == bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) == bool(array) -Error: binopvs: bool == int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) > bool(array) -Error: binopvv: int64 > bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) > bool(scalar) -Error: binopvs: int64 > bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) > bool(array) -Error: binopvs: bool < int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) != bool(array) -Error: binopvv: int64 != bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) != bool(scalar) -Error: binopvs: int64 != bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) != bool(array) -Error: binopvs: bool != int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) <= bool(array) -Error: binopvv: int64 <= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) <= bool(scalar) -Error: binopvs: int64 <= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) <= bool(array) -Error: binopvs: bool >= int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:1: RuntimeWarning: divide by zero encountered in remainder - #!/usr/bin/env python3 -./operator_tests.py:72: UserWarning: Error computing int64(array) % bool(array) -Error: binopvv: int64 % bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) % bool(scalar) -Error: binopvs: int64 % bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) % bool(array) -Error: binopsv: int64 % bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) & bool(array) -Error: binopvv: int64 & bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) & bool(scalar) -Error: binopvs: int64 & bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) & bool(array) -Error: binopsv: int64 & bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) ^ bool(array) -Error: binopvv: int64 ^ bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) ^ bool(scalar) -Error: binopvs: int64 ^ bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) ^ bool(array) -Error: binopsv: int64 ^ bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) | bool(array) -Error: binopvv: int64 | bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) | bool(scalar) -Error: binopvs: int64 | bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) | bool(array) -Error: binopsv: int64 | bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) >> bool(array) -Error: binopvv: int64 >> bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) >> bool(scalar) -Error: binopvs: int64 >> bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) >> bool(array) -Error: binopsv: int64 >> bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) >= bool(array) -Error: binopvv: int64 >= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) >= bool(scalar) -Error: binopvs: int64 >= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) >= bool(array) -Error: binopvs: bool <= int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) << bool(array) -Error: binopvv: int64 << bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) << bool(scalar) -Error: binopvs: int64 << bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) << bool(array) -Error: binopsv: int64 << bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:1: RuntimeWarning: divide by zero encountered in floor_divide - #!/usr/bin/env python3 -./operator_tests.py:72: UserWarning: Error computing int64(array) // bool(array) -Error: binopvv: int64 // bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) // bool(scalar) -Error: binopvs: int64 // bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) // bool(array) -Error: binopsv: int64 // bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) < bool(array) -Error: binopvv: int64 < bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) < bool(scalar) -Error: binopvs: int64 < bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) < bool(array) -Error: binopvs: bool > int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) / bool(array) -Error: binopvv: int64 / bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(array) / bool(scalar) -Error: binopvs: int64 / bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing int64(scalar) / bool(array) -Error: binopsv: int64 / bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) % int64(array) -Error: binopvv: float64 % int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) % int64(scalar) -Error: binopvs: float64 % int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) % int64(array) -Error: binopsv: float64 % int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) % float64(array) -Error: binopvv: float64 % float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) % float64(scalar) -Error: binopvs: float64 % float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) % float64(array) -Error: binopsv: float64 % float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:96: UserWarning: result mismatch: float64(scalar) // float64(array) = -np: [nan 28. 14. 9. 7. 5. 4. 4. 3. 3.] -ak: [inf 28. 14. 9. 7. 5. 4. 4. 3. 3.] - warnings.warn("result mismatch: {} =\n{}".format(expression, res)) -./operator_tests.py:1: RuntimeWarning: invalid value encountered in true_divide - #!/usr/bin/env python3 -./operator_tests.py:72: UserWarning: Error computing float64(array) == bool(array) -Error: binopvv: float64 == bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) == bool(scalar) -Error: binopvs: float64 == bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) == bool(array) -Error: binopvs: bool == float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) > bool(array) -Error: binopvv: float64 > bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) > bool(scalar) -Error: binopvs: float64 > bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) > bool(array) -Error: binopvs: bool < float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) != bool(array) -Error: binopvv: float64 != bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) != bool(scalar) -Error: binopvs: float64 != bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) != bool(array) -Error: binopvs: bool != float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) <= bool(array) -Error: binopvv: float64 <= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) <= bool(scalar) -Error: binopvs: float64 <= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) <= bool(array) -Error: binopvs: bool >= float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) % bool(array) -Error: binopvv: float64 % bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) % bool(scalar) -Error: binopvs: float64 % bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) % bool(array) -Error: binopsv: float64 % bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) >= bool(array) -Error: binopvv: float64 >= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) >= bool(scalar) -Error: binopvs: float64 >= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) >= bool(array) -Error: binopvs: bool <= float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) // bool(array) -Error: binopvv: float64 // bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) // bool(scalar) -Error: binopvs: float64 // bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) // bool(array) -Error: binopsv: float64 // bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) < bool(array) -Error: binopvv: float64 < bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) < bool(scalar) -Error: binopvs: float64 < bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) < bool(array) -Error: binopvs: bool > float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) / bool(array) -Error: binopvv: float64 / bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(array) / bool(scalar) -Error: binopvs: float64 / bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing float64(scalar) / bool(array) -Error: binopsv: float64 / bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) == int64(array) -Error: binopvv: bool == int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) == int64(scalar) -Error: binopvs: bool == int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) == int64(array) -Error: binopvs: int64 == bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) > int64(array) -Error: binopvv: bool > int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) > int64(scalar) -Error: binopvs: bool > int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) > int64(array) -Error: binopvs: int64 < bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) != int64(array) -Error: binopvv: bool != int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) != int64(scalar) -Error: binopvs: bool != int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) != int64(array) -Error: binopvs: int64 != bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) <= int64(array) -Error: binopvv: bool <= int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) <= int64(scalar) -Error: binopvs: bool <= int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) <= int64(array) -Error: binopvs: int64 >= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) % int64(array) -Error: binopvv: bool % int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) % int64(scalar) -Error: binopvs: bool % int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) % int64(array) -Error: binopsv: bool % int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) & int64(array) -Error: binopvv: bool & int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) & int64(scalar) -Error: binopvs: bool & int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) & int64(array) -Error: binopsv: bool & int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) ^ int64(array) -Error: binopvv: bool ^ int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) ^ int64(scalar) -Error: binopvs: bool ^ int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) ^ int64(array) -Error: binopsv: bool ^ int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) | int64(array) -Error: binopvv: bool | int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) | int64(scalar) -Error: binopvs: bool | int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) | int64(array) -Error: binopsv: bool | int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) >> int64(array) -Error: binopvv: bool >> int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) >> int64(scalar) -Error: binopvs: bool >> int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) >> int64(array) -Error: binopsv: bool >> int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) >= int64(array) -Error: binopvv: bool >= int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) >= int64(scalar) -Error: binopvs: bool >= int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) >= int64(array) -Error: binopvs: int64 <= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) << int64(array) -Error: binopvv: bool << int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) << int64(scalar) -Error: binopvs: bool << int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) << int64(array) -Error: binopsv: bool << int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) // int64(array) -Error: binopvv: bool // int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) // int64(scalar) -Error: binopvs: bool // int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) // int64(array) -Error: binopsv: bool // int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) < int64(array) -Error: binopvv: bool < int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) < int64(scalar) -Error: binopvs: bool < int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) < int64(array) -Error: binopvs: int64 > bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) / int64(array) -Error: binopvv: bool / int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) / int64(scalar) -Error: binopvs: bool / int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) / int64(array) -Error: binopsv: bool / int64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) == float64(array) -Error: binopvv: bool == float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) == float64(scalar) -Error: binopvs: bool == float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) == float64(array) -Error: binopvs: float64 == bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) > float64(array) -Error: binopvv: bool > float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) > float64(scalar) -Error: binopvs: bool > float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) > float64(array) -Error: binopvs: float64 < bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) != float64(array) -Error: binopvv: bool != float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) != float64(scalar) -Error: binopvs: bool != float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) != float64(array) -Error: binopvs: float64 != bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) <= float64(array) -Error: binopvv: bool <= float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) <= float64(scalar) -Error: binopvs: bool <= float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) <= float64(array) -Error: binopvs: float64 >= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) % float64(array) -Error: binopvv: bool % float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) % float64(scalar) -Error: binopvs: bool % float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) % float64(array) -Error: binopsv: bool % float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) >= float64(array) -Error: binopvv: bool >= float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) >= float64(scalar) -Error: binopvs: bool >= float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) >= float64(array) -Error: binopvs: float64 <= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) // float64(array) -Error: binopvv: bool // float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) // float64(scalar) -Error: binopvs: bool // float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) // float64(array) -Error: binopsv: bool // float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) < float64(array) -Error: binopvv: bool < float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) < float64(scalar) -Error: binopvs: bool < float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) < float64(array) -Error: binopvs: float64 > bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) / float64(array) -Error: binopvv: bool / float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) / float64(scalar) -Error: binopvs: bool / float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) / float64(array) -Error: binopsv: bool / float64 not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) == bool(array) -Error: binopvv: bool == bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) == bool(scalar) -Error: binopvs: bool == bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) == bool(array) -Error: binopvs: bool == bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) > bool(array) -Error: binopvv: bool > bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) > bool(scalar) -Error: binopvs: bool > bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) > bool(array) -Error: binopvs: bool < bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) != bool(array) -Error: binopvv: bool != bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) != bool(scalar) -Error: binopvs: bool != bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) != bool(array) -Error: binopvs: bool != bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) <= bool(array) -Error: binopvv: bool <= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) <= bool(scalar) -Error: binopvs: bool <= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) <= bool(array) -Error: binopvs: bool >= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) % bool(array) -Error: binopvv: bool % bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) % bool(scalar) -Error: binopvs: bool % bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) % bool(array) -Error: binopsv: bool % bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -4.3.1 -psp = tcp://localhost:5555 -connected to tcp://localhost:5555 -Dtypes: dict_keys(['int64', 'float64', 'bool']) -pdarrays: -int64 : [1 2 3 4 5 6 7 8 9 10] -float64 : [0.000000e+00 1.111111e-01 2.222222e-01 3.333333e-01 4.444444e-01 5.555556e-01 6.666667e-01 7.777778e-01 8.888889e-01 1.000000e+00] -bool : [True False True False True False True False True False] -ndarrays: -int64 : [ 1 2 3 4 5 6 7 8 9 10] -float64 : [0. 0.11111111 0.22222222 0.33333333 0.44444444 0.55555556 - 0.66666667 0.77777778 0.88888889 1. ] -bool : [ True False True False True False True False True False] -scalars: -int64 : 5 -float64 : 3.14159 -bool : True -78 not_implemented -int64(array) & float64(array) -Error: binopvv: int64 & float64 not implemented -int64(array) & float64(scalar) -Error: binopvs: int64 & float64 not implemented -int64(scalar) & float64(array) -Error: binopsv: int64 & float64 not implemented -int64(array) ^ float64(array) -Error: binopvv: int64 ^ float64 not implemented -int64(array) ^ float64(scalar) -Error: binopvs: int64 ^ float64 not implemented -int64(scalar) ^ float64(array) -Error: binopsv: int64 ^ float64 not implemented -int64(array) | float64(array) -Error: binopvv: int64 | float64 not implemented -int64(array) | float64(scalar) -Error: binopvs: int64 | float64 not implemented -int64(scalar) | float64(array) -Error: binopsv: int64 | float64 not implemented -int64(array) >> float64(array) -Error: binopvv: int64 >> float64 not implemented -int64(array) >> float64(scalar) -Error: binopvs: int64 >> float64 not implemented -int64(scalar) >> float64(array) -Error: binopsv: int64 >> float64 not implemented -int64(array) << float64(array) -Error: binopvv: int64 << float64 not implemented -int64(array) << float64(scalar) -Error: binopvs: int64 << float64 not implemented -int64(scalar) << float64(array) -Error: binopsv: int64 << float64 not implemented -float64(array) & int64(array) -Error: binopvv: float64 & int64 not implemented -float64(array) & int64(scalar) -Error: binopvs: float64 & int64 not implemented -float64(scalar) & int64(array) -Error: binopsv: float64 & int64 not implemented -float64(array) ^ int64(array) -Error: binopvv: float64 ^ int64 not implemented -float64(array) ^ int64(scalar) -Error: binopvs: float64 ^ int64 not implemented -float64(scalar) ^ int64(array) -Error: binopsv: float64 ^ int64 not implemented -float64(array) | int64(array) -Error: binopvv: float64 | int64 not implemented -float64(array) | int64(scalar) -Error: binopvs: float64 | int64 not implemented -float64(scalar) | int64(array) -Error: binopsv: float64 | int64 not implemented -float64(array) >> int64(array) -Error: binopvv: float64 >> int64 not implemented -float64(array) >> int64(scalar) -Error: binopvs: float64 >> int64 not implemented -float64(scalar) >> int64(array) -Error: binopsv: float64 >> int64 not implemented -float64(array) << int64(array) -Error: binopvv: float64 << int64 not implemented -float64(array) << int64(scalar) -Error: binopvs: float64 << int64 not implemented -float64(scalar) << int64(array) -Error: binopsv: float64 << int64 not implemented -float64(array) & float64(array) -Error: binopvv: float64 & float64 not implemented -float64(array) & float64(scalar) -Error: binopvs: float64 & float64 not implemented -float64(scalar) & float64(array) -Error: binopsv: float64 & float64 not implemented -float64(array) ^ float64(array) -Error: binopvv: float64 ^ float64 not implemented -float64(array) ^ float64(scalar) -Error: binopvs: float64 ^ float64 not implemented -float64(scalar) ^ float64(array) -Error: binopsv: float64 ^ float64 not implemented -float64(array) | float64(array) -Error: binopvv: float64 | float64 not implemented -float64(array) | float64(scalar) -Error: binopvs: float64 | float64 not implemented -float64(scalar) | float64(array) -Error: binopsv: float64 | float64 not implemented -float64(array) >> float64(array) -Error: binopvv: float64 >> float64 not implemented -float64(array) >> float64(scalar) -Error: binopvs: float64 >> float64 not implemented -float64(scalar) >> float64(array) -Error: binopsv: float64 >> float64 not implemented -float64(array) << float64(array) -Error: binopvv: float64 << float64 not implemented -float64(array) << float64(scalar) -Error: binopvs: float64 << float64 not implemented -float64(scalar) << float64(array) -Error: binopsv: float64 << float64 not implemented -float64(array) & bool(array) -Error: binopvv: float64 & bool not implemented -float64(array) & bool(scalar) -Error: binopvs: float64 & bool not implemented -float64(scalar) & bool(array) -Error: binopsv: float64 & bool not implemented -float64(array) ^ bool(array) -Error: binopvv: float64 ^ bool not implemented -float64(array) ^ bool(scalar) -Error: binopvs: float64 ^ bool not implemented -float64(scalar) ^ bool(array) -Error: binopsv: float64 ^ bool not implemented -float64(array) | bool(array) -Error: binopvv: float64 | bool not implemented -float64(array) | bool(scalar) -Error: binopvs: float64 | bool not implemented -float64(scalar) | bool(array) -Error: binopsv: float64 | bool not implemented -float64(array) >> bool(array) -Error: binopvv: float64 >> bool not implemented -float64(array) >> bool(scalar) -Error: binopvs: float64 >> bool not implemented -float64(scalar) >> bool(array) -Error: binopsv: float64 >> bool not implemented -float64(array) << bool(array) -Error: binopvv: float64 << bool not implemented -float64(array) << bool(scalar) -Error: binopvs: float64 << bool not implemented -float64(scalar) << bool(array) -Error: binopsv: float64 << bool not implemented -bool(array) & float64(array) -Error: binopvv: bool & float64 not implemented -bool(array) & float64(scalar) -Error: binopvs: bool & float64 not implemented -bool(scalar) & float64(array) -Error: binopsv: bool & float64 not implemented -bool(array) ^ float64(array) -Error: binopvv: bool ^ float64 not implemented -bool(array) ^ float64(scalar) -Error: binopvs: bool ^ float64 not implemented -bool(scalar) ^ float64(array) -Error: binopsv: bool ^ float64 not implemented -bool(array) | float64(array) -Error: binopvv: bool | float64 not implemented -bool(array) | float64(scalar) -Error: binopvs: bool | float64 not implemented -bool(scalar) | float64(array) -Error: binopsv: bool | float64 not implemented -bool(array) >> float64(array) -Error: binopvv: bool >> float64 not implemented -bool(array) >> float64(scalar) -Error: binopvs: bool >> float64 not implemented -bool(scalar) >> float64(array) -Error: binopsv: bool >> float64 not implemented -bool(array) << float64(array) -Error: binopvv: bool << float64 not implemented -bool(array) << float64(scalar) -Error: binopvs: bool << float64 not implemented -bool(scalar) << float64(array) -Error: binopsv: bool << float64 not implemented -bool(array) - bool(array) -Error: binopvv: bool - bool not implemented -bool(array) - bool(scalar) -Error: binopvs: bool - bool not implemented -bool(scalar) - bool(array) -Error: binopsv: bool - bool not implemented -186 caught -int64(array) % float64(array) -Error: binopvv: int64 % float64 not implemented -int64(array) % float64(scalar) -Error: binopvs: int64 % float64 not implemented -int64(scalar) % float64(array) -Error: binopsv: int64 % float64 not implemented -int64(array) == bool(array) -Error: binopvv: int64 == bool not implemented -int64(array) == bool(scalar) -Error: binopvs: int64 == bool not implemented -int64(scalar) == bool(array) -Error: binopvs: bool == int64 not implemented -int64(array) > bool(array) -Error: binopvv: int64 > bool not implemented -int64(array) > bool(scalar) -Error: binopvs: int64 > bool not implemented -int64(scalar) > bool(array) -Error: binopvs: bool < int64 not implemented -int64(array) != bool(array) -Error: binopvv: int64 != bool not implemented -int64(array) != bool(scalar) -Error: binopvs: int64 != bool not implemented -int64(scalar) != bool(array) -Error: binopvs: bool != int64 not implemented -int64(array) <= bool(array) -Error: binopvv: int64 <= bool not implemented -int64(array) <= bool(scalar) -Error: binopvs: int64 <= bool not implemented -int64(scalar) <= bool(array) -Error: binopvs: bool >= int64 not implemented -int64(array) % bool(array) -Error: binopvv: int64 % bool not implemented -int64(array) % bool(scalar) -Error: binopvs: int64 % bool not implemented -int64(scalar) % bool(array) -Error: binopsv: int64 % bool not implemented -int64(array) & bool(array) -Error: binopvv: int64 & bool not implemented -int64(array) & bool(scalar) -Error: binopvs: int64 & bool not implemented -int64(scalar) & bool(array) -Error: binopsv: int64 & bool not implemented -int64(array) ^ bool(array) -Error: binopvv: int64 ^ bool not implemented -int64(array) ^ bool(scalar) -Error: binopvs: int64 ^ bool not implemented -int64(scalar) ^ bool(array) -Error: binopsv: int64 ^ bool not implemented -int64(array) | bool(array) -Error: binopvv: int64 | bool not implemented -int64(array) | bool(scalar) -Error: binopvs: int64 | bool not implemented -int64(scalar) | bool(array) -Error: binopsv: int64 | bool not implemented -int64(array) >> bool(array) -Error: binopvv: int64 >> bool not implemented -int64(array) >> bool(scalar) -Error: binopvs: int64 >> bool not implemented -int64(scalar) >> bool(array) -Error: binopsv: int64 >> bool not implemented -int64(array) >= bool(array) -Error: binopvv: int64 >= bool not implemented -int64(array) >= bool(scalar) -Error: binopvs: int64 >= bool not implemented -int64(scalar) >= bool(array) -Error: binopvs: bool <= int64 not implemented -int64(array) << bool(array) -Error: binopvv: int64 << bool not implemented -int64(array) << bool(scalar) -Error: binopvs: int64 << bool not implemented -int64(scalar) << bool(array) -Error: binopsv: int64 << bool not implemented -int64(array) // bool(array) -Error: binopvv: int64 // bool not implemented -int64(array) // bool(scalar) -Error: binopvs: int64 // bool not implemented -int64(scalar) // bool(array) -Error: binopsv: int64 // bool not implemented -int64(array) < bool(array) -Error: binopvv: int64 < bool not implemented -int64(array) < bool(scalar) -Error: binopvs: int64 < bool not implemented -int64(scalar) < bool(array) -Error: binopvs: bool > int64 not implemented -int64(array) / bool(array) -Error: binopvv: int64 / bool not implemented -int64(array) / bool(scalar) -Error: binopvs: int64 / bool not implemented -int64(scalar) / bool(array) -Error: binopsv: int64 / bool not implemented -float64(array) % int64(array) -Error: binopvv: float64 % int64 not implemented -float64(array) % int64(scalar) -Error: binopvs: float64 % int64 not implemented -float64(scalar) % int64(array) -Error: binopsv: float64 % int64 not implemented -float64(array) % float64(array) -Error: binopvv: float64 % float64 not implemented -float64(array) % float64(scalar) -Error: binopvs: float64 % float64 not implemented -float64(scalar) % float64(array) -Error: binopsv: float64 % float64 not implemented -float64(array) == bool(array) -Error: binopvv: float64 == bool not implemented -float64(array) == bool(scalar) -Error: binopvs: float64 == bool not implemented -float64(scalar) == bool(array) -Error: binopvs: bool == float64 not implemented -float64(array) > bool(array) -Error: binopvv: float64 > bool not implemented -float64(array) > bool(scalar) -Error: binopvs: float64 > bool not implemented -float64(scalar) > bool(array) -Error: binopvs: bool < float64 not implemented -float64(array) != bool(array) -Error: binopvv: float64 != bool not implemented -float64(array) != bool(scalar) -Error: binopvs: float64 != bool not implemented -float64(scalar) != bool(array) -Error: binopvs: bool != float64 not implemented -float64(array) <= bool(array) -Error: binopvv: float64 <= bool not implemented -float64(array) <= bool(scalar) -Error: binopvs: float64 <= bool not implemented -float64(scalar) <= bool(array) -Error: binopvs: bool >= float64 not implemented -float64(array) % bool(array) -Error: binopvv: float64 % bool not implemented -float64(array) % bool(scalar) -Error: binopvs: float64 % bool not implemented -float64(scalar) % bool(array) -Error: binopsv: float64 % bool not implemented -float64(array) >= bool(array) -Error: binopvv: float64 >= bool not implemented -float64(array) >= bool(scalar) -Error: binopvs: float64 >= bool not implemented -float64(scalar) >= bool(array) -Error: binopvs: bool <= float64 not implemented -float64(array) // bool(array) -Error: binopvv: float64 // bool not implemented -float64(array) // bool(scalar) -Error: binopvs: float64 // bool not implemented -float64(scalar) // bool(array) -Error: binopsv: float64 // bool not implemented -float64(array) < bool(array) -Error: binopvv: float64 < bool not implemented -float64(array) < bool(scalar) -Error: binopvs: float64 < bool not implemented -float64(scalar) < bool(array) -Error: binopvs: bool > float64 not implemented -float64(array) / bool(array) -Error: binopvv: float64 / bool not implemented -float64(array) / bool(scalar) -Error: binopvs: float64 / bool not implemented -float64(scalar) / bool(array) -Error: binopsv: float64 / bool not implemented -bool(array) == int64(array) -Error: binopvv: bool == int64 not implemented -bool(array) == int64(scalar) -Error: binopvs: bool == int64 not implemented -bool(scalar) == int64(array) -Error: binopvs: int64 == bool not implemented -bool(array) > int64(array) -Error: binopvv: bool > int64 not implemented -bool(array) > int64(scalar) -Error: binopvs: bool > int64 not implemented -bool(scalar) > int64(array) -Error: binopvs: int64 < bool not implemented -bool(array) != int64(array) -Error: binopvv: bool != int64 not implemented -bool(array) != int64(scalar) -Error: binopvs: bool != int64 not implemented -bool(scalar) != int64(array) -Error: binopvs: int64 != bool not implemented -bool(array) <= int64(array) -Error: binopvv: bool <= int64 not implemented -bool(array) <= int64(scalar) -Error: binopvs: bool <= int64 not implemented -bool(scalar) <= int64(array) -Error: binopvs: int64 >= bool not implemented -bool(array) % int64(array) -Error: binopvv: bool % int64 not implemented -bool(array) % int64(scalar) -Error: binopvs: bool % int64 not implemented -bool(scalar) % int64(array) -Error: binopsv: bool % int64 not implemented -bool(array) & int64(array) -Error: binopvv: bool & int64 not implemented -bool(array) & int64(scalar) -Error: binopvs: bool & int64 not implemented -bool(scalar) & int64(array) -Error: binopsv: bool & int64 not implemented -bool(array) ^ int64(array) -Error: binopvv: bool ^ int64 not implemented -bool(array) ^ int64(scalar) -Error: binopvs: bool ^ int64 not implemented -bool(scalar) ^ int64(array) -Error: binopsv: bool ^ int64 not implemented -bool(array) | int64(array) -Error: binopvv: bool | int64 not implemented -bool(array) | int64(scalar) -Error: binopvs: bool | int64 not implemented -bool(scalar) | int64(array) -Error: binopsv: bool | int64 not implemented -bool(array) >> int64(array) -Error: binopvv: bool >> int64 not implemented -bool(array) >> int64(scalar) -Error: binopvs: bool >> int64 not implemented -bool(scalar) >> int64(array) -Error: binopsv: bool >> int64 not implemented -bool(array) >= int64(array) -Error: binopvv: bool >= int64 not implemented -bool(array) >= int64(scalar) -Error: binopvs: bool >= int64 not implemented -bool(scalar) >= int64(array) -Error: binopvs: int64 <= bool not implemented -bool(array) << int64(array) -Error: binopvv: bool << int64 not implemented -bool(array) << int64(scalar) -Error: binopvs: bool << int64 not implemented -bool(scalar) << int64(array) -Error: binopsv: bool << int64 not implemented -bool(array) // int64(array) -Error: binopvv: bool // int64 not implemented -bool(array) // int64(scalar) -Error: binopvs: bool // int64 not implemented -bool(scalar) // int64(array) -Error: binopsv: bool // int64 not implemented -bool(array) < int64(array) -Error: binopvv: bool < int64 not implemented -bool(array) < int64(scalar) -Error: binopvs: bool < int64 not implemented -bool(scalar) < int64(array) -Error: binopvs: int64 > bool not implemented -bool(array) / int64(array) -Error: binopvv: bool / int64 not implemented -bool(array) / int64(scalar) -Error: binopvs: bool / int64 not implemented -bool(scalar) / int64(array) -Error: binopsv: bool / int64 not implemented -bool(array) == float64(array) -Error: binopvv: bool == float64 not implemented -bool(array) == float64(scalar) -Error: binopvs: bool == float64 not implemented -bool(scalar) == float64(array) -Error: binopvs: float64 == bool not implemented -bool(array) > float64(array) -Error: binopvv: bool > float64 not implemented -bool(array) > float64(scalar) -Error: binopvs: bool > float64 not implemented -bool(scalar) > float64(array) -Error: binopvs: float64 < bool not implemented -bool(array) != float64(array) -Error: binopvv: bool != float64 not implemented./operator_tests.py:72: UserWarning: Error computing bool(array) >> bool(array) -Error: binopvv: bool >> bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) >> bool(scalar) -Error: binopvs: bool >> bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) >> bool(array) -Error: binopsv: bool >> bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) + bool(array) -Error: binopvv: bool + bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) + bool(scalar) -Error: binopvs: bool + bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) + bool(array) -Error: binopsv: bool + bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) >= bool(array) -Error: binopvv: bool >= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) >= bool(scalar) -Error: binopvs: bool >= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) >= bool(array) -Error: binopvs: bool <= bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) * bool(array) -Error: binopvv: bool * bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) * bool(scalar) -Error: binopvs: bool * bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) * bool(array) -Error: binopsv: bool * bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) << bool(array) -Error: binopvv: bool << bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) << bool(scalar) -Error: binopvs: bool << bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) << bool(array) -Error: binopsv: bool << bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) // bool(array) -Error: binopvv: bool // bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) // bool(scalar) -Error: binopvs: bool // bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) // bool(array) -Error: binopsv: bool // bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) < bool(array) -Error: binopvv: bool < bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) < bool(scalar) -Error: binopvs: bool < bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) < bool(array) -Error: binopvs: bool > bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) / bool(array) -Error: binopvv: bool / bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(array) / bool(scalar) -Error: binopvs: bool / bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) -./operator_tests.py:72: UserWarning: Error computing bool(scalar) / bool(array) -Error: binopsv: bool / bool not implemented - warnings.warn("Error computing {}\n{}".format(expression, str(e))) - -bool(array) != float64(scalar) -Error: binopvs: bool != float64 not implemented -bool(scalar) != float64(array) -Error: binopvs: float64 != bool not implemented -bool(array) <= float64(array) -Error: binopvv: bool <= float64 not implemented -bool(array) <= float64(scalar) -Error: binopvs: bool <= float64 not implemented -bool(scalar) <= float64(array) -Error: binopvs: float64 >= bool not implemented -bool(array) % float64(array) -Error: binopvv: bool % float64 not implemented -bool(array) % float64(scalar) -Error: binopvs: bool % float64 not implemented -bool(scalar) % float64(array) -Error: binopsv: bool % float64 not implemented -bool(array) >= float64(array) -Error: binopvv: bool >= float64 not implemented -bool(array) >= float64(scalar) -Error: binopvs: bool >= float64 not implemented -bool(scalar) >= float64(array) -Error: binopvs: float64 <= bool not implemented -bool(array) // float64(array) -Error: binopvv: bool // float64 not implemented -bool(array) // float64(scalar) -Error: binopvs: bool // float64 not implemented -bool(scalar) // float64(array) -Error: binopsv: bool // float64 not implemented -bool(array) < float64(array) -Error: binopvv: bool < float64 not implemented -bool(array) < float64(scalar) -Error: binopvs: bool < float64 not implemented -bool(scalar) < float64(array) -Error: binopvs: float64 > bool not implemented -bool(array) / float64(array) -Error: binopvv: bool / float64 not implemented -bool(array) / float64(scalar) -Error: binopvs: bool / float64 not implemented -bool(scalar) / float64(array) -Error: binopsv: bool / float64 not implemented -bool(array) == bool(array) -Error: binopvv: bool == bool not implemented -bool(array) == bool(scalar) -Error: binopvs: bool == bool not implemented -bool(scalar) == bool(array) -Error: binopvs: bool == bool not implemented -bool(array) > bool(array) -Error: binopvv: bool > bool not implemented -bool(array) > bool(scalar) -Error: binopvs: bool > bool not implemented -bool(scalar) > bool(array) -Error: binopvs: bool < bool not implemented -bool(array) != bool(array) -Error: binopvv: bool != bool not implemented -bool(array) != bool(scalar) -Error: binopvs: bool != bool not implemented -bool(scalar) != bool(array) -Error: binopvs: bool != bool not implemented -bool(array) <= bool(array) -Error: binopvv: bool <= bool not implemented -bool(array) <= bool(scalar) -Error: binopvs: bool <= bool not implemented -bool(scalar) <= bool(array) -Error: binopvs: bool >= bool not implemented -bool(array) % bool(array) -Error: binopvv: bool % bool not implemented -bool(array) % bool(scalar) -Error: binopvs: bool % bool not implemented -bool(scalar) % bool(array) -Error: binopsv: bool % bool not implemented -bool(array) >> bool(array) -Error: binopvv: bool >> bool not implemented -bool(array) >> bool(scalar) -Error: binopvs: bool >> bool not implemented -bool(scalar) >> bool(array) -Error: binopsv: bool >> bool not implemented -bool(array) + bool(array) -Error: binopvv: bool + bool not implemented -bool(array) + bool(scalar) -Error: binopvs: bool + bool not implemented -bool(scalar) + bool(array) -Error: binopsv: bool + bool not implemented -bool(array) >= bool(array) -Error: binopvv: bool >= bool not implemented -bool(array) >= bool(scalar) -Error: binopvs: bool >= bool not implemented -bool(scalar) >= bool(array) -Error: binopvs: bool <= bool not implemented -bool(array) * bool(array) -Error: binopvv: bool * bool not implemented -bool(array) * bool(scalar) -Error: binopvs: bool * bool not implemented -bool(scalar) * bool(array) -Error: binopsv: bool * bool not implemented -bool(array) << bool(array) -Error: binopvv: bool << bool not implemented -bool(array) << bool(scalar) -Error: binopvs: bool << bool not implemented -bool(scalar) << bool(array) -Error: binopsv: bool << bool not implemented -bool(array) // bool(array) -Error: binopvv: bool // bool not implemented -bool(array) // bool(scalar) -Error: binopvs: bool // bool not implemented -bool(scalar) // bool(array) -Error: binopsv: bool // bool not implemented -bool(array) < bool(array) -Error: binopvv: bool < bool not implemented -bool(array) < bool(scalar) -Error: binopvs: bool < bool not implemented -bool(scalar) < bool(array) -Error: binopvs: bool > bool not implemented -bool(array) / bool(array) -Error: binopvv: bool / bool not implemented -bool(array) / bool(scalar) -Error: binopvs: bool / bool not implemented -bool(scalar) / bool(array) -Error: binopsv: bool / bool not implemented -0 wrong_dtype -3 wrong_value -int64(array) // float64(array) -np: [nan 18. 13. 12. 11. 10. 10. 10. 10. 10.] -ak: [inf 18. 13. 12. 11. 10. 10. 10. 10. 10.] -int64(scalar) // float64(array) -np: [nan 45. 22. 15. 11. 8. 7. 6. 5. 5.] -ak: [inf 45. 22. 15. 11. 9. 7. 6. 5. 5.] -float64(scalar) // float64(array) -np: [nan 28. 14. 9. 7. 5. 4. 4. 3. 3.] -ak: [inf 28. 14. 9. 7. 5. 4. 4. 3. 3.] -0 failure -189 differences from numpy in 459 tests