add changes to the jacobian computation

Author: Transurgeon

cvxpy/reductions/solvers/nlp_solvers/ipopt_nlpif.py

@@ -214,27 +214,31 @@ def constraints(self, x):
         def jacobian(self, x):
             """Returns the Jacobian of the constraints with respect to x."""
             # Convert to torch tensor with gradient tracking
-            offset = 0
-            torch_vars_dict = {}
-            torch_exprs = []
-            
-            for var in self.main_var:
-                size = var.size
-                slice = x[offset:offset+size].reshape(var.shape, order='F')
-                torch_tensor = torch.from_numpy(slice.astype(np.float64)).requires_grad_(True)
-                torch_vars_dict[var.id] = torch_tensor  # Map CVXPY variable ID to torch tensor
-                torch_exprs.append(torch_tensor)
-                offset += size
-            
+            x = torch.from_numpy(x.astype(np.float64)).requires_grad_(True)
+
             # Define a function that computes all constraint values
-            def constraint_function(*args):
+            def constraint_function(x):
+                from cvxtorch.utils.torch_utils import tensor_reshape_fortran
+                offset = 0
+                torch_vars_dict = {}
+                torch_exprs = []
+                for var in self.main_var:
+                    size = var.size
+                    slice = x[offset:offset+size].reshape(var.shape)
+                    #slice = x[offset:offset+size].reshape(var.shape, order='F')
+                    torch_vars_dict[var.id] = slice # Map CVXPY variable ID to torch tensor
+                    torch_exprs.append(slice)
+                    offset += size
+                
                 # Create mapping from torch tensors back to CVXPY variables
                 torch_to_var = {}
                 for i, var in enumerate(self.main_var):
-                    torch_to_var[var.id] = args[i]
+                    torch_to_var[var.id] = torch_exprs[i]
 
                 constraint_values = []
                 for constraint in self.problem.constraints:
+                    # all constraints have a single argument
+                    # because they are "normalized" in the reduction
                     constraint_expr = constraint.args[0]
                     constraint_vars = constraint_expr.variables()
 
@@ -255,8 +259,7 @@ def constraint_function(*args):
 
             # Compute Jacobian using torch.autograd.functional.jacobian
             if len(self.problem.constraints) > 0:
-                jacobian_tuple = torch.autograd.functional.jacobian(constraint_function, 
-                                                                    tuple(torch_exprs))
+                jacobian_tuple = torch.autograd.functional.jacobian(constraint_function, x)
                 # Handle the case where jacobian_tuple is a tuple (multiple variables)
                 if isinstance(jacobian_tuple, tuple):
                     # Concatenate along the last dimension (variable dimension)

cvxpy/sandbox/control_of_car.py

@@ -4,7 +4,7 @@
 import cvxpy as cp
 
 
-def solve_car_control(x_final, L=0.1, N=25, h=0.1, gamma=10):
+def solve_car_control(x_final, L=0.1, N=2, h=0.1, gamma=10):
     """
     Solve the nonlinear optimal control problem for car trajectory planning.
     

cvxpy/sandbox/control_of_car_matrix.py

@@ -3,7 +3,7 @@
 import matplotlib.pyplot as plt
 
 
-def solve_car_control(x_final, L=0.1, N=10, h=0.1, gamma=10):
+def solve_car_control(x_final, L=0.1, N=2, h=0.1, gamma=10):
     """
     Solve the nonlinear optimal control problem for car trajectory planning.
     
@@ -73,7 +73,7 @@ def solve_car_control(x_final, L=0.1, N=10, h=0.1, gamma=10):
 
     # Solve using an appropriate solver
     # For nonlinear problems, we might need special solver options
-    problem.solve(solver=cp.SCS, verbose=True)
+    problem.solve(solver=cp.IPOPT, nlp=True, verbose=True)
 
     # Extract solution
     x_opt = x.value
@@ -165,7 +165,7 @@ def plot_trajectory(x_opt, u_opt, L, h, title="Car Trajectory"):
 
         except Exception as e:
             print(f"Error: {e}")
-    
+"""
     # Additional analysis: plot control inputs
     if x_opt is not None and u_opt is not None:
         fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 6))
@@ -184,3 +184,4 @@ def plot_trajectory(x_opt, u_opt, L, h, title="Car Trajectory"):
         
         plt.tight_layout()
         plt.show()
+"""

cvxpy/sandbox/direct_ipopt_call.py

@@ -1,12 +1,12 @@
 import cvxpy as cp
 
 # Define variables
-x = cp.Variable(1)
-y = cp.Variable(1)
+x = cp.Variable(3)
+y = cp.Variable(3)
 
-objective = cp.Maximize(cp.maximum(x, y))
+objective = cp.Maximize(cp.sum(cp.maximum(x, y)))
 
-constraints = [x - 14 == 0, y - 6 == 0]
+constraints = [x <= 14, y <= 6]
 
 problem = cp.Problem(objective, constraints)
 print(cp.installed_solvers())

cvxpy/sandbox/entr_max.py

@@ -0,0 +1,15 @@
+import cvxpy as cp
+import numpy as np
+
+k = 5
+x = cp.Variable((k, k))
+x.value = np.ones((k, k)) / k**2
+left = np.ones(k) / k
+right = np.exp(-np.linspace(-1, 1, k)**2)
+right = right / np.sum(right)
+obj = cp.entr(x).sum()
+constr = [cp.sum(x, axis=1) == right,
+            cp.sum(x, axis=0) == left]
+problem = cp.Problem(cp.Maximize(obj), constr)
+problem.solve(solver=cp.IPOPT, nlp=True)
+assert problem.status == cp.OPTIMAL