openscvx 0.4.1.dev91__tar.gz → 0.4.1.dev92__tar.gz

{openscvx-0.4.1.dev91/openscvx.egg-info → openscvx-0.4.1.dev92}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.4.1.dev91
+Version: 0.4.1.dev92
 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.dev91 → openscvx-0.4.1.dev92}/examples/abstract/brachistochrone.py

@@ -74,6 +74,7 @@ time = ox.Time(
     final=("minimize", total_time),
     min=0.0,
     max=total_time,
+    uniform_time_grid=True,
 )
 
 problem = Problem(
@@ -91,7 +92,6 @@ problem.settings.prp.dt = 0.01
 
 problem.settings.scp.lam_prox = 1e1  # Weight on the Trust Reigon
 problem.settings.scp.lam_cost = 1e0  # Weight on the Minimal Time Objective
-problem.settings.scp.uniform_time_grid = True
 
 
 plotting_dict = {}

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/examples/car/dubins_car.py

@@ -86,6 +86,8 @@ time = ox.Time(
     final=ox.Minimize(total_time),
     min=0.0,
     max=20,
+    time_dilation_min=0.02 * total_time,
+    uniform_time_grid=True,
 )
 
 problem = Problem(
@@ -96,13 +98,11 @@ problem = Problem(
     constraints=constraints,
     N=n,
     licq_max=1e-8,
-    time_dilation_factor_min=0.02,
 )
 
 # Set solver parameters
 problem.settings.scp.lam_cost = 4e1
 problem.settings.scp.lam_vc = 1e3
-problem.settings.scp.uniform_time_grid = True
 
 plotting_dict = {
     "obs_radius": problem.parameters["obs_radius"],

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/examples/car/dubins_car_conditional.py

@@ -99,6 +99,7 @@ time = ox.Time(
     final=ox.Minimize(total_time),
     min=0.0,
     max=20,
+    uniform_time_grid=True,
 )
 
 problem = Problem(
@@ -113,7 +114,6 @@ problem = Problem(
 
 # Set solver parameters
 problem.settings.scp.lam_vc = 1e3
-problem.settings.scp.uniform_time_grid = True
 
 
 plotting_dict = {

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/examples/car/dubins_car_disjoint.py

@@ -102,6 +102,7 @@ time = ox.Time(
     final=("minimize", total_time),
     min=0.0,
     max=20,
+    uniform_time_grid=True,
 )
 
 problem = Problem(
@@ -114,7 +115,6 @@ problem = Problem(
 )
 # Set solver parameters
 problem.settings.scp.lam_vc = 6e2
-problem.settings.scp.uniform_time_grid = True
 plotting_dict = {
     "wp1_radius": problem.parameters["wp1_radius"],
     "wp1_center": problem.parameters["wp1_center"],

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/examples/car/dubins_car_stljax.py

@@ -57,7 +57,9 @@ angular_rate.guess = np.zeros((n, 1))
 
 # Define time (needed for time-dependent constraints)
 # Time is a State subclass, so it can be used directly in expressions
-time = ox.Time(initial=0.0, final=("minimize", total_time), min=0.0, max=10.0)
+time = ox.Time(
+    initial=0.0, final=("minimize", total_time), min=0.0, max=10.0, uniform_time_grid=True
+)
 
 
 # Define list of all states and controls
@@ -106,7 +108,6 @@ problem = Problem(
 )
 # Set solver parameters
 problem.settings.scp.lam_vc = 6e2
-problem.settings.scp.uniform_time_grid = True
 # Extract parameter values from problem.parameters (not Parameter objects)
 plotting_dict = {
     "wp1_center": problem.parameters.get("wp1_center", None),

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/examples/drone/logo.py

@@ -127,6 +127,8 @@ time_state = ox.Time(
     final=total_time,
     min=0.0,
     max=total_time,
+    time_dilation_min=0.001 * total_time,
+    time_dilation_max=3.0 * total_time,
 )
 
 # Control components
@@ -353,8 +355,6 @@ problem = Problem(
     constraints=constraints,
     N=n,
     byof=byof,
-    time_dilation_factor_min=0.001,
-    time_dilation_factor_max=3.0,
     autotuner=ox.RampProximalWeight(),
     float_dtype="float64",
 )

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/examples/realtime/base_problems/obstacle_avoidance_realtime_base.py

@@ -142,6 +142,7 @@ time = ox.Time(
     final=("minimize", total_time),
     min=0.0,
     max=total_time,
+    time_dilation_min=0.2 * total_time,
 )
 
 problem = Problem(
@@ -151,7 +152,6 @@ problem = Problem(
     time=time,
     constraints=constraints,
     N=n,
-    time_dilation_factor_min=0.2,
     autotuner=ox.ConstantProximalWeight(),
 )
 

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/__init__.py

@@ -70,7 +70,7 @@ from openscvx.symbolic.expr import (
     Vstack,
     ctcs,
 )
-from openscvx.symbolic.time import Time
+from openscvx.symbolic.expr.time import Time
 from openscvx.utils.cache import clear_cache, get_cache_dir, get_cache_size
 
 load_results = OptimizationResults.load

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.1.dev91'
-__version_tuple__ = version_tuple = (0, 4, 1, 'dev91')
+__version__ = version = '0.4.1.dev92'
+__version_tuple__ = version_tuple = (0, 4, 1, 'dev92')
 
-__commit_id__ = commit_id = 'g3738e53c4'
+__commit_id__ = commit_id = 'g624f43d2f'

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/config.py

@@ -409,7 +409,6 @@ class ScpConfig:
         ep_tr: float = 1e-4,
         ep_vb: float = 1e-4,
         ep_vc: float = 1e-8,
-        uniform_time_grid: bool = False,
         autotuner: Optional["AutotuningBase"] = None,
     ):
         """
@@ -433,8 +432,6 @@ class ScpConfig:
             lam_cost (float): The weight for original cost. Defaults to 0.0.
             lam_vb (float): The weight for virtual buffer. This is only used if
                 there are nonconvex nodal constraints present. Defaults to 0.0.
-            uniform_time_grid (bool): Whether to use a uniform time grid.
-                Defaults to `False`.
             autotuner: Optional custom autotuner instance. If not provided, defaults
                 to ``AugmentedLagrangian()`` with default parameters. Useful for
                 customizing parameters:
@@ -464,7 +461,7 @@ class ScpConfig:
         self.ep_vc = ep_vc
         self.lam_cost = lam_cost
         self.lam_vb = lam_vb
-        self.uniform_time_grid = uniform_time_grid
+        self._uniform_time_grid = False
         # Store autotuner via property to support lazy default construction
         self.autotuner = autotuner
 

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/loader.py

@@ -68,9 +68,9 @@ from openscvx.config import _resolve_autotuner
 from openscvx.symbolic.expr.control import Control
 from openscvx.symbolic.expr.expr import Expr, Parameter
 from openscvx.symbolic.expr.state import State
+from openscvx.symbolic.expr.time import Time
 from openscvx.symbolic.parser._registry import _PARSE_FUNCTIONS
 from openscvx.symbolic.parser.parser import ExprParser
-from openscvx.symbolic.time import Time
 
 # ---------------------------------------------------------------------------
 # Public API
@@ -180,6 +180,7 @@ def load_dict(data: dict) -> dict:
         final=_parse_time_boundary(time_data["final"]),
         min=float(time_data["min"]),
         max=float(time_data["max"]),
+        uniform_time_grid=bool(time_data.get("uniform_time_grid", False)),
     )
 
     # ---- N -------------------------------------------------------------

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/problem.py

@@ -55,9 +55,9 @@ from openscvx.symbolic.builder import preprocess_symbolic_problem
 from openscvx.symbolic.expr import CTCS, Constraint
 from openscvx.symbolic.expr.control import Control
 from openscvx.symbolic.expr.state import State
+from openscvx.symbolic.expr.time import Time
 from openscvx.symbolic.lower import lower_symbolic_problem
 from openscvx.symbolic.problem import SymbolicProblem
-from openscvx.symbolic.time import Time
 from openscvx.utils import printing, profiling
 from openscvx.utils.caching import (
     get_solver_cache_paths,
@@ -82,8 +82,6 @@ class Problem:
         algebraic_prop: Optional[dict] = None,
         licq_min: float = 0.0,
         licq_max: float = 1e-4,
-        time_dilation_factor_min: float = 0.3,
-        time_dilation_factor_max: float = 3.0,
         autotuner: Optional[AutotuningBase] = AugmentedLagrangian(),
         byof: Optional[ByofSpec] = None,
         float_dtype: str = "float32",
@@ -113,10 +111,6 @@ class Problem:
                 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.
-            time_dilation_factor_min (float): Minimum time dilation factor.
-                Defaults to 0.3.
-            time_dilation_factor_max (float): Maximum time dilation factor.
-                Defaults to 3.0.
             byof (ByofSpec, optional): Expert mode only. Raw JAX functions to
                 bypass symbolic layer. See :class:`openscvx.expert.ByofSpec` for
                 detailed documentation.
@@ -157,8 +151,6 @@ class Problem:
             time=time,
             licq_min=licq_min,
             licq_max=licq_max,
-            time_dilation_factor_min=time_dilation_factor_min,
-            time_dilation_factor_max=time_dilation_factor_max,
             dynamics_prop_extra=dynamics_prop,
             states_prop_extra=states_prop,
             algebraic_prop=algebraic_prop,
@@ -220,8 +212,11 @@ class Problem:
             prp=PropagationConfig(),
         )
 
-        # OCP construction happens in initialize() so users can modify
-        # settings (like uniform_time_grid) between __init__ and initialize()
+        # Copy time grid setting from Time to SCP config so the solver can
+        # read it during constraint assembly.
+        if isinstance(time, Time):
+            self.settings.scp._uniform_time_grid = time.uniform_time_grid
+
         self._discretization_solver: callable = None
 
         # Set up emitter & queue (thread started in initialize() after columns are known)

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/solvers/ptr_solver.py

@@ -470,7 +470,7 @@ class PTRSolver(ConvexSolver):
             if settings.sim.x.final_type[i] == "Fix":
                 constr += [x_nonscaled[-1][i] == x_term[i]]  # Final Boundary Conditions
 
-        if settings.scp.uniform_time_grid:
+        if settings.scp._uniform_time_grid:
             S_u_inv_td = inv_S_u[settings.sim.time_dilation_slice, settings.sim.time_dilation_slice]
             c_u_td = c_u[settings.sim.time_dilation_slice]
             constr += [

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/symbolic/augmentation.py

@@ -71,6 +71,7 @@ from openscvx.symbolic.expr import (
 )
 from openscvx.symbolic.expr.control import Control
 from openscvx.symbolic.expr.state import State
+from openscvx.symbolic.expr.time import Time
 
 
 def _check_nonconvex_equality(constraint: Constraint, context: str) -> None:
@@ -440,8 +441,6 @@ def augment_dynamics_with_ctcs(
     N: int,
     licq_min: float = 0.0,
     licq_max: float = 1e-4,
-    time_dilation_factor_min: float = 0.3,
-    time_dilation_factor_max: float = 3.0,
 ) -> Tuple[Expr, List[State], List[Control]]:
     """Augment dynamics with continuous-time constraint satisfaction states.
 
@@ -467,8 +466,6 @@ def augment_dynamics_with_ctcs(
         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)
-        time_dilation_factor_min: Minimum time dilation factor (default: 0.3)
-        time_dilation_factor_max: Maximum time dilation factor (default: 3.0)
 
     Returns:
         Tuple of:
@@ -561,28 +558,49 @@ def augment_dynamics_with_ctcs(
         raise ValueError("No state named 'time' found in states list")
 
     time_final = time_state.final[0]
-    time_dilation.min = np.array([time_dilation_factor_min * time_final])
-    time_dilation.max = np.array([time_dilation_factor_max * time_final])
-
-    # Compute initial guess for time_dilation from time.guess using finite differences
-    # The relationship is: dt/dtau = time_dilation, where tau is normalized time [0,1]
-    # With N nodes, dtau = 1/(N-1) between consecutive nodes
-    if time_state.guess is None:
-        raise ValueError("time state must have a guess set before augmentation")
-
-    if N > 1:
-        time_guess = time_state.guess.flatten()  # Shape (N,)
-        time_dilation_guess = np.zeros(N)
-        dtau = 1.0 / (N - 1)  # Normalized time step between nodes
-        # Compute finite difference: time_dilation[k] = (time[k+1] - time[k]) / dtau
-        for k in range(N - 1):
-            time_dilation_guess[k] = (time_guess[k + 1] - time_guess[k]) / dtau
-        # For the last node, use the previous value (extrapolate)
-        time_dilation_guess[N - 1] = time_dilation_guess[N - 2]
-        time_dilation.guess = time_dilation_guess.reshape(-1, 1)
+
+    # If time_state is a Time instance, use its time_dilation_* attributes.
+    # Otherwise fall back to default factor-based bounds (0.3 / 3.0).
+    is_time = isinstance(time_state, Time)
+
+    if is_time and time_state.time_dilation_min is not None:
+        time_dilation.min = np.array([time_state.time_dilation_min])
+    else:
+        time_dilation.min = np.array([0.3 * time_final])
+
+    if is_time and time_state.time_dilation_max is not None:
+        time_dilation.max = np.array([time_state.time_dilation_max])
     else:
-        # Single node case: use time_final as guess
-        time_dilation.guess = np.ones([N, 1]) * time_final
+        time_dilation.max = np.array([3.0 * time_final])
+
+    # Use user-provided time_dilation guess if available,
+    # otherwise compute from time.guess via finite differences
+    if is_time and time_state.time_dilation_guess is not None:
+        time_dilation.guess = time_state.time_dilation_guess
+    else:
+        # The relationship is: dt/dtau = time_dilation, where tau is normalized time [0,1]
+        # With N nodes, dtau = 1/(N-1) between consecutive nodes
+        if time_state.guess is None:
+            raise ValueError("time state must have a guess set before augmentation")
+
+        if N > 1:
+            time_guess = time_state.guess.flatten()  # Shape (N,)
+            time_dilation_guess = np.zeros(N)
+            dtau = 1.0 / (N - 1)  # Normalized time step between nodes
+            # Compute finite difference: time_dilation[k] = (time[k+1] - time[k]) / dtau
+            for k in range(N - 1):
+                time_dilation_guess[k] = (time_guess[k + 1] - time_guess[k]) / dtau
+            # For the last node, use the previous value (extrapolate)
+            time_dilation_guess[N - 1] = time_dilation_guess[N - 2]
+            time_dilation.guess = time_dilation_guess.reshape(-1, 1)
+        else:
+            # Single node case: use time_final as guess
+            time_dilation.guess = np.ones([N, 1]) * time_final
+
+    # Store a back-reference so that later mutations to the Time object
+    # (e.g. time.time_dilation_min = ...) propagate to the live control.
+    if is_time:
+        time_state._time_dilation_control = time_dilation
 
     controls_augmented.append(time_dilation)
 

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/symbolic/builder.py

@@ -43,6 +43,7 @@ from openscvx.symbolic.constraint_set import ConstraintSet
 from openscvx.symbolic.expr import Constant, Parameter, traverse
 from openscvx.symbolic.expr.control import Control
 from openscvx.symbolic.expr.state import State
+from openscvx.symbolic.expr.time import Time
 from openscvx.symbolic.preprocessing import (
     collect_and_assign_slices,
     convert_dynamics_dict_to_expr,
@@ -61,7 +62,6 @@ from openscvx.symbolic.preprocessing import (
     validate_variable_names,
 )
 from openscvx.symbolic.problem import SymbolicProblem
-from openscvx.symbolic.time import Time
 
 
 def preprocess_symbolic_problem(
@@ -73,8 +73,6 @@ def preprocess_symbolic_problem(
     time: Time,
     licq_min: float = 0.0,
     licq_max: float = 1e-4,
-    time_dilation_factor_min: float = 0.3,
-    time_dilation_factor_max: float = 3.0,
     dynamics_prop_extra: dict = None,
     states_prop_extra: List[State] = None,
     algebraic_prop: dict = None,
@@ -109,8 +107,6 @@ def preprocess_symbolic_problem(
         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)
-        time_dilation_factor_min: Minimum factor for time dilation control (default: 0.3)
-        time_dilation_factor_max: Maximum factor for time dilation control (default: 3.0)
         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
@@ -308,8 +304,6 @@ def preprocess_symbolic_problem(
         N,
         licq_min=licq_min,
         licq_max=licq_max,
-        time_dilation_factor_min=time_dilation_factor_min,
-        time_dilation_factor_max=time_dilation_factor_max,
     )
 
     # Assign slices to augmented states and controls in canonical order

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/symbolic/expr/__init__.py

@@ -149,6 +149,9 @@ from .state import BoundaryType, Fixed, Free, Maximize, Minimize, State
 # STL operations
 from .stl import Or
 
+# Time
+from .time import Time
+
 # Variable
 from .variable import Variable
 
@@ -190,6 +193,8 @@ __all__ = [
     "Maximize",
     # Control
     "Control",
+    # Time
+    "Time",
     # Mathematical functions
     "Sin",
     "Cos",

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/symbolic/expr/control.py

@@ -59,17 +59,31 @@ class Control(Variable):
             steer.guess = np.linspace([0, 0], [0, 1], 50)  # Gradual acceleration
     """
 
-    def __init__(self, name: str, shape: Tuple[int, ...]):
+    def __init__(
+        self,
+        name: str,
+        shape: Tuple[int, ...],
+        *,
+        min: Optional[np.ndarray] = None,
+        max: Optional[np.ndarray] = None,
+    ):
         """Initialize a Control object.
 
         Args:
             name: Name identifier for the control variable
             shape: Shape of the control vector (typically 1D tuple like (3,))
+            min: Optional minimum bounds array (keyword-only)
+            max: Optional maximum bounds array (keyword-only)
         """
         super().__init__(name, shape)
         self._scaling_min = None
         self._scaling_max = None
 
+        if min is not None:
+            self.min = min
+        if max is not None:
+            self.max = max
+
     def sparsity(self, n_x: int, n_u: int) -> Tuple[np.ndarray, np.ndarray]:
         """Element-level exact sparsity: diagonal block at ``_slice``."""
         n = self._shape[0]

{openscvx-0.4.1.dev91 → openscvx-0.4.1.dev92}/openscvx/symbolic/expr/state.py

@@ -197,12 +197,25 @@ class State(Variable):
             pos.final = [10, ("free", 5), ("maximize", 150)]  # Maximize final altitude
     """
 
-    def __init__(self, name: str, shape: Tuple[int, ...]):
+    def __init__(
+        self,
+        name: str,
+        shape: Tuple[int, ...],
+        *,
+        min: Optional[np.ndarray] = None,
+        max: Optional[np.ndarray] = None,
+        initial: Optional[list] = None,
+        final: Optional[list] = None,
+    ):
         """Initialize a State object.
 
         Args:
             name: Name identifier for the state variable
             shape: Shape of the state vector (typically 1D tuple)
+            min: Optional minimum bounds array (keyword-only)
+            max: Optional maximum bounds array (keyword-only)
+            initial: Optional initial boundary conditions array (keyword-only)
+            final: Optional final boundary conditions array (keyword-only)
         """
         super().__init__(name, shape)
         self._initial = None
@@ -212,6 +225,15 @@ class State(Variable):
         self._scaling_min = None
         self._scaling_max = None
 
+        if min is not None:
+            self.min = min
+        if max is not None:
+            self.max = max
+        if initial is not None:
+            self.initial = initial
+        if final is not None:
+            self.final = final
+
     def sparsity(self, n_x: int, n_u: int) -> Tuple[np.ndarray, np.ndarray]:
         """Element-level exact sparsity: diagonal block at ``_slice``."""
         n = self._shape[0]