ppc64le builds are failing on 0.6.2

[h-vetinari]

Have not found out why yet, but it seems there are some pretty fundamental issues with 0.6.2 on ppc64le, especially when looking at the complete mismatches in output for some of the tests. @jayfurmanek

I still merged this in #28 because I need to unblock the other stuck PRs, but would obviously like to solve this soon.

============================= test session starts ==============================
platform linux -- Python 3.6.12, pytest-6.2.1, py-1.10.0, pluggy-0.13.1
rootdir: $SRC_DIR
collected 53 items
tests/basic_test.py FF.F.F.F.                                            [ 16%]
tests/codegen_matrices_test.py .........                                 [ 33%]
tests/codegen_vectors_test.py .....                                      [ 43%]
tests/derivative_test.py .....                                           [ 52%]
tests/dual_infeasibility_test.py ...                                     [ 58%]
tests/feasibility_test.py F                                              [ 60%]
tests/mkl_pardiso_test.py s                                              [ 62%]
tests/multithread_test.py .                                              [ 64%]
tests/non_convex_test.py ...                                             [ 69%]
tests/polishing_test.py FFF                                              [ 75%]
tests/primal_infeasibility_test.py ..                                    [ 79%]
tests/unconstrained_test.py F                                            [ 81%]
tests/update_matrices_test.py FFFFFFFFF                                  [ 98%]
tests/warm_start_test.py .                                               [100%]
=================================== FAILURES ===================================

=========================== short test summary info ============================
FAILED tests/basic_test.py::basic_tests::test_basic_QP - AssertionError: 
FAILED tests/basic_test.py::basic_tests::test_update_bounds - AssertionError: 
FAILED tests/basic_test.py::basic_tests::test_update_l - AssertionError: 
FAILED tests/basic_test.py::basic_tests::test_update_q - AssertionError: 
FAILED tests/basic_test.py::basic_tests::test_update_u - AssertionError: 
FAILED tests/feasibility_test.py::feasibility_tests::test_feasibility_problem
FAILED tests/polishing_test.py::polish_tests::test_polish_random - AssertionE...
FAILED tests/polishing_test.py::polish_tests::test_polish_simple - AssertionE...
FAILED tests/polishing_test.py::polish_tests::test_polish_unconstrained - Typ...
FAILED tests/unconstrained_test.py::unconstrained_tests::test_unconstrained_problem
FAILED tests/update_matrices_test.py::update_matrices_tests::test_solve - Ass...
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_A - ...
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_A_allind
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P - ...
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_A_allind
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_A_indA
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_A_indP
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_A_indP_indA
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_allind
================== 19 failed, 33 passed, 1 skipped in 25.76s ===================

+ python -m pytest --pyargs osqp
============================= test session starts ==============================
platform linux -- Python 3.6.12, pytest-6.2.1, py-1.10.0, pluggy-0.13.1
rootdir: $SRC_DIR
collected 53 items
tests/basic_test.py FF.F.F.F.                                            [ 16%]
tests/codegen_matrices_test.py .........                                 [ 33%]
tests/codegen_vectors_test.py .....                                      [ 43%]
tests/derivative_test.py .....                                           [ 52%]
tests/dual_infeasibility_test.py ...                                     [ 58%]
tests/feasibility_test.py F                                              [ 60%]
tests/mkl_pardiso_test.py s                                              [ 62%]
tests/multithread_test.py .                                              [ 64%]
tests/non_convex_test.py ...                                             [ 69%]
tests/polishing_test.py FFF                                              [ 75%]
tests/primal_infeasibility_test.py ..                                    [ 79%]
tests/unconstrained_test.py F                                            [ 81%]
tests/update_matrices_test.py FFFFFFFFF                                  [ 98%]
tests/warm_start_test.py .                                               [100%]
=================================== FAILURES ===================================
__________________________ basic_tests.test_basic_QP ___________________________
self = <osqp.tests.basic_test.basic_tests testMethod=test_basic_QP>
    def test_basic_QP(self):
        # Solve problem
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 2 / 2 (100%)
E       Max absolute difference: 200004.94917794
E       Max relative difference: 1.000025
E        x: array([1.512428e-12, 5.000000e+00])
E        y: array([-1.270488e-01, -1.999999e+05])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/basic_test.py:47: AssertionError
________________________ basic_tests.test_update_bounds ________________________
self = <osqp.tests.basic_test.basic_tests testMethod=test_update_bounds>
    def test_update_bounds(self):
        # Update lower bound
        l_new = -100 * np.ones(self.m)
        # Update lower bound
        u_new = 1000 * np.ones(self.m)
        self.model.update(u=u_new, l=l_new)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                    l_new, u_new)
    
        # Assert close
        nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
