[examples/python] Add util.py file, move "generate_mixed_qp" function…

… to it

give reg a meaning

examples/python/estimate_nonconvex_eigenvalue.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1, reg=-2.0):
-    # A function for generating sparse random convex qps in dense format
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp object using qp problem dimensions

examples/python/init_dense_qp.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating random convex qps
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp object using qp problem dimensions

examples/python/init_dense_qp_with_box.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating random convex qps
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp object using qp problem dimensions

examples/python/init_dense_qp_with_other_options.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating random convex qps
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp object using qp problem dimensions

examples/python/init_dense_qp_with_timings.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating random convex qps
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp object using qp problem dimensions

examples/python/init_with_default_options.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating random convex qps
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp object using qp problem dimensions

examples/python/loading_sparse_qp.py

@@ -8,36 +8,11 @@
 
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating random convex qps
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc")
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P, q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp2 object using matrix masks
-H, g, A, b, C, u, l = generate_mixed_qp(n)
+H, g, A, b, C, u, l = generate_mixed_qp(n, True)
 
 H_ = H != 0.0
 A_ = A != 0.0

examples/python/overview-simple.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating sparse random convex qps in dense format
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # generate a qp problem

examples/python/solve_dense_qp.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating sparse random convex qps in dense format
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp object using qp problem dimensions

examples/python/solve_dense_qp_with_setting.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating sparse random convex qps in dense format
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp object using qp problem dimensions

examples/python/solve_without_api.py

@@ -1,32 +1,7 @@
 import proxsuite
 import numpy as np
 import scipy.sparse as spa
-
-
-def generate_mixed_qp(n, seed=1):
-    # A function for generating sparse random convex qps in dense format
-
-    np.random.seed(seed)
-    n_eq = int(n / 4)
-    n_in = int(n / 4)
-    m = n_eq + n_in
-
-    P = spa.random(
-        n, n, density=0.075, data_rvs=np.random.randn, format="csc"
-    ).toarray()
-    P = (P + P.T) / 2.0
-
-    s = max(np.absolute(np.linalg.eigvals(P)))
-    P += (abs(s) + 1e-02) * spa.eye(n)
-    P = spa.coo_matrix(P)
-    q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc")
-    v = np.random.randn(n)  # Fictitious solution
-    delta = np.random.rand(m)  # To get inequality
-    u = A @ v
-    l = -1.0e20 * np.ones(m)
-
-    return P, q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+from util import generate_mixed_qp
 
 
 # load a qp object using qp problem dimensions
@@ -40,9 +15,7 @@ def generate_mixed_qp(n, seed=1):
 
 # solve the problem using the dense backend
 
-results2 = proxsuite.proxqp.dense.solve(
-    H.toarray(), g, A.toarray(), b, C.toarray(), l, u
-)
+results2 = proxsuite.proxqp.dense.solve(H, g, A.toarray(), b, C.toarray(), l, u)
 # Note finally, that the matrices are in sparse format, when using the dense backend you
 # should convert them in dense format