openscvx 0.4.1.dev146__tar.gz → 0.4.1.dev147__tar.gz

{openscvx-0.4.1.dev146/openscvx.egg-info → openscvx-0.4.1.dev147}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.4.1.dev146
+Version: 0.4.1.dev147
 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.4.1.dev146 → openscvx-0.4.1.dev147}/openscvx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.1.dev146'
-__version_tuple__ = version_tuple = (0, 4, 1, 'dev146')
+__version__ = version = '0.4.1.dev147'
+__version_tuple__ = version_tuple = (0, 4, 1, 'dev147')
 
-__commit_id__ = commit_id = 'g66b4191a1'
+__commit_id__ = commit_id = 'g50fc80214'

{openscvx-0.4.1.dev146 → openscvx-0.4.1.dev147}/openscvx/problem.py

@@ -18,7 +18,7 @@ import os
 import queue
 import threading
 import time
-from typing import List, Optional, Union
+from typing import Dict, List, Optional, Union
 
 import jax
 
@@ -83,8 +83,8 @@ class Problem:
         dynamics_prop: Optional[dict] = None,
         states_prop: Optional[List[State]] = None,
         algebraic_prop: Optional[dict] = None,
-        licq_min: float = 0.0,
-        licq_max: float = 1e-4,
+        licq_min: Union[float, Dict[int, float]] = 0.0,
+        licq_max: Union[float, Dict[int, float]] = 1e-4,
         algorithm: Optional[Union[Algorithm, dict]] = None,
         discretizer: Optional[Union[Discretizer, dict]] = None,
         solver: Optional[Union[ConvexSolver, dict]] = None,
@@ -114,8 +114,12 @@ class Problem:
                 Only specify additional states beyond optimization states. Used with dynamics_prop.
             algebraic_prop (dict, optional): Dictionary mapping names to symbolic expressions
                 for outputs evaluated (not integrated) during propagation.
-            licq_min (float): Minimum LICQ constraint value. Defaults to 0.0.
-            licq_max (float): Maximum LICQ constraint value. Defaults to 1e-4.
+            licq_min: Minimum LICQ constraint value. Defaults to 0.0.
+                Either a scalar (applied to all CTCS groups) or a dict
+                mapping CTCS group ``idx`` to per-group bounds.
+            licq_max: Maximum LICQ constraint value. Defaults to 1e-4.
+                Either a scalar (applied to all CTCS groups) or a dict
+                mapping CTCS group ``idx`` to per-group bounds.
             algorithm: SCP algorithm configuration. Accepts:
 
                 - ``None`` — uses ``PenalizedTrustRegion()`` with defaults.

{openscvx-0.4.1.dev146 → openscvx-0.4.1.dev147}/openscvx/symbolic/augmentation.py

@@ -54,7 +54,7 @@ Example:
         # controls_aug includes original controls + time dilation
 """
 
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 import numpy as np
 
@@ -484,8 +484,8 @@ def augment_dynamics_with_ctcs(
     N: int,
     xdelta: Optional[Expr] = None,
     *,
-    licq_min: float = 0.0,
-    licq_max: float = 1e-4,
+    licq_min: Union[float, Dict[int, float]] = 0.0,
+    licq_max: Union[float, Dict[int, float]] = 1e-4,
 ) -> Tuple[Expr, Optional[Expr], List[State], List[Control]]:
     """Augment dynamics with continuous-time constraint satisfaction states.
 