>       nptest.assert_allclose(res.y, y_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 4 / 5 (80%)
E       Max absolute difference: 0.6
E       Max relative difference: 3.
E        x: array([ 0. ,  0. ,  0. , -0.8,  0. ])
E        y: array([-2.000000e-01, -2.000000e-01, -2.000000e-01, -2.000000e-01,
E              -5.469972e-13])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/basic_test.py:110: AssertionError
__________________________ basic_tests.test_update_l ___________________________
self = <osqp.tests.basic_test.basic_tests testMethod=test_update_l>
    def test_update_l(self):
        # Update lower bound
        l_new = -50 * np.ones(self.m)
        self.model.update(l=l_new)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                    l_new, self.u)
    
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 2 / 2 (100%)
E       Max absolute difference: 14.94909091
E       Max relative difference: 1.50255848
E        x: array([1.512428e-12, 5.000000e+00])
E        y: array([-0.127273, -9.949091])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/basic_test.py:77: AssertionError
__________________________ basic_tests.test_update_q ___________________________
self = <osqp.tests.basic_test.basic_tests testMethod=test_update_q>
    def test_update_q(self):
        # Update linear cost
        q_new = np.array([10, 20])
        self.model.update(q=q_new)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, q_new, self.A,
                                                    self.l, self.u)
    
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 2 / 2 (100%)
E       Max absolute difference: 200004.92658055
E       Max relative difference: 1.000025
E        x: array([-8.144723e-11,  5.000000e+00])
E        y: array([-1.835446e-01, -1.999999e+05])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/basic_test.py:62: AssertionError
__________________________ basic_tests.test_update_u ___________________________
self = <osqp.tests.basic_test.basic_tests testMethod=test_update_u>
    def test_update_u(self):
        # Update lower bound
        u_new = 1000 * np.ones(self.m)
        self.model.update(u=u_new)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                    self.l, u_new)
    
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 2 / 2 (100%)
E       Max absolute difference: 199666.66634989
E       Max relative difference: 0.99833359
E        x: array([-1.515152e-01, -3.332828e+02])
E        y: array([-1.270482e-01, -1.999999e+05])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/basic_test.py:92: AssertionError
__________________ feasibility_tests.test_feasibility_problem __________________
self = <osqp.tests.feasibility_test.feasibility_tests testMethod=test_feasibility_problem>
    def test_feasibility_problem(self):
    
        # Solve problem
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 30 / 30 (100%)
E       Max absolute difference: 3.02759177
E       Max relative difference: 2.78453701
E        x: array([-0.065607,  1.041944,  0.475696, -1.640367, -0.341802, -0.816963,
E              -1.063892,  0.449446, -0.448297, -1.012899, -0.125137,  0.022673,
E              -1.152065,  1.068174,  1.181433,  0.016903, -0.113736, -0.481158,...
E        y: array([ 0.      ,  0.      ,  0.      ,  0.919212,  0.      ,  0.      ,
E               0.      , -1.719954,  0.      ,  0.      ,  0.      ,  1.310161,
E               0.      ,  0.      ,  0.      ,  0.760976,  0.      ,  0.      ,...
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/feasibility_test.py:55: AssertionError
_______________________ polish_tests.test_polish_random ________________________
self = <osqp.tests.polishing_test.polish_tests testMethod=test_polish_random>
    def test_polish_random(self):
    
        # Random QP problem
        sp.random.seed(6)
    
        self.n = 30
        self.m = 50
        Pt = sparse.random(self.n, self.n)
        self.P = Pt.T @ Pt
        self.q = np.random.randn(self.n)
        self.A = sparse.csc_matrix(np.random.randn(self.m, self.n))
        self.l = -3 + np.random.randn(self.m)
        self.u = 3 + np.random.randn(self.m)
        self.model = osqp.OSQP()
        self.model.setup(P=self.P, q=self.q, A=self.A, l=self.l, u=self.u,
                         **self.opts)
    
        # Solve problem
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 30 / 30 (100%)
E       Max absolute difference: 4.32332116
E       Max relative difference: 2.31455905
E        x: array([-0.204149,  0.778481,  1.865201,  0.053583, -0.106964, -1.084762,
E              -0.604401, -0.87254 , -0.187153, -1.331029,  1.408312,  0.231445,
E               0.169812,  0.493663, -0.949908, -1.43441 ,  0.775492,  0.56798 ,...
E        y: array([ 0.      ,  0.      ,  0.      ,  1.623168,  0.      ,  0.      ,
E               0.      , -1.677255,  0.      ,  0.      ,  0.      ,  0.747558,
E               0.      ,  0.      ,  0.      , -1.175545,  0.      ,  0.      ,...
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/polishing_test.py:106: AssertionError
_______________________ polish_tests.test_polish_simple ________________________
self = <osqp.tests.polishing_test.polish_tests testMethod=test_polish_simple>
    def test_polish_simple(self):
    
        # Simple QP problem
        self.P = sparse.diags([11., 0.], format='csc')
        self.q = np.array([3, 4])
        self.A = sparse.csc_matrix(
            [[-1, 0], [0, -1], [-1, -3], [2, 5], [3, 4]])
        self.u = np.array([0, 0, -15, 100, 80])
        self.l = -1e05 * np.ones(len(self.u))
        self.n = self.P.shape[0]
        self.m = self.A.shape[0]
        self.model = osqp.OSQP()
        self.model.setup(P=self.P, q=self.q, A=self.A, l=self.l, u=self.u,
                         **self.opts)
    
        # Solve problem
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 2 / 2 (100%)
E       Max absolute difference: 20004.94908784
E       Max relative difference: 1.00025
E        x: array([1.625403e-22, 5.000000e+00])
E        y: array([-1.272803e-01, -1.999995e+04])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/polishing_test.py:51: AssertionError
____________________ polish_tests.test_polish_unconstrained ____________________
self = <osqp.tests.polishing_test.polish_tests testMethod=test_polish_unconstrained>
    def test_polish_unconstrained(self):
    
        # Unconstrained QP problem
        sp.random.seed(4)
    
        self.n = 30
        self.m = 0
        P = sparse.diags(np.random.rand(self.n)) + 0.2*sparse.eye(self.n)
        self.P = P.tocsc()
        self.q = np.random.randn(self.n)
        self.A = sparse.csc_matrix((self.m, self.n))
        self.l = np.array([])
        self.u = np.array([])
        self.model = osqp.OSQP()
        self.model.setup(P=self.P, q=self.q, A=self.A, l=self.l, u=self.u,
                         **self.opts)
    
        # Solve problem
        res = self.model.solve()
    
        x_sol, _, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/polishing_test.py:79: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/numpy/testing/_private/utils.py:1523: in compare
    equal_nan=equal_nan)
<__array_function__ internals>:6: in isclose
    ???
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
a = array([-0.61981415, -0.06174194,  0.83824061, -0.0595013 , -0.17810828,
        2.90550031, -1.8901713 , -1.91191741, ...323554,  1.15967924, -0.47821898,  3.6108927 ,
        0.03404309,  0.16322926, -2.17974795,  0.32458796, -1.97553574])
b = array(None, dtype=object), rtol = 0.001, atol = 0.0001, equal_nan = True
    @array_function_dispatch(_isclose_dispatcher)
    def isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False):
        """
        Returns a boolean array where two arrays are element-wise equal within a
        tolerance.
    
        The tolerance values are positive, typically very small numbers.  The
        relative difference (`rtol` * abs(`b`)) and the absolute difference
        `atol` are added together to compare against the absolute difference
        between `a` and `b`.
    
        .. warning:: The default `atol` is not appropriate for comparing numbers
                     that are much smaller than one (see Notes).
    
        Parameters
        ----------
        a, b : array_like
            Input arrays to compare.
        rtol : float
            The relative tolerance parameter (see Notes).
        atol : float
            The absolute tolerance parameter (see Notes).
        equal_nan : bool
            Whether to compare NaN's as equal.  If True, NaN's in `a` will be
            considered equal to NaN's in `b` in the output array.
    
        Returns
        -------
        y : array_like
            Returns a boolean array of where `a` and `b` are equal within the
            given tolerance. If both `a` and `b` are scalars, returns a single
            boolean value.
    
        See Also
        --------
        allclose
   
        Notes
        -----
        .. versionadded:: 1.7.0
    
        For finite values, isclose uses the following equation to test whether
        two floating point values are equivalent.
    
         absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
    
        Unlike the built-in `math.isclose`, the above equation is not symmetric
        in `a` and `b` -- it assumes `b` is the reference value -- so that
        `isclose(a, b)` might be different from `isclose(b, a)`. Furthermore,
        the default value of atol is not zero, and is used to determine what
        small values should be considered close to zero. The default value is
        appropriate for expected values of order unity: if the expected values
        are significantly smaller than one, it can result in false positives.
        `atol` should be carefully selected for the use case at hand. A zero value
        for `atol` will result in `False` if either `a` or `b` is zero.
    
        Examples
        --------
        >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
        array([ True, False])
        >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
        array([ True, True])
        >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
        array([False,  True])
        >>> np.isclose([1.0, np.nan], [1.0, np.nan])
        array([ True, False])
        >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
        array([ True, True])
        >>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
        array([ True, False])
        >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
        array([False, False])
        >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
        array([ True,  True])
        >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
        array([False,  True])
        """
        def within_tol(x, y, atol, rtol):
            with errstate(invalid='ignore'):
                return less_equal(abs(x-y), atol + rtol * abs(y))
    
        x = asanyarray(a)
        y = asanyarray(b)
    
        # Make sure y is an inexact type to avoid bad behavior on abs(MIN_INT).
        # This will cause casting of x later. Also, make sure to allow subclasses
        # (e.g., for numpy.ma).
        dt = multiarray.result_type(y, 1.)
        y = array(y, dtype=dt, copy=False, subok=True)
    
        xfin = isfinite(x)
>       yfin = isfinite(y)
E       TypeError: ufunc 'isfinite' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/numpy/core/numeric.py:2288: TypeError
________________ unconstrained_tests.test_unconstrained_problem ________________
self = <osqp.tests.unconstrained_test.unconstrained_tests testMethod=test_unconstrained_problem>
    def test_unconstrained_problem(self):
    
        # Solve problem
        res = self.model.solve()
    
        # Assert close
        x_sol, _, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/unconstrained_test.py:48: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/numpy/testing/_private/utils.py:1523: in compare
    equal_nan=equal_nan)
<__array_function__ internals>:6: in isclose
    ???
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
a = array([-0.61981415, -0.06174194,  0.83824061, -0.0595013 , -0.17810828,
        2.90550031, -1.8901713 , -1.91191741, ...323554,  1.15967924, -0.47821898,  3.6108927 ,
        0.03404309,  0.16322926, -2.17974795,  0.32458796, -1.97553574])
b = array(None, dtype=object), rtol = 0.001, atol = 0.0001, equal_nan = True
    @array_function_dispatch(_isclose_dispatcher)
    def isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False):
        """
        Returns a boolean array where two arrays are element-wise equal within a
        tolerance.
    
        The tolerance values are positive, typically very small numbers.  The
        relative difference (`rtol` * abs(`b`)) and the absolute difference
        `atol` are added together to compare against the absolute difference
        between `a` and `b`.
    
        .. warning:: The default `atol` is not appropriate for comparing numbers
                     that are much smaller than one (see Notes).
    
        Parameters
        ----------
        a, b : array_like
            Input arrays to compare.
        rtol : float
            The relative tolerance parameter (see Notes).
        atol : float
            The absolute tolerance parameter (see Notes).
        equal_nan : bool
            Whether to compare NaN's as equal.  If True, NaN's in `a` will be
            considered equal to NaN's in `b` in the output array.
    
        Returns
        -------
        y : array_like
            Returns a boolean array of where `a` and `b` are equal within the
            given tolerance. If both `a` and `b` are scalars, returns a single
            boolean value.
    
        See Also
        --------
        allclose
    
        Notes
        -----
        .. versionadded:: 1.7.0
    
        For finite values, isclose uses the following equation to test whether
        two floating point values are equivalent.
    
         absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
    
        Unlike the built-in `math.isclose`, the above equation is not symmetric
        in `a` and `b` -- it assumes `b` is the reference value -- so that
        `isclose(a, b)` might be different from `isclose(b, a)`. Furthermore,
        the default value of atol is not zero, and is used to determine what
        small values should be considered close to zero. The default value is
        appropriate for expected values of order unity: if the expected values
        are significantly smaller than one, it can result in false positives.
        `atol` should be carefully selected for the use case at hand. A zero value
        for `atol` will result in `False` if either `a` or `b` is zero.
    
        Examples
        --------
        >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
        array([ True, False])
        >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
        array([ True, True])
        >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
        array([False,  True])
        >>> np.isclose([1.0, np.nan], [1.0, np.nan])
        array([ True, False])
        >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
        array([ True, True])
        >>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
        array([ True, False])
        >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
        array([False, False])
        >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
        array([ True,  True])
        >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
        array([False,  True])
        """
        def within_tol(x, y, atol, rtol):
            with errstate(invalid='ignore'):
                return less_equal(abs(x-y), atol + rtol * abs(y))
    
        x = asanyarray(a)
        y = asanyarray(b)
    
        # Make sure y is an inexact type to avoid bad behavior on abs(MIN_INT).
        # This will cause casting of x later. Also, make sure to allow subclasses
        # (e.g., for numpy.ma).
        dt = multiarray.result_type(y, 1.)
        y = array(y, dtype=dt, copy=False, subok=True)
    
        xfin = isfinite(x)
>       yfin = isfinite(y)
E       TypeError: ufunc 'isfinite' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/numpy/core/numeric.py:2288: TypeError
_______________________ update_matrices_tests.test_solve _______________________
self = <osqp.tests.update_matrices_test.update_matrices_tests testMethod=test_solve>
    def test_solve(self):
        # Solve problem
        res = self.model.solve()
    
        # Assert close
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 5 / 5 (100%)
E       Max absolute difference: 1.42357816
E       Max relative difference: 12.2469448
E        x: array([-1.135636, -0.471212,  0.214947,  1.307339,  0.176622])
E        y: array([ 0.      ,  0.      ,  0.      , -0.116239,  0.195665])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/update_matrices_test.py:52: AssertionError
_____________________ update_matrices_tests.test_update_A ______________________
self = <osqp.tests.update_matrices_test.update_matrices_tests testMethod=test_update_A>
    def test_update_A(self):
        # Update matrix A
        Ax = self.A_new.data
        Ax_idx = np.arange(self.A_new.nnz)
        self.model.update(Ax=Ax, Ax_idx=Ax_idx)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A_new,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 5 / 5 (100%)
E       Max absolute difference: 0.20039148
E       Max relative difference: 6.26783218e+10
E        x: array([-0.128437,  0.200391,  0.01928 ,  0.123355,  0.065085])
E        y: array([0.000000e+00, 0.000000e+00, 0.000000e+00, 1.968062e-12,
E              4.310575e-11])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/update_matrices_test.py:96: AssertionError
__________________ update_matrices_tests.test_update_A_allind __________________
self = <osqp.tests.update_matrices_test.update_matrices_tests testMethod=test_update_A_allind>
    def test_update_A_allind(self):
        # Update matrix A
        Ax = self.A_new.data
        self.model.update(Ax=Ax)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P, self.q, self.A_new,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 5 / 5 (100%)
E       Max absolute difference: 0.20039148
E       Max relative difference: 6.26783218e+10
E        x: array([-0.128437,  0.200391,  0.01928 ,  0.123355,  0.065085])
E        y: array([0.000000e+00, 0.000000e+00, 0.000000e+00, 1.968062e-12,
E              4.310575e-11])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/update_matrices_test.py:110: AssertionError
_____________________ update_matrices_tests.test_update_P ______________________
self = <osqp.tests.update_matrices_test.update_matrices_tests testMethod=test_update_P>
    def test_update_P(self):
        # Update matrix P
        Px = self.P_triu_new.data
        Px_idx = np.arange(self.P_triu_new.nnz)
        self.model.update(Px=Px, Px_idx=Px_idx)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P_new, self.q, self.A,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 5 / 5 (100%)
E       Max absolute difference: 1.53550889
E       Max relative difference: 14.49796299
E        x: array([-1.243371, -0.525746,  0.247115,  1.429597,  0.191722])
E        y: array([ 0.      ,  0.      ,  0.      , -0.105912,  0.178281])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/update_matrices_test.py:67: AssertionError
_________________ update_matrices_tests.test_update_P_A_allind _________________
self = <osqp.tests.update_matrices_test.update_matrices_tests testMethod=test_update_P_A_allind>
    def test_update_P_A_allind(self):
        # Update matrices P and A
        Px = self.P_triu_new.data
        Ax = self.A_new.data
        self.model.update(Px=Px, Ax=Ax)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P_new, self.q, self.A_new,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 5 / 5 (100%)
E       Max absolute difference: 0.23532033
E       Max relative difference: 3.91548261e+11
E        x: array([-0.150824,  0.23532 ,  0.02264 ,  0.144856,  0.076429])
E        y: array([0.000000e+00, 0.000000e+00, 0.000000e+00, 3.699569e-13,
E              9.143034e-12])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/update_matrices_test.py:174: AssertionError
__________________ update_matrices_tests.test_update_P_A_indA __________________
self = <osqp.tests.update_matrices_test.update_matrices_tests testMethod=test_update_P_A_indA>
    def test_update_P_A_indA(self):
        # Update matrices P and A
        Px = self.P_triu_new.data
        Ax = self.A_new.data
        Ax_idx = np.arange(self.A_new.nnz)
        self.model.update(Px=Px, Ax=Ax, Ax_idx=Ax_idx)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P_new, self.q, self.A_new,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 5 / 5 (100%)
E       Max absolute difference: 0.23532033
E       Max relative difference: 3.91548261e+11
E        x: array([-0.150824,  0.23532 ,  0.02264 ,  0.144856,  0.076429])
E        y: array([0.000000e+00, 0.000000e+00, 0.000000e+00, 3.699569e-13,
E              9.143034e-12])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/update_matrices_test.py:159: AssertionError
__________________ update_matrices_tests.test_update_P_A_indP __________________
self = <osqp.tests.update_matrices_test.update_matrices_tests testMethod=test_update_P_A_indP>
    def test_update_P_A_indP(self):
        # Update matrices P and A
        Px = self.P_triu_new.data
        Px_idx = np.arange(self.P_triu_new.nnz)
        Ax = self.A_new.data
        self.model.update(Px=Px, Px_idx=Px_idx, Ax=Ax)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P_new, self.q, self.A_new,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 5 / 5 (100%)
E       Max absolute difference: 0.23532033
E       Max relative difference: 3.91548261e+11
E        x: array([-0.150824,  0.23532 ,  0.02264 ,  0.144856,  0.076429])
E        y: array([0.000000e+00, 0.000000e+00, 0.000000e+00, 3.699569e-13,
E              9.143034e-12])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/update_matrices_test.py:143: AssertionError
_______________ update_matrices_tests.test_update_P_A_indP_indA ________________
self = <osqp.tests.update_matrices_test.update_matrices_tests testMethod=test_update_P_A_indP_indA>
    def test_update_P_A_indP_indA(self):
        # Update matrices P and A
        Px = self.P_triu_new.data
        Px_idx = np.arange(self.P_triu_new.nnz)
        Ax = self.A_new.data
        Ax_idx = np.arange(self.A_new.nnz)
        self.model.update(Px=Px, Px_idx=Px_idx, Ax=Ax, Ax_idx=Ax_idx)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P_new, self.q, self.A_new,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 5 / 5 (100%)
E       Max absolute difference: 0.23532033
E       Max relative difference: 3.91548261e+11
E        x: array([-0.150824,  0.23532 ,  0.02264 ,  0.144856,  0.076429])
E        y: array([0.000000e+00, 0.000000e+00, 0.000000e+00, 3.699569e-13,
E              9.143034e-12])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/update_matrices_test.py:127: AssertionError
__________________ update_matrices_tests.test_update_P_allind __________________
self = <osqp.tests.update_matrices_test.update_matrices_tests testMethod=test_update_P_allind>
    def test_update_P_allind(self):
        # Update matrix P
        Px = self.P_triu_new.data
        self.model.update(Px=Px)
        res = self.model.solve()
    
        x_sol, y_sol, obj_sol = solve_high_accuracy(self.P_new, self.q, self.A,
                                                    self.l, self.u)
        # Assert close
>       nptest.assert_allclose(res.x, x_sol, rtol=rel_tol, atol=abs_tol)
E       AssertionError: 
E       Not equal to tolerance rtol=0.001, atol=0.0001
E       
E       Mismatched elements: 5 / 5 (100%)
E       Max absolute difference: 1.53550889
E       Max relative difference: 14.49796299
E        x: array([-1.243371, -0.525746,  0.247115,  1.429597,  0.191722])
E        y: array([ 0.      ,  0.      ,  0.      , -0.105912,  0.178281])
../_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_p/lib/python3.6/site-packages/osqp/tests/update_matrices_test.py:81: AssertionError
=========================== short test summary info ============================
FAILED tests/basic_test.py::basic_tests::test_basic_QP - AssertionError: 
FAILED tests/basic_test.py::basic_tests::test_update_bounds - AssertionError: 
FAILED tests/basic_test.py::basic_tests::test_update_l - AssertionError: 
FAILED tests/basic_test.py::basic_tests::test_update_q - AssertionError: 
FAILED tests/basic_test.py::basic_tests::test_update_u - AssertionError: 
FAILED tests/feasibility_test.py::feasibility_tests::test_feasibility_problem
FAILED tests/polishing_test.py::polish_tests::test_polish_random - AssertionE...
FAILED tests/polishing_test.py::polish_tests::test_polish_simple - AssertionE...
FAILED tests/polishing_test.py::polish_tests::test_polish_unconstrained - Typ...
FAILED tests/unconstrained_test.py::unconstrained_tests::test_unconstrained_problem
FAILED tests/update_matrices_test.py::update_matrices_tests::test_solve - Ass...
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_A - ...
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_A_allind
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P - ...
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_A_allind
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_A_indA
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_A_indP
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_A_indP_indA
FAILED tests/update_matrices_test.py::update_matrices_tests::test_update_P_allind
================== 19 failed, 33 passed, 1 skipped in 25.76s ===================

[Tobias-Fischer]

Hi @h-vetinari - this is blocking some new repos that I am working on. Did you have any more luck looking into this?

[h-vetinari]

Hey @Tobias-Fischer, I've been trying to work on this in #32, but neither the person who originally helped get this off the ground (@jayfurmanek) nor the upstream maintainers have responded to my pings & questions.

Anyone can go and try to debug this, and I'll happily merge a PR that manages to, but - much as it pains me to say - I currently consider the ppc64le builds to be dead in the water. Unless those other repos you mention are ppc64le-only, I'd suggest skipping those builds and re-enabling them sometime later.

[Tobias-Fischer]

Okay, many thanks for letting me know!