adding unit-tests and improvements to NLP interface. (#6)

* adding many tests, new smoothcanon for min, and improvements to ipopt_nlpif

* fixing last two tests

* add another example, qcp

* adding example for acopf

* add control of a car example done

---------

Co-authored-by: William Zijie Zhang <william@gridmatic.com>

Author: Transurgeon

cvxpy/atoms/__init__.py

@@ -68,6 +68,7 @@
 from cvxpy.atoms.elementwise.sqrt import sqrt
 from cvxpy.atoms.elementwise.square import square
 from cvxpy.atoms.elementwise.xexp import xexp
+from cvxpy.atoms.elementwise.trig import sin, cos, tan
 from cvxpy.atoms.eye_minus_inv import eye_minus_inv, resolvent
 from cvxpy.atoms.gen_lambda_max import gen_lambda_max
 from cvxpy.atoms.geo_mean import geo_mean

cvxpy/atoms/elementwise/trig.py

@@ -0,0 +1,202 @@
+"""
+Copyright 2025 CVXPY Developers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+from typing import List, Tuple
+
+import numpy as np
+
+from cvxpy.atoms.elementwise.elementwise import Elementwise
+from cvxpy.constraints.constraint import Constraint
+
+
+class sin(Elementwise):
+    """Elementwise :math:`\\sin x`.
+    """
+
+    def __init__(self, x) -> None:
+        super(sin, self).__init__(x)
+
+    @Elementwise.numpy_numeric
+    def numeric(self, values):
+        """Returns the elementwise sine of x.
+        """
+        return np.sin(values[0])
+
+    def sign_from_args(self) -> Tuple[bool, bool]:
+        """Returns sign (is positive, is negative) of the expression.
+        """
+        # Always unknown.
+        return (False, False)
+
+    def is_atom_convex(self) -> bool:
+        """Is the atom convex?
+        """
+        return False
+
+    def is_atom_concave(self) -> bool:
+        """Is the atom concave?
+        """
+        return True
+
+    def is_atom_log_log_convex(self) -> bool:
+        """Is the atom log-log convex?
+        """
+        return False
+
+    def is_atom_log_log_concave(self) -> bool:
+        """Is the atom log-log concave?
+        """
+        return True
+
+    def is_incr(self, idx) -> bool:
+        """Is the composition non-decreasing in argument idx?
+        """
+        return True
+
+    def is_decr(self, idx) -> bool:
+        """Is the composition non-increasing in argument idx?
+        """
+        return False
+
+    def _domain(self) -> List[Constraint]:
+        """Returns constraints describing the domain of the node.
+        """
+        return []
+
+    def _grad(self) -> List[Constraint]:
+        """Returns the gradient of the node.
+        """
+        return []
+
+
+class cos(Elementwise):
+    """Elementwise :math:`\\cos x`.
+    """
+
+    def __init__(self, x) -> None:
+        super(cos, self).__init__(x)
+
+    @Elementwise.numpy_numeric
+    def numeric(self, values):
+        """Returns the elementwise cosine of x.
+        """
+        return np.cos(values[0])
+
+    def sign_from_args(self) -> Tuple[bool, bool]:
+        """Returns sign (is positive, is negative) of the expression.
+        """
+        # Always unknown.
+        return (False, False)
+
+    def is_atom_convex(self) -> bool:
+        """Is the atom convex?
+        """
+        return False
+
+    def is_atom_concave(self) -> bool:
+        """Is the atom concave?
+        """
+        return True
+
+    def is_atom_log_log_convex(self) -> bool:
+        """Is the atom log-log convex?
+        """
+        return False
+
+    def is_atom_log_log_concave(self) -> bool:
+        """Is the atom log-log concave?
+        """
+        return True
+
+    def is_incr(self, idx) -> bool:
+        """Is the composition non-decreasing in argument idx?
+        """
+        return True
+
+    def is_decr(self, idx) -> bool:
+        """Is the composition non-increasing in argument idx?
+        """
+        return False
+
+    def _domain(self) -> List[Constraint]:
+        """Returns constraints describing the domain of the node.
+        """
+        return []
+
+    def _grad(self) -> List[Constraint]:
+        """Returns the gradient of the node.
+        """
+        return []
+
+
+class tan(Elementwise):
+    """Elementwise :math:`\\tan x`.
+    """
+
+    def __init__(self, x) -> None:
+        super(tan, self).__init__(x)
+
+    @Elementwise.numpy_numeric
+    def numeric(self, values):
+        """Returns the elementwise tangent of x.
+        """
+        return np.tan(values[0])
+
+    def sign_from_args(self) -> Tuple[bool, bool]:
+        """Returns sign (is positive, is negative) of the expression.
+        """
+        # Always unknown.
+        return (False, False)
+
+    def is_atom_convex(self) -> bool:
+        """Is the atom convex?
+        """
+        return False
+
+    def is_atom_concave(self) -> bool:
+        """Is the atom concave?
+        """
+        return True
+
+    def is_atom_log_log_convex(self) -> bool:
+        """Is the atom log-log convex?
+        """
+        return False
+
+    def is_atom_log_log_concave(self) -> bool:
+        """Is the atom log-log concave?
+        """
+        return True
+
+    def is_incr(self, idx) -> bool:
+        """Is the composition non-decreasing in argument idx?
+        """
+        return True
+
+    def is_decr(self, idx) -> bool:
+        """Is the composition non-increasing in argument idx?
+        """
+        return False
+
+    def _domain(self) -> List[Constraint]:
+        """Returns constraints describing the domain of the node.
+        """
+        return []
+
+    def _grad(self) -> List[Constraint]:
+        """Returns the gradient of the node.
+        """
+        return []
+    

cvxpy/reductions/expr2smooth/canonicalizers/__init__.py

@@ -14,9 +14,11 @@
 limitations under the License.
 """
 from cvxpy.atoms import maximum
+from cvxpy.atoms.elementwise.minimum import minimum
 from cvxpy.atoms.elementwise.power import power
 from cvxpy.atoms.pnorm import Pnorm
 from cvxpy.atoms.elementwise.abs import abs
+from cvxpy.reductions.expr2smooth.canonicalizers.minimum_canon import minimum_canon
 from cvxpy.reductions.expr2smooth.canonicalizers.abs_canon import abs_canon
 from cvxpy.reductions.expr2smooth.canonicalizers.pnorm_canon import pnorm_canon
 from cvxpy.reductions.expr2smooth.canonicalizers.power_canon import power_canon
@@ -25,8 +27,9 @@
 CANON_METHODS = {
     abs: abs_canon,
     maximum : maximum_canon,
+    minimum: minimum_canon,
     # log: log_canon,
-    power: power_canon,
-    Pnorm : pnorm_canon,
+    #power: power_canon,
+    #Pnorm : pnorm_canon,
     # inv: inv_pos_canon,
 }

cvxpy/reductions/expr2smooth/canonicalizers/minimum_canon.py

@@ -0,0 +1,27 @@
+"""
+Copyright 2025 CVXPY developers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from cvxpy.atoms.elementwise.maximum import maximum
+from cvxpy.reductions.expr2smooth.canonicalizers.maximum_canon import (
+    maximum_canon,
+)
+
+
+def minimum_canon(expr, args):
+    del expr
+    temp = maximum(*[-arg for arg in args])
+    canon, constr = maximum_canon(temp, temp.args)
+    return -canon, constr

cvxpy/reductions/expr2smooth/canonicalizers/power_canon.py

@@ -36,3 +36,9 @@ def power_canon(expr, args):
         t = Variable(shape)
         if 0 < p < 1:
             return t, [t**(1/p) == x, t >= 0]
+        elif p > 1:
+            return x**p, []
+        else:  # p < 0
+            raise ValueError(
+                "Power canonicalization does not support negative powers."
+            )

cvxpy/reductions/solvers/nlp_solvers/ipopt_nlpif.py

@@ -120,8 +120,14 @@ def solve_via_data(self, data, warm_start: bool, verbose: bool, solver_opts, sol
         """
         import cyipopt
         bounds = self.Bounds(data["problem"])
-        x0 = [12, 5, 0]
-
+        initial_values = []
+        for var in bounds.main_var:
+            if var.value is not None:
+                initial_values.append(var.value.flatten(order='F'))
+            else:
+                # If no initial value, use zero
+                initial_values.append(np.zeros(var.size))
+        x0 = np.concatenate(initial_values, axis=0)
         nlp = cyipopt.Problem(
         n=len(x0),
         m=len(bounds.cl),
@@ -134,7 +140,7 @@ def solve_via_data(self, data, warm_start: bool, verbose: bool, solver_opts, sol
         nlp.add_option('mu_strategy', 'adaptive')
         nlp.add_option('tol', 1e-7)
         nlp.add_option('hessian_approximation', "limited-memory")
-        x, info = nlp.solve(x0)
+        _, info = nlp.solve(x0)
         return info
 
     def cite(self, data):
@@ -160,7 +166,7 @@ def objective(self, x):
             offset = 0
             for var in self.main_var:
                 size = var.size
-                var.value = x[offset:offset+size]
+                var.value = x[offset:offset+size].reshape(var.shape, order='F')
                 offset += size
             # Evaluate the objective
             obj_value = self.problem.objective.args[0].value
@@ -173,7 +179,7 @@ def gradient(self, x):
             torch_exprs = []
             for var in self.main_var:
                 size = var.size
-                slice = x[offset:offset+size]
+                slice = x[offset:offset+size].reshape(var.shape, order='F')
                 torch_exprs.append(torch.from_numpy(slice.astype(np.float64)).requires_grad_(True))
                 offset += size
 
@@ -196,7 +202,7 @@ def constraints(self, x):
             offset = 0
             for var in self.main_var:
                 size = var.size
-                var.value = x[offset:offset+size]
+                var.value = x[offset:offset+size].reshape(var.shape, order='F')
                 offset += size
 
             # Evaluate all constraints
@@ -214,7 +220,7 @@ def jacobian(self, x):
 
             for var in self.main_var:
                 size = var.size
-                slice = x[offset:offset+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)
@@ -245,7 +251,7 @@ def constraint_function(*args):
                         *constr_torch_args
                     )
                     constraint_values.append(torch_expr)
-                return torch.cat([torch.atleast_1d(cv) for cv in constraint_values])
+                return torch.cat([cv.flatten() for cv in constraint_values])
 
             # Compute Jacobian using torch.autograd.functional.jacobian
             if len(self.problem.constraints) > 0:
@@ -254,7 +260,10 @@ def constraint_function(*args):
                 # Handle the case where jacobian_tuple is a tuple (multiple variables)
                 if isinstance(jacobian_tuple, tuple):
                     # Concatenate along the last dimension (variable dimension)
-                    jacobian_matrix = torch.cat(jacobian_tuple, dim=-1)
+                    jacobian_matrix = torch.cat(
+                        [jac.reshape(jac.size(0), -1) for jac in jacobian_tuple],
+                        dim=1
+                    )
                 else:
                     # Single variable case
                     jacobian_matrix = jacobian_tuple
@@ -298,8 +307,8 @@ def get_variable_bounds(self):
             for var in self.main_var:
                 size = var.size
                 if var.bounds:
-                    var_lower.extend(var.bounds[0])
-                    var_upper.extend(var.bounds[1])
+                    var_lower.extend(var.bounds[0].flatten(order='F'))
+                    var_upper.extend(var.bounds[1].flatten(order='F'))
                 else:
                     # No bounds specified, use infinite bounds
                     var_lower.extend([-np.inf] * size)