openscvx 0.3.2.dev195__tar.gz → 0.3.2.dev210__tar.gz

{openscvx-0.3.2.dev195/openscvx.egg-info → openscvx-0.3.2.dev210}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev195
+Version: 0.3.2.dev210
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License

{openscvx-0.3.2.dev195 → openscvx-0.3.2.dev210}/openscvx/__init__.py

@@ -15,6 +15,7 @@ from openscvx.symbolic.expr import (
     CTCS,
     Abs,
     Add,
+    Bilerp,
     Block,
     Concat,
     Constant,
@@ -31,7 +32,9 @@ from openscvx.symbolic.expr import (
     Hstack,
     Index,
     Inequality,
+    Inv,
     Leaf,
+    Linterp,
     Log,
     LogSumExp,
     MatMul,
@@ -96,6 +99,7 @@ __all__ = [
     "Vstack",
     "Block",
     "Diag",
+    "Inv",
     "Constant",
     # Mathematical functions
     "Sin",
@@ -107,6 +111,8 @@ __all__ = [
     "Log",
     "LogSumExp",
     "Max",
+    "Linterp",
+    "Bilerp",
     # Constraints
     "Constraint",
     "Equality",

{openscvx-0.3.2.dev195 → openscvx-0.3.2.dev210}/openscvx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2.dev195'
-__version_tuple__ = version_tuple = (0, 3, 2, 'dev195')
+__version__ = version = '0.3.2.dev210'
+__version_tuple__ = version_tuple = (0, 3, 2, 'dev210')
 
-__commit_id__ = commit_id = 'ged5d19a8c'
+__commit_id__ = commit_id = 'g28ab57c34'

{openscvx-0.3.2.dev195 → openscvx-0.3.2.dev210}/openscvx/symbolic/expr/__init__.py

@@ -113,14 +113,16 @@ from .lie import (
 )
 
 # Linear algebra operations
-from .linalg import Diag, Norm, Sum, Transpose
+from .linalg import Diag, Inv, Norm, Sum, Transpose
 
 # Mathematical functions
 from .math import (
     Abs,
+    Bilerp,
     Cos,
     Exp,
     Huber,
+    Linterp,
     Log,
     LogSumExp,
     Max,
@@ -194,6 +196,8 @@ __all__ = [
     "Log",
     "LogSumExp",
     "Max",
+    "Linterp",
+    "Bilerp",
     # Linear algebra operations
     "Transpose",
     "Stack",
@@ -202,6 +206,7 @@ __all__ = [
     "Block",
     "Norm",
     "Diag",
+    "Inv",
     # Spatial/3D operations
     "QDCM",
     "SSMP",

{openscvx-0.3.2.dev195 → openscvx-0.3.2.dev210}/openscvx/symbolic/expr/linalg.py

@@ -8,6 +8,7 @@ Key Operations:
     - **Matrix Operations:**
         - `Transpose` - Matrix/tensor transposition (swaps last two dimensions)
         - `Diag` - Construct diagonal matrix from vector
+        - `Inv` - Matrix inverse (square matrices only, JAX lowering only)
     - **Reductions:**
         - `Sum` - Sum all elements of an array (reduces to scalar)
         - `Norm` - Euclidean (L2) norm and other norms of vectors/matrices
@@ -50,7 +51,9 @@ Example:
 import hashlib
 from typing import Tuple
 
-from .expr import Expr, to_expr
+import numpy as np
+
+from .expr import Constant, Expr, to_expr
 
 
 class Transpose(Expr):
@@ -213,6 +216,85 @@ class Sum(Expr):
         return f"sum({self.operand!r})"
 
 
+class Inv(Expr):
+    """Matrix inverse operation for symbolic expressions.
+
+    Computes the inverse of a square matrix. For batched inputs with shape
+    (..., M, M), inverts the last two dimensions following jax.numpy.linalg.inv
+    conventions.
+
+    The canonicalization includes an optimization that eliminates double inverses:
+    Inv(Inv(A)) simplifies to A.
+
+    Attributes:
+        operand: Square matrix expression to invert
+
+    Example:
+        Define matrix inverse expressions::
+
+            M = Variable("M", shape=(3, 3))
+            M_inv = Inv(M)  # Result shape (3, 3)
+
+            # Batched case
+            M_batch = Variable("M_batch", shape=(5, 3, 3))
+            M_batch_inv = Inv(M_batch)  # Result shape (5, 3, 3)
+
+    Note:
+        Matrix inverse is non-convex and only supported in JAX lowering.
+        CVXPy lowering will raise NotImplementedError since inv(X) is neither
+        convex nor concave for variable matrices.
+
+    !!! warning
+        Solving a matrix inverse inside an optimization loop can be somewhat
+        of an oxymoron and performance may be severly impacted.
+        Consider whether your problem can be reformulated to avoid the inverse.
+    """
+
+    def __init__(self, operand):
+        """Initialize a matrix inverse operation.
+
+        Args:
+            operand: Square matrix expression to invert. Must have shape
+                (..., M, M) where the last two dimensions are equal.
+        """
+        self.operand = to_expr(operand)
+
+    def children(self):
+        return [self.operand]
+
+    def canonicalize(self) -> "Expr":
+        """Canonicalize the operand with double inverse optimization and constant folding."""
+        operand = self.operand.canonicalize()
+
+        # Double inverse optimization: Inv(Inv(A)) = A
+        if isinstance(operand, Inv):
+            return operand.operand
+
+        # Constant folding: compute inverse at canonicalization time
+        if isinstance(operand, Constant):
+            return Constant(np.linalg.inv(operand.value))
+
+        return Inv(operand)
+
+    def check_shape(self) -> Tuple[int, ...]:
+        """Matrix inverse preserves shape; validates square matrix."""
+        operand_shape = self.operand.check_shape()
+
+        if len(operand_shape) < 2:
+            raise ValueError(f"Inv requires at least a 2D matrix, got shape {operand_shape}")
+
+        if operand_shape[-1] != operand_shape[-2]:
+            raise ValueError(
+                f"Inv requires a square matrix (last two dims must be equal), "
+                f"got shape {operand_shape}"
+            )
+
+        return operand_shape
+
+    def __repr__(self):
+        return f"inv({self.operand!r})"
+
+
 class Norm(Expr):
     """Norm operation for symbolic expressions (reduction to scalar).
 

{openscvx-0.3.2.dev195 → openscvx-0.3.2.dev210}/openscvx/symbolic/expr/math.py

@@ -697,3 +697,205 @@ class LogSumExp(Expr):
     def __repr__(self):
         inner = ", ".join(repr(op) for op in self.operands)
         return f"logsumexp({inner})"
+
+
+class Linterp(Expr):
+    """1D linear interpolation for symbolic expressions.
+
+    Computes the linear interpolant of data points (xp, fp) evaluated at x,
+    equivalent to jax.numpy.interp(x, xp, fp). For values outside the data range,
+    the boundary values are returned (no extrapolation).
+
+    This is useful for incorporating tabulated data (e.g., atmospheric properties,
+    engine thrust curves, aerodynamic coefficients) into trajectory optimization
+    dynamics and constraints.
+
+    Attributes:
+        x: Query point(s) at which to evaluate the interpolant (symbolic expression)
+        xp: 1D array of x-coordinates of data points (must be increasing)
+        fp: 1D array of y-coordinates of data points (same length as xp)
+
+    Example:
+        Interpolate atmospheric density from altitude table::
+
+            import openscvx as ox
+            import numpy as np
+
+            # US 1976 Standard Atmosphere data
+            alt_data = np.array([0, 5000, 10000, 15000, 20000])  # meters
+            rho_data = np.array([1.225, 0.736, 0.414, 0.195, 0.089])  # kg/m^3
+
+            altitude = ox.State("altitude", shape=(1,))
+            rho = ox.Linterp(altitude[0], alt_data, rho_data)
+
+            # rho can now be used in dynamics expressions
+            drag = 0.5 * rho * v**2 * Cd * S
+
+    Note:
+        - xp must be strictly increasing
+        - For query points outside [xp[0], xp[-1]], boundary values are returned
+    """
+
+    def __init__(self, x, xp, fp):
+        """Initialize a 1D linear interpolation node.
+
+        Args:
+            x: Query point(s) at which to evaluate the interpolant.
+                Can be a scalar or array symbolic expression.
+            xp: 1D array of x-coordinates of data points. Must be increasing.
+                Can be a numpy array or Constant expression.
+            fp: 1D array of y-coordinates of data points. Must have same length as xp.
+                Can be a numpy array or Constant expression.
+        """
+        self.x = to_expr(x)
+        self.xp = to_expr(xp)
+        self.fp = to_expr(fp)
+
+    def children(self):
+        return [self.x, self.xp, self.fp]
+
+    def canonicalize(self) -> "Expr":
+        """Canonicalize by canonicalizing all operands."""
+        x = self.x.canonicalize()
+        xp = self.xp.canonicalize()
+        fp = self.fp.canonicalize()
+        return Linterp(x, xp, fp)
+
+    def check_shape(self) -> Tuple[int, ...]:
+        """Output shape matches the query point shape.
+
+        The interpolation is element-wise over x, so the output has
+        the same shape as the query points.
+
+        Returns:
+            tuple: Shape of the query point x
+
+        Raises:
+            ValueError: If xp and fp have different lengths or are not 1D
+        """
+        xp_shape = self.xp.check_shape()
+        fp_shape = self.fp.check_shape()
+
+        if len(xp_shape) != 1:
+            raise ValueError(f"Linterp xp must be 1D, got shape {xp_shape}")
+        if len(fp_shape) != 1:
+            raise ValueError(f"Linterp fp must be 1D, got shape {fp_shape}")
+        if xp_shape != fp_shape:
+            raise ValueError(
+                f"Linterp xp and fp must have same length, got {xp_shape} vs {fp_shape}"
+            )
+
+        return self.x.check_shape()
+
+    def __repr__(self):
+        return f"linterp({self.x!r}, {self.xp!r}, {self.fp!r})"
+
+
+class Bilerp(Expr):
+    """2D bilinear interpolation for symbolic expressions.
+
+    Performs bilinear interpolation on a regular 2D grid. Given grid points
+    (xp, yp) and corresponding values fp, computes the bilinearly interpolated
+    value at query point (x, y). For values outside the grid, boundary values
+    are returned (clamping, no extrapolation).
+
+    This is useful for incorporating 2D tabulated data (e.g., engine thrust
+    as a function of altitude and Mach number, aerodynamic coefficients as
+    a function of angle of attack and sideslip) into trajectory optimization.
+
+    Attributes:
+        x: Query x-coordinate (symbolic expression)
+        y: Query y-coordinate (symbolic expression)
+        xp: 1D array of x grid coordinates (must be increasing), length N
+        yp: 1D array of y grid coordinates (must be increasing), length M
+        fp: 2D array of values with shape (N, M), where fp[i, j] is the
+            value at grid point (xp[i], yp[j])
+
+    Example:
+        Interpolate engine thrust from altitude and Mach number::
+
+            import openscvx as ox
+            import numpy as np
+
+            # Grid coordinates
+            alt_grid = np.array([0, 5000, 10000, 15000, 20000])  # meters
+            mach_grid = np.array([0.0, 0.5, 1.0, 1.5, 2.0])
+
+            # Thrust values: thrust_table[i, j] = thrust at (alt_grid[i], mach_grid[j])
+            thrust_table = np.array([...])  # shape (5, 5)
+
+            altitude = ox.State("altitude", shape=(1,))
+            mach = ox.State("mach", shape=(1,))
+
+            thrust = ox.Bilerp(altitude[0], mach[0], alt_grid, mach_grid, thrust_table)
+
+    Note:
+        - xp and yp must be strictly increasing
+        - fp must have shape (len(xp), len(yp))
+        - For query points outside the grid, boundary values are returned
+        - This node is only supported in JAX lowering (dynamics/cost), not CVXPy
+    """
+
+    def __init__(self, x, y, xp, yp, fp):
+        """Initialize a 2D bilinear interpolation node.
+
+        Args:
+            x: Query x-coordinate. Can be a scalar symbolic expression.
+            y: Query y-coordinate. Can be a scalar symbolic expression.
+            xp: 1D array of x grid coordinates. Must be increasing.
+            yp: 1D array of y grid coordinates. Must be increasing.
+            fp: 2D array of values with shape (len(xp), len(yp)).
+        """
+        self.x = to_expr(x)
+        self.y = to_expr(y)
+        self.xp = to_expr(xp)
+        self.yp = to_expr(yp)
+        self.fp = to_expr(fp)
+
+    def children(self):
+        return [self.x, self.y, self.xp, self.yp, self.fp]
+
+    def canonicalize(self) -> "Expr":
+        """Canonicalize by canonicalizing all operands."""
+        x = self.x.canonicalize()
+        y = self.y.canonicalize()
+        xp = self.xp.canonicalize()
+        yp = self.yp.canonicalize()
+        fp = self.fp.canonicalize()
+        return Bilerp(x, y, xp, yp, fp)
+
+    def check_shape(self) -> Tuple[int, ...]:
+        """Output shape is scalar (single interpolated value).
+
+        Returns:
+            tuple: Empty tuple (scalar output)
+
+        Raises:
+            ValueError: If grid arrays have invalid shapes
+        """
+        xp_shape = self.xp.check_shape()
+        yp_shape = self.yp.check_shape()
+        fp_shape = self.fp.check_shape()
+        x_shape = self.x.check_shape()
+        y_shape = self.y.check_shape()
+
+        if len(xp_shape) != 1:
+            raise ValueError(f"Bilerp xp must be 1D, got shape {xp_shape}")
+        if len(yp_shape) != 1:
+            raise ValueError(f"Bilerp yp must be 1D, got shape {yp_shape}")
+        if len(fp_shape) != 2:
+            raise ValueError(f"Bilerp fp must be 2D, got shape {fp_shape}")
+        if fp_shape != (xp_shape[0], yp_shape[0]):
+            raise ValueError(
+                f"Bilerp fp shape {fp_shape} must match (len(xp), len(yp)) = "
+                f"({xp_shape[0]}, {yp_shape[0]})"
+            )
+        if x_shape != ():
+            raise ValueError(f"Bilerp x must be scalar, got shape {x_shape}")
+        if y_shape != ():
+            raise ValueError(f"Bilerp y must be scalar, got shape {y_shape}")
+
+        return ()
+
+    def __repr__(self):
+        return f"bilerp({self.x!r}, {self.y!r}, {self.xp!r}, {self.yp!r}, {self.fp!r})"

{openscvx-0.3.2.dev195 → openscvx-0.3.2.dev210}/openscvx/symbolic/lowerers/cvxpy.py

@@ -134,6 +134,7 @@ from openscvx.symbolic.expr import (
     CTCS,
     Abs,
     Add,
+    Bilerp,
     Block,
     Concat,
     Constant,
@@ -147,6 +148,7 @@ from openscvx.symbolic.expr import (
     Huber,
     Index,
     Inequality,
+    Linterp,
     Log,
     LogSumExp,
     MatMul,
@@ -170,6 +172,7 @@ from openscvx.symbolic.expr import (
     Vstack,
 )
 from openscvx.symbolic.expr.control import Control
+from openscvx.symbolic.expr.linalg import Inv
 from openscvx.symbolic.expr.state import State
 
 _CVXPY_VISITORS: Dict[Type[Expr], Callable] = {}
@@ -1121,6 +1124,34 @@ class CvxpyLowerer:
         operand = self.lower(node.operand)
         return operand.T
 
+    @visitor(Inv)
+    def _visit_inv(self, node: Inv) -> cp.Expression:
+        """Raise NotImplementedError for matrix inverse.
+
+        Matrix inverse is not DCP-compliant in CVXPy as it is neither convex
+        nor concave for variable matrices.
+
+        Args:
+            node: Inv expression node
+
+        Raises:
+            NotImplementedError: Always raised since matrix inverse is not DCP-compliant
+
+        Note:
+            For optimization problems requiring matrix inverse:
+            - If the matrix is constant/parameter, compute the inverse numerically
+              before passing to CVXPy
+            - Handle matrix inverse in the JAX dynamics/constraint layer instead
+            - Consider reformulating the problem to avoid explicit matrix inverse
+        """
+        raise NotImplementedError(
+            "Matrix inverse (Inv) is not DCP-compliant in CVXPy. "
+            "inv(X) is neither convex nor concave for variable matrices. "
+            "Consider: (1) computing the inverse numerically if the matrix is constant, "
+            "(2) handling this in the JAX layer instead, or "
+            "(3) reformulating the problem to avoid explicit matrix inverse."
+        )
+
     @visitor(Power)
     def _visit_power(self, node: Power) -> cp.Expression:
         """Lower element-wise power (base**exponent) to CVXPy expression.
@@ -1238,6 +1269,37 @@ class CvxpyLowerer:
         block_exprs = [[self.lower(block) for block in row] for row in node.blocks]
         return cp.bmat(block_exprs)
 
+    @visitor(Linterp)
+    def _visit_linterp(self, node: Linterp) -> cp.Expression:
+        """Raise NotImplementedError for linear interpolation.
+
+        Linear interpolation (Linterp) is not DCP-compliant in CVXPy as it
+        represents a piecewise-linear function that is neither convex nor
+        concave in general.
+
+        Args:
+            node: Linterp expression node
+
+        Raises:
+            NotImplementedError: Always raised since Linterp is not DCP-compliant
+        """
+        raise NotImplementedError("Linear interpolation (Linterp) is not DCP-compliant in CVXPy.")
+
+    @visitor(Bilerp)
+    def _visit_bilerp(self, node: Bilerp) -> cp.Expression:
+        """Raise NotImplementedError for bilinear interpolation.
+
+        Bilinear interpolation (Bilerp) is not DCP-compliant in CVXPy as it
+        represents a nonlinear function that is neither convex nor concave.
+
+        Args:
+            node: Bilerp expression node
+
+        Raises:
+            NotImplementedError: Always raised since Bilerp is not DCP-compliant
+        """
+        raise NotImplementedError("Bilinear interpolation (Bilerp) is not DCP-compliant in CVXPy.")
+
 
 def lower_to_cvxpy(expr: Expr, variable_map: Dict[str, cp.Expression] = None) -> cp.Expression:
     """Lower symbolic expression to CVXPy expression or constraint.

{openscvx-0.3.2.dev195 → openscvx-0.3.2.dev210}/openscvx/symbolic/lowerers/jax.py

@@ -121,6 +121,7 @@ from openscvx.symbolic.expr import (
     Add,
     Adjoint,
     AdjointDual,
+    Bilerp,
     Block,
     Concat,
     Constant,
@@ -136,6 +137,7 @@ from openscvx.symbolic.expr import (
     Huber,
     Index,
     Inequality,
+    Linterp,
     Log,
     LogSumExp,
     MatMul,
@@ -171,6 +173,7 @@ from openscvx.symbolic.expr.lie import (
     SO3Exp,
     SO3Log,
 )
+from openscvx.symbolic.expr.linalg import Inv
 from openscvx.symbolic.expr.state import State
 
 _JAX_VISITORS: Dict[Type[Expr], Callable] = {}
@@ -1227,6 +1230,22 @@ class JaxLowerer:
         f = self.lower(node.operand)
         return lambda x, u, node, params: jnp.diag(f(x, u, node, params))
 
+    @visitor(Inv)
+    def _visit_inv(self, node: Inv):
+        """Lower matrix inverse to JAX function.
+
+        Computes the inverse of a square matrix using jnp.linalg.inv.
+        Supports batched inputs with shape (..., M, M).
+
+        Args:
+            node: Inv expression node
+
+        Returns:
+            Function (x, u, node, params) -> inverse of operand matrix
+        """
+        f = self.lower(node.operand)
+        return lambda x, u, node, params: jnp.linalg.inv(f(x, u, node, params))
+
     @visitor(Or)
     def _visit_or(self, node: Or):
         """Lower STL disjunction (Or) to JAX using STLJax library.
@@ -1451,3 +1470,77 @@ class JaxLowerer:
                 return jax.vmap(inner, in_axes=axis)(data)
 
         return vmapped_fn
+
+    @visitor(Linterp)
+    def _visit_linterp(self, node: Linterp):
+        """Lower 1D linear interpolation to JAX function.
+
+        Uses jnp.interp which performs piecewise linear interpolation.
+        For query points outside the data range, boundary values are returned.
+
+        Args:
+            node: Linterp expression node with xp, fp, and x
+
+        Returns:
+            Function (x, u, node, params) -> interpolated value(s)
+
+        Note:
+            The xp and fp arrays are typically constants (tabulated data),
+            while x is typically a symbolic expression (state or derived value).
+            jnp.interp is differentiable through JAX's autodiff.
+        """
+        f_xp = self.lower(node.xp)
+        f_fp = self.lower(node.fp)
+        f_x = self.lower(node.x)
+
+        def linterp_fn(x, u, node_idx, params):
+            xp_val = f_xp(x, u, node_idx, params)
+            fp_val = f_fp(x, u, node_idx, params)
+            x_val = f_x(x, u, node_idx, params)
+            return jnp.interp(x_val, xp_val, fp_val)
+
+        return linterp_fn
+
+    @visitor(Bilerp)
+    def _visit_bilerp(self, node: Bilerp):
+        """Lower 2D bilinear interpolation to JAX function.
+
+        Uses jax.scipy.ndimage.map_coordinates for bilinear interpolation on a
+        regular grid. For query points outside the grid, boundary values are
+        returned (clamping via mode='nearest').
+
+        Args:
+            node: Bilerp expression node with x, y, xp, yp, fp
+
+        Returns:
+            Function (x, u, node, params) -> interpolated scalar value
+
+        Note:
+            The grid arrays (xp, yp, fp) are typically constants (tabulated data),
+            while x and y are symbolic expressions (state or derived values).
+            Physical coordinates are converted to fractional indices before
+            interpolation. The implementation is differentiable through JAX's autodiff.
+        """
+        f_x = self.lower(node.x)
+        f_y = self.lower(node.y)
+        f_xp = self.lower(node.xp)
+        f_yp = self.lower(node.yp)
+        f_fp = self.lower(node.fp)
+
+        def bilerp_fn(x, u, node_idx, params):
+            x_val = f_x(x, u, node_idx, params)
+            y_val = f_y(x, u, node_idx, params)
+            xp_val = f_xp(x, u, node_idx, params)
+            yp_val = f_yp(x, u, node_idx, params)
+            fp_val = f_fp(x, u, node_idx, params)
+
+            # Convert physical coordinates to fractional indices
+            # jnp.interp maps physical coords to index space (handles non-uniform grids)
+            idx_x = jnp.interp(x_val, xp_val, jnp.arange(len(xp_val)))
+            idx_y = jnp.interp(y_val, yp_val, jnp.arange(len(yp_val)))
+
+            # Use map_coordinates with order=1 (bilinear) and mode='nearest' (clamp)
+            coords = jnp.array([[idx_x], [idx_y]])
+            return jax.scipy.ndimage.map_coordinates(fp_val, coords, order=1, mode="nearest")[0]
+
+        return bilerp_fn

{openscvx-0.3.2.dev195 → openscvx-0.3.2.dev210/openscvx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev195
+Version: 0.3.2.dev210
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License