@@ -509,8 +509,12 @@ def augment_dynamics_with_ctcs(
         controls: List of control variables
         constraints_ctcs: List of CTCS constraints (should be sorted and grouped)
         N: Number of discretization nodes
-        licq_min: Minimum bound for augmented states (default: 0.0)
-        licq_max: Maximum bound for augmented states (default: 1e-4)
+        licq_min: Minimum bound for augmented states (default: 0.0).
+            Either a scalar (applied to all groups) or a dict mapping
+            CTCS group ``idx`` to per-group bounds.
+        licq_max: Maximum bound for augmented states (default: 1e-4).
+            Either a scalar (applied to all groups) or a dict mapping
+            CTCS group ``idx`` to per-group bounds.
 
     Returns:
         Tuple of:
@@ -567,6 +571,24 @@ def augment_dynamics_with_ctcs(
                 penalty_groups[ctcs.idx] = []
             penalty_groups[ctcs.idx].append(ctcs)
 
+        # Validate dict-valued licq_min / licq_max keys against actual groups.
+        valid_ids = set(penalty_groups.keys())
+        for name, val in [("licq_min", licq_min), ("licq_max", licq_max)]:
+            if isinstance(val, dict):
+                unknown = set(val.keys()) - valid_ids
+                if unknown:
+                    raise ValueError(
+                        f"{name} dict contains unknown CTCS group idx: {unknown}. "
+                        f"Valid idx values: {sorted(valid_ids)}"
+                    )
+                missing = valid_ids - set(val.keys())
+                if missing:
+                    raise ValueError(
+                        f"{name} dict is missing entries for CTCS group idx: "
+                        f"{sorted(missing)}. When using a dict, all groups must "
+                        f"have an entry. Valid idx values: {sorted(valid_ids)}"
+                    )
+
         # Create augmented state expressions for each group and corresponding
         # augmented state variables. For discrete dynamics, preserve these states
         # by identity mapping across impulsive updates.
@@ -580,13 +602,17 @@ def augment_dynamics_with_ctcs(
                 augmented_state_expr = Add(*penalty_terms)
             augmented_state_exprs.append(augmented_state_expr)
 
+            # Resolve per-group LICQ bounds
+            idx_min = licq_min[idx] if isinstance(licq_min, dict) else licq_min
+            idx_max = licq_max[idx] if isinstance(licq_max, dict) else licq_max
+
             aug_var = State(f"_ctcs_aug_{idx}", shape=(1,))
-            aug_var.initial = np.array([licq_min])  # Set initial to respect bounds
+            aug_var.initial = np.array([idx_min])  # Set initial to respect bounds
             aug_var.final = [("free", 0)]
-            aug_var.min = np.array([licq_min])
-            aug_var.max = np.array([licq_max])
-            # Set guess to licq_min as well
-            aug_var.guess = np.full([N, 1], licq_min)  # N x num augmented states
+            aug_var.min = np.array([idx_min])
+            aug_var.max = np.array([idx_max])
+            # Set guess to idx_min as well
+            aug_var.guess = np.full([N, 1], idx_min)  # N x num augmented states
             states_augmented.append(aug_var)
             augmented_state_exprs_discrete.append(aug_var)
 

{openscvx-0.4.1.dev146 → openscvx-0.4.1.dev147}/openscvx/symbolic/builder.py

@@ -29,7 +29,7 @@ Pipeline stages:
 See `preprocess_symbolic_problem()` for the main entry point.
 """
 
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 import numpy as np
 
@@ -71,8 +71,8 @@ def preprocess_symbolic_problem(
     controls: List[Control],
     N: int,
     time: Time,
-    licq_min: float = 0.0,
-    licq_max: float = 1e-4,
+    licq_min: Union[float, Dict[int, float]] = 0.0,
+    licq_max: Union[float, Dict[int, float]] = 1e-4,
     dynamics_prop_extra: dict = None,
     dynamics_discrete: dict = None,
     states_prop_extra: List[State] = None,
@@ -106,8 +106,12 @@ def preprocess_symbolic_problem(
         controls: List of user-defined Control objects (should NOT include time dilation)
         N: Number of discretization nodes in the trajectory
         time: Time configuration object specifying time bounds and constraints
-        licq_min: Minimum bound for CTCS augmented states (default: 0.0)
-        licq_max: Maximum bound for CTCS augmented states (default: 1e-4)
+        licq_min: Minimum bound for CTCS augmented states (default: 0.0).
+            Either a scalar (applied to all groups) or a dict mapping
+            CTCS group ``idx`` to per-group bounds.
+        licq_max: Maximum bound for CTCS augmented states (default: 1e-4).
+            Either a scalar (applied to all groups) or a dict mapping
+            CTCS group ``idx`` to per-group bounds.
         dynamics_prop_extra: Optional dictionary of additional dynamics for propagation-only
             states (default: None)
         states_prop_extra: Optional list of additional State objects for propagation only

{openscvx-0.4.1.dev146 → openscvx-0.4.1.dev147/openscvx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.4.1.dev146
+Version: 0.4.1.dev147
 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.4.1.dev146 → openscvx-0.4.1.dev147}/tests/symbolic/test_augmentation.py

@@ -821,6 +821,105 @@ def test_augmented_state_bounds():
     assert np.allclose(aug_state.guess, 0.001), "Augmented state guess should be licq_min"
 
 
+def test_augmented_state_bounds_per_group_dict():
+    """Per-group LICQ bounds via dict keyed by idx."""
+    x = State("x", (1,))
+    time = State("time", (1,))
+    time.final = np.array([10.0])
+    xdot = x
+    states = [time, x]
+    controls = []
+    N = 5
+    time.guess = np.linspace(0, time.final[0], N).reshape(-1, 1)
+
+    # Two constraints with different node intervals → two groups (idx 0 and 1)
+    c0 = ctcs(x <= 1.0, penalty="squared_relu", nodes=(0, 3))
+    c1 = ctcs(x <= 2.0, penalty="squared_relu", nodes=(3, 5))
+
+    _, _, states_aug, _ = augment_dynamics_with_ctcs(
+        xdot,
+        states,
+        controls,
+        [c0, c1],
+        N,
+        licq_min={0: 0.0, 1: 0.001},
+        licq_max={0: 1e-8, 1: 0.01},
+    )
+
+    aug0 = states_aug[2]  # _ctcs_aug_0
+    aug1 = states_aug[3]  # _ctcs_aug_1
+
+    assert aug0.min[0] == 0.0
+    assert aug0.max[0] == 1e-8
+    assert aug0.initial[0] == 0.0
+    assert np.allclose(aug0.guess, 0.0)
+
+    assert aug1.min[0] == 0.001
+    assert aug1.max[0] == 0.01
+    assert aug1.initial[0] == 0.001
+    assert np.allclose(aug1.guess, 0.001)
+
+
+def test_augmented_state_bounds_scalar_with_multiple_groups():
+    """Scalar LICQ bounds broadcast to all groups."""
+    x = State("x", (1,))
+    time = State("time", (1,))
+    time.final = np.array([10.0])
+    xdot = x
+    states = [time, x]
+    controls = []
+    N = 5
+    time.guess = np.linspace(0, time.final[0], N).reshape(-1, 1)
+
+    c0 = ctcs(x <= 1.0, penalty="squared_relu", nodes=(0, 3))
+    c1 = ctcs(x <= 2.0, penalty="squared_relu", nodes=(3, 5))
+
+    _, _, states_aug, _ = augment_dynamics_with_ctcs(
+        xdot,
+        states,
+        controls,
+        [c0, c1],
+        N,
+        licq_min=0.002,
+        licq_max=0.05,
+    )
+
+    for i in [2, 3]:
+        aug = states_aug[i]
+        assert aug.min[0] == 0.002
+        assert aug.max[0] == 0.05
+        assert aug.initial[0] == 0.002
+
+
+def test_licq_dict_unknown_idx_raises():
+    """Dict licq with unknown idx raises helpful error."""
+    x = State("x", (1,))
+    time = State("time", (1,))
+    time.final = np.array([10.0])
+    states = [time, x]
+    N = 5
+    time.guess = np.linspace(0, time.final[0], N).reshape(-1, 1)
+    c0 = ctcs(x <= 1.0, penalty="squared_relu", nodes=(0, 5))
+
+    with pytest.raises(ValueError, match="unknown CTCS group idx.*5"):
+        augment_dynamics_with_ctcs(x, states, [], [c0], N, licq_max={0: 1e-8, 5: 1e-4})
+
+
+def test_licq_dict_missing_idx_raises():
+    """Dict licq missing a group idx raises helpful error."""
+    x = State("x", (1,))
+    time = State("time", (1,))
+    time.final = np.array([10.0])
+    states = [time, x]
+    N = 5
+    time.guess = np.linspace(0, time.final[0], N).reshape(-1, 1)
+    c0 = ctcs(x <= 1.0, penalty="squared_relu", nodes=(0, 3))
+    c1 = ctcs(x <= 2.0, penalty="squared_relu", nodes=(3, 5))
+
+    with pytest.raises(ValueError, match="missing entries for CTCS group idx.*1"):
+        augment_dynamics_with_ctcs(x, states, [], [c0, c1], N, licq_max={0: 1e-8})
+
+
 def test_time_dilation_control_bounds():
     """Test that time dilation control has correct min/max bounds based on time."""
     x = State("x", (2,))