Refactor Python examples with a new "util.py" file

CHANGELOG.md

@@ -13,6 +13,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * Fix cereal include directory in cmake ([#340](https://github.com/Simple-Robotics/proxsuite/pull/340))
 * Extend doc with hint for conda installation from source ([#340](https://github.com/Simple-Robotics/proxsuite/pull/340))
 
+### Changed
+
+* Refactor Python examples with a new "util.py" file ([#347](https://github.com/Simple-Robotics/proxsuite/pull/347))
+
 ## [0.6.6] - 2024-06-15
 
 ### Fixed

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,39 +1,14 @@
 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
 n = 10
 n_eq = 2
 n_in = 2
-H, g, A, b, C, u, l = generate_mixed_qp(n)
+H, g, A, b, C, u, l = generate_mixed_qp(n, True)
 
 # solve the problem using the sparse backend
 results = proxsuite.proxqp.sparse.solve(H, g, A, b, C, l, u)