Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package python-quantum-blackbird for
openSUSE:Factory checked in at 2021-06-19 23:02:54
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-quantum-blackbird (Old)
and /work/SRC/openSUSE:Factory/.python-quantum-blackbird.new.2625 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-quantum-blackbird"
Sat Jun 19 23:02:54 2021 rev:6 rq:900584 version:0.3.0
Changes:
--------
---
/work/SRC/openSUSE:Factory/python-quantum-blackbird/python-quantum-blackbird.changes
2021-05-12 19:33:23.318760436 +0200
+++
/work/SRC/openSUSE:Factory/.python-quantum-blackbird.new.2625/python-quantum-blackbird.changes
2021-06-19 23:03:28.691711820 +0200
@@ -1,0 +2,6 @@
+Thu Jun 17 08:05:46 UTC 2021 - Guillaume GARDET <[email protected]>
+
+- Add upstream patch to fix test on aarch64:
+ * fix-aarch64.patch
+
+-------------------------------------------------------------------
New:
----
fix-aarch64.patch
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-quantum-blackbird.spec ++++++
--- /var/tmp/diff_new_pack.JnsgGD/_old 2021-06-19 23:03:29.183712579 +0200
+++ /var/tmp/diff_new_pack.JnsgGD/_new 2021-06-19 23:03:29.187712586 +0200
@@ -30,6 +30,8 @@
# PATCH-FIX-UPSTREAM skip_32bit_divide_scalar_array_test.patch
gh#XanaduAI/blackbird#42 [email protected]
# Skip tests failing on 32bit
Patch0: skip_32bit_divide_scalar_array_test.patch
+# PATCH-FIX-UPSTREAM - https://github.com/XanaduAI/blackbird/pull/45
+Patch1: fix-aarch64.patch
BuildRequires: %{python_module antlr4-python3-runtime >= 4.8}
BuildRequires: %{python_module networkx}
BuildRequires: %{python_module numpy >= 1.16}
++++++ fix-aarch64.patch ++++++
>From d944105edcbab53e9110e3b24ac4167c788e71b7 Mon Sep 17 00:00:00 2001
From: Theodor Isacsson <[email protected]>
Date: Mon, 14 Jun 2021 17:05:43 -0400
Subject: [PATCH] switch to isclose and allclose
---
.../blackbird/tests/test_auxiliary.py | 60 +++++++++----------
.../blackbird/tests/test_listener.py | 4 +-
2 files changed, 32 insertions(+), 32 deletions(-)
diff --git a/blackbird_python/blackbird/tests/test_auxiliary.py
b/blackbird_python/blackbird/tests/test_auxiliary.py
index 4db8430..b35e74a 100644
--- a/blackbird_python/blackbird/tests/test_auxiliary.py
+++ b/blackbird_python/blackbird/tests/test_auxiliary.py
@@ -137,7 +137,7 @@ def test_number_int(self, parser, ctx, n, expected):
number = blackbirdParser.NumberContext(parser, ctx)
number.INT = lambda: True
number.getText = lambda: n
- assert _number(number) == expected
+ assert np.isclose(_number(number), expected)
@pytest.mark.parametrize('n, expected', test_floats)
def test_number_float(self, parser, ctx, n, expected):
@@ -145,7 +145,7 @@ def test_number_float(self, parser, ctx, n, expected):
number = blackbirdParser.NumberContext(parser, ctx)
number.FLOAT = lambda: True
number.getText = lambda: n
- assert _number(number) == expected
+ assert np.isclose(_number(number), expected)
@pytest.mark.parametrize('n, expected', test_complex)
def test_number_complex(self, parser, ctx, n, expected):
@@ -153,13 +153,13 @@ def test_number_complex(self, parser, ctx, n, expected):
number = blackbirdParser.NumberContext(parser, ctx)
number.COMPLEX = lambda: True
number.getText = lambda: n
- assert _number(number) == expected
+ assert np.isclose(_number(number), expected)
def test_number_pi(self, parser, ctx):
"""Test that a Blackbird pi literal is properly converted to a Python
type"""
number = blackbirdParser.NumberContext(parser, ctx)
number.PI = lambda: True
- assert _number(number) == np.pi
+ assert np.isclose(_number(number), np.pi)
def test_number_invalid(self, parser, ctx):
"""Test that an unknown number correctly raises and exception"""
@@ -179,7 +179,7 @@ def test_function_exp(self, parser, ctx, n, expected, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.EXP = lambda: True
expression = num(n)
- assert _func(func, expression) == np.exp(expected)
+ assert np.isclose(_func(func, expression), np.exp(expected))
@pytest.mark.parametrize('n, expected', test_complex)
def test_function_log(self, parser, ctx, n, expected, num):
@@ -187,7 +187,7 @@ def test_function_log(self, parser, ctx, n, expected, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.LOG = lambda: True
expression = num(n)
- assert _func(func, expression) == np.log(expected)
+ assert np.isclose(_func(func, expression), np.log(expected))
@pytest.mark.parametrize('n, expected', test_complex)
def test_function_sin(self, parser, ctx, n, expected, num):
@@ -195,7 +195,7 @@ def test_function_sin(self, parser, ctx, n, expected, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.SIN = lambda: True
expression = num(n)
- assert _func(func, expression) == np.sin(expected)
+ assert np.isclose(_func(func, expression), np.sin(expected))
@pytest.mark.parametrize('n, expected', test_complex)
def test_function_cos(self, parser, ctx, n, expected, num):
@@ -203,7 +203,7 @@ def test_function_cos(self, parser, ctx, n, expected, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.COS = lambda: True
expression = num(n)
- assert _func(func, expression) == np.cos(expected)
+ assert np.isclose(_func(func, expression), np.cos(expected))
@pytest.mark.parametrize('n, expected', test_floats)
def test_function_tan(self, parser, ctx, n, expected, num):
@@ -211,7 +211,7 @@ def test_function_tan(self, parser, ctx, n, expected, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.TAN = lambda: True
expression = num(n, num_type='float')
- assert _func(func, expression) == np.tan(expected)
+ assert np.isclose(_func(func, expression), np.tan(expected))
def test_function_arcsin(self, parser, ctx, num):
"""Test that a Blackbird arcsin function is properly called"""
@@ -221,7 +221,7 @@ def test_function_arcsin(self, parser, ctx, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.ARCSIN = lambda: True
expression = num(n)
- assert _func(func, expression) == np.arcsin(expected)
+ assert np.isclose(_func(func, expression), np.arcsin(expected))
def test_function_arccos(self, parser, ctx, num):
"""Test that a Blackbird arccos function is properly called"""
@@ -231,7 +231,7 @@ def test_function_arccos(self, parser, ctx, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.ARCCOS = lambda: True
expression = num(n)
- assert _func(func, expression) == np.arccos(expected)
+ assert np.isclose(_func(func, expression), np.arccos(expected))
def test_function_arctan(self, parser, ctx, num):
"""Test that a Blackbird arctan function is properly called"""
@@ -241,7 +241,7 @@ def test_function_arctan(self, parser, ctx, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.ARCTAN = lambda: True
expression = num(n)
- assert _func(func, expression) == np.arctan(expected)
+ assert np.isclose(_func(func, expression), np.arctan(expected))
@pytest.mark.parametrize('n, expected', test_complex)
def test_function_sinh(self, parser, ctx, n, expected, num):
@@ -249,7 +249,7 @@ def test_function_sinh(self, parser, ctx, n, expected, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.SINH = lambda: True
expression = num(n)
- assert _func(func, expression) == np.sinh(expected)
+ assert np.isclose(_func(func, expression), np.sinh(expected))
@pytest.mark.parametrize('n, expected', test_complex)
def test_function_cosh(self, parser, ctx, n, expected, num):
@@ -257,7 +257,7 @@ def test_function_cosh(self, parser, ctx, n, expected, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.COSH = lambda: True
expression = num(n)
- assert _func(func, expression) == np.cosh(expected)
+ assert np.isclose(_func(func, expression), np.cosh(expected))
def test_function_tanh(self, parser, ctx, num):
"""Test that a Blackbird tanh function is properly called"""
@@ -267,7 +267,7 @@ def test_function_tanh(self, parser, ctx, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.TANH = lambda: True
expression = num(n, num_type='float')
- assert _func(func, expression) == np.tanh(expected)
+ assert np.isclose(_func(func, expression), np.tanh(expected))
@pytest.mark.parametrize('n, expected', test_complex)
def test_function_arcsinh(self, parser, ctx, n, expected, num):
@@ -275,7 +275,7 @@ def test_function_arcsinh(self, parser, ctx, n, expected,
num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.ARCSINH = lambda: True
expression = num(n)
- assert _func(func, expression) == np.arcsinh(expected)
+ assert np.isclose(_func(func, expression), np.arcsinh(expected))
@pytest.mark.parametrize('n, expected', test_complex)
def test_function_arccosh(self, parser, ctx, n, expected, num):
@@ -283,7 +283,7 @@ def test_function_arccosh(self, parser, ctx, n, expected,
num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.ARCCOSH = lambda: True
expression = num(n)
- assert _func(func, expression) == np.arccosh(expected)
+ assert np.isclose(_func(func, expression), np.arccosh(expected))
def test_function_arctanh(self, parser, ctx, num):
"""Test that a Blackbird arctanh function is properly called"""
@@ -293,7 +293,7 @@ def test_function_arctanh(self, parser, ctx, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.ARCTANH = lambda: True
expression = num(n, num_type='float')
- assert _func(func, expression) == np.arctanh(expected)
+ assert np.isclose(_func(func, expression), np.arctanh(expected))
@pytest.mark.parametrize('n, expected', test_complex)
def test_function_sqrt(self, parser, ctx, n, expected, num):
@@ -301,7 +301,7 @@ def test_function_sqrt(self, parser, ctx, n, expected, num):
func = blackbirdParser.FunctionContext(parser, ctx)
func.SQRT = lambda: True
expression = num(n)
- assert _func(func, expression) == np.sqrt(expected)
+ assert np.isclose(_func(func, expression), np.sqrt(expected))
def test_function_invalid(self, parser, ctx):
"""Test that an invalid Blackbird function raises the correct
exception"""
@@ -319,7 +319,7 @@ class TestExpression:
def test_number(self, n, expected, num):
"""Test that a Blackbird expression containing numbers evaluates"""
expr = num(n)
- assert _expression(expr) == expected
+ assert np.isclose(_expression(expr), expected)
def test_variable(self, parser, ctx, monkeypatch):
"""Test that a Blackbird expression containing variables evaluates"""
@@ -363,7 +363,7 @@ class DummyPowerLabel(blackbirdParser.PowerLabelContext):
expression = lambda self: (DummyBracketsLabel(parser, ctx), num(2))
expr = DummyPowerLabel(parser, ctx)
- assert _expression(expr) == (n1[1]+n2[1])**2
+ assert np.isclose(_expression(expr), (n1[1]+n2[1])**2)
@pytest.mark.parametrize('n, expected', test_complex)
@@ -376,7 +376,7 @@ class DummySignLabel(blackbirdParser.SignLabelContext):
expr = DummySignLabel(parser, ctx)
expr.MINUS = lambda: True
- assert _expression(expr) == -expected
+ assert np.isclose(_expression(expr), -expected)
@pytest.mark.parametrize('n, expected', test_complex)
def test_unary_plus(self, parser, ctx, n, expected, num):
@@ -388,7 +388,7 @@ class DummySignLabel(blackbirdParser.SignLabelContext):
expr = DummySignLabel(parser, ctx)
expr.PLUS = lambda: True
- assert _expression(expr) == expected
+ assert np.isclose(_expression(expr), expected)
@pytest.mark.parametrize('n1', test_complex)
@pytest.mark.parametrize('n2', test_floats)
@@ -401,7 +401,7 @@ class DummyAddLabel(blackbirdParser.AddLabelContext):
expr = DummyAddLabel(parser, ctx)
expr.PLUS = lambda: True
- assert _expression(expr) == n1[1] + n2[1]
+ assert np.isclose(_expression(expr), n1[1] + n2[1])
@pytest.mark.parametrize('n1', test_complex)
@pytest.mark.parametrize('n2', test_floats)
@@ -414,7 +414,7 @@ class DummyAddLabel(blackbirdParser.AddLabelContext):
expr = DummyAddLabel(parser, ctx)
expr.MINUS = lambda: True
- assert _expression(expr) == n1[1] - n2[1]
+ assert np.isclose(_expression(expr), n1[1] - n2[1])
@pytest.mark.parametrize('n1', test_complex)
@pytest.mark.parametrize('n2', test_floats)
@@ -427,7 +427,7 @@ class DummyMulLabel(blackbirdParser.MulLabelContext):
expr = DummyMulLabel(parser, ctx)
expr.TIMES = lambda: True
- assert _expression(expr) == n1[1]*n2[1]
+ assert np.isclose(_expression(expr), n1[1]*n2[1])
@pytest.mark.parametrize('n1', test_complex)
@pytest.mark.parametrize('n2', test_floats)
@@ -522,7 +522,7 @@ class DummyAddLabel(blackbirdParser.AddLabelContext):
expr = DummyAddLabel(parser, ctx)
expr.PLUS = lambda: True
- assert np.all(_expression(expr) == n1[1] + U)
+ assert np.allclose(_expression(expr), n1[1] + U)
def test_plus_array(self, parser, ctx, var, monkeypatch):
"""Test addition of two arrays"""
@@ -551,7 +551,7 @@ class DummyAddLabel(blackbirdParser.AddLabelContext):
expr = DummyAddLabel(parser, ctx)
expr.MINUS = lambda: True
- assert np.all(_expression(expr) == n1[1] - U)
+ assert np.allclose(_expression(expr), n1[1] - U)
def test_minus_array(self, parser, ctx, var, monkeypatch):
"""Test subtraction of two arrays"""
@@ -580,7 +580,7 @@ class DummyMulLabel(blackbirdParser.MulLabelContext):
expr = DummyMulLabel(parser, ctx)
expr.TIMES = lambda: True
- assert np.all(_expression(expr) == n1[1]*U)
+ assert np.allclose(_expression(expr), n1[1]*U)
def test_multiply_array_element(self, parser, ctx, var, monkeypatch):
"""Test multiplication of two arrays"""
@@ -609,7 +609,7 @@ class DummyMulLabel(blackbirdParser.MulLabelContext):
expr = DummyMulLabel(parser, ctx)
expr.DIVIDE = lambda: True
- assert np.all(_expression(expr) == n1[1]/U)
+ assert np.allclose(_expression(expr), n1[1]/U)
def test_divide_array_element(self, parser, ctx, var, monkeypatch):
"""Test division of two arrays"""
diff --git a/blackbird_python/blackbird/tests/test_listener.py
b/blackbird_python/blackbird/tests/test_listener.py
index 0705cf9..3d8202b 100644
--- a/blackbird_python/blackbird/tests/test_listener.py
+++ b/blackbird_python/blackbird/tests/test_listener.py
@@ -204,7 +204,7 @@ def test_variable_expression(self,
parse_input_mocked_metadata):
bb = parse_input_mocked_metadata(
"float alpha = 0.32\nfloat gamma = (2.0*cos(alpha*pi)+1)**2"
)
- assert bb._var["gamma"] == (2.0 * np.cos(0.32 * np.pi) + 1) ** 2
+ assert np.isclose(bb._var["gamma"], (2.0 * np.cos(0.32 * np.pi) + 1)
** 2)
def test_array_variable_expression(self, parse_input_mocked_metadata):
"""Test that a variable expression containing arrays is correctly
parsed"""
@@ -212,7 +212,7 @@ def test_array_variable_expression(self,
parse_input_mocked_metadata):
"complex array A =\n\t-1.0+1.0j, 2.7e5+0.2e-5j\n\t-0.1-2j,
0.2-0.1j\ncomplex res = (2.0*cos(A*pi)+1)**2"
)
A = np.array([[-1.0 + 1.0j, 2.7e5 + 0.2e-5j], [-0.1 - 2j, 0.2 - 0.1j]])
- assert np.all(bb._var["res"] == (2.0 * np.cos(A * np.pi) + 1) ** 2)
+ assert np.allclose(bb._var["res"], (2.0 * np.cos(A * np.pi) + 1) ** 2)
class TestParsingQuantumPrograms:
