openscvx 0.3.2.dev300__tar.gz → 0.3.2.dev315__tar.gz

{openscvx-0.3.2.dev300/openscvx.egg-info → openscvx-0.3.2.dev315}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev300
+Version: 0.3.2.dev315
 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.dev300 → openscvx-0.3.2.dev315}/examples/car/dubins_car_stljax.py

@@ -55,12 +55,9 @@ angular_rate.min = np.array([-5])
 angular_rate.max = np.array([5])
 angular_rate.guess = np.zeros((n, 1))
 
-# Define time state (needed for time-dependent constraints)
-time = ox.State("time", shape=(1,))
-time.max = np.array([10])
-time.min = np.array([0.0])
-time.initial = np.array([0.0])
-time.final = [ox.Minimize(total_time)]
+# 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)
 
 
 # Define list of all states and controls
@@ -97,20 +94,13 @@ wp2_pred = ox.linalg.Norm(position - wp2_center) <= wp2_radius
 constraints.append(ox.stl.Or(wp1_pred, wp2_pred).over((3, 5)))
 
 # Build the problem
-time_config = ox.Time(
-    initial=0.0,
-    final=total_time,
-    min=0.0,
-    max=10,
-)
-
 constraints.append((time.at(5) - time.at(3) == 1.23).convex())
 
 problem = Problem(
     dynamics=dynamics,
     states=states,
     controls=controls,
-    time=time_config,
+    time=time,  # Time is already defined above as ox.Time
     constraints=constraints,
     N=n,
 )

{openscvx-0.3.2.dev300 → openscvx-0.3.2.dev315}/examples/drone/cinema_vp.py

@@ -64,12 +64,9 @@ fuel.min = np.array([0])
 fuel.initial = np.array([0])
 fuel.final = [("minimize", 0)]
 
-# Define time state (needed for time-dependent constraints)
-time = ox.State("time", shape=(1,))
-time.max = np.array([total_time])
-time.min = np.array([0.0])
-time.initial = np.array([0.0])
-time.final = np.array([total_time])
+# 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=total_time, min=0.0, max=total_time)
 
 # Define control components
 thrust_force = ox.Control("thrust_force", shape=(3,))  # Thrust forces [fx, fy, fz]
@@ -230,18 +227,11 @@ attitude.guess = attitude_bar
 angular_velocity.guess = angular_velocity_bar
 fuel.guess = fuel_bar
 
-time_config = ox.Time(
-    initial=0.0,
-    final=total_time,
-    min=0.0,
-    max=total_time,
-)
-
 problem = Problem(
     dynamics=dynamics,
     states=states,
     controls=controls,
-    time=time_config,
+    time=time,  # Time is already defined above as ox.Time
     constraints=constraints,
     N=n,
     licq_max=1e-8,

{openscvx-0.3.2.dev300 → openscvx-0.3.2.dev315}/openscvx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2.dev300'
-__version_tuple__ = version_tuple = (0, 3, 2, 'dev300')
+__version__ = version = '0.3.2.dev315'
+__version_tuple__ = version_tuple = (0, 3, 2, 'dev315')
 
-__commit_id__ = commit_id = 'ga9b91ecfb'
+__commit_id__ = commit_id = 'g0fafbcbb5'

{openscvx-0.3.2.dev300 → openscvx-0.3.2.dev315}/openscvx/symbolic/augmentation.py

@@ -53,7 +53,7 @@ Example:
         # controls_aug includes original controls + time dilation
 """
 
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Tuple
 
 import numpy as np
 
@@ -385,113 +385,6 @@ def get_nodal_constraints_from_ctcs(
     return nodal_ctcs
 
 
-def augment_with_time_state(
-    states: List[State],
-    constraints: ConstraintSet,
-    time_initial: float | tuple,
-    time_final: float | tuple,
-    time_min: float,
-    time_max: float,
-    N: int,
-    time_scaling_min: Optional[float] = None,
-    time_scaling_max: Optional[float] = None,
-) -> Tuple[List[State], ConstraintSet]:
-    """Augment problem with a time state variable.
-
-    Creates a time state variable if one doesn't already exist and adds it to the
-    states list. Also adds CTCS constraints to enforce time bounds continuously
-    throughout the trajectory.
-
-    The time state tracks physical time along the trajectory and is used for
-    time-optimal control problems. Boundary conditions can be fixed values or
-    free variables with initial guesses.
-
-    Args:
-        states: List of State objects (will not be modified, copy is returned)
-        constraints: ConstraintSet with unsorted constraints (will be modified in place)
-        time_initial: Initial time boundary condition:
-            - float: Fixed initial time
-            - tuple: ("free", guess) for free initial time with initial guess
-        time_final: Final time boundary condition (same format as time_initial)
-        time_min: Minimum bound for time variable throughout trajectory
-        time_max: Maximum bound for time variable throughout trajectory
-        N: Number of discretization nodes (for initial guess generation)
-
-    Returns:
-        Tuple of:
-            - Updated states list (original + time state if created)
-            - The same ConstraintSet with time CTCS constraints added to unsorted
-
-    Note:
-        If a state named "time" already exists, it is not modified and no
-        constraints are added.
-
-    Example:
-        Get augmented states::
-
-            x = ox.State("x", shape=(3,))
-            constraints = ConstraintSet()
-            states_aug, constraints = augment_with_time_state(
-                states=[x],
-                constraints=constraints,
-                time_initial=0.0,
-                time_final=("free", 10.0),
-                time_min=0.0,
-                time_max=100.0,
-                N=50
-            )
-
-        states_aug now includes time state with initial=0, final=free
-    """
-    # Create copy of states to avoid mutating input
-    states_aug = list(states)
-
-    # Check if a time state already exists
-    time_state = None
-    for state in states_aug:
-        if state.name == "time":
-            time_state = state
-            break
-
-    if time_state is None:
-        # Create time State only if it doesn't exist
-        time_state = State("time", shape=(1,))
-        time_state.min = np.array([time_min])
-        time_state.max = np.array([time_max])
-
-        # Set time boundary conditions
-        time_state.initial = [time_initial]
-        time_state.final = [time_final]
-
-        # Create initial guess for time (linear interpolation)
-        time_guess_start = (
-            time_state.initial[0]
-            if isinstance(time_state.initial[0], (int, float))
-            else time_state.initial[0][1]
-        )
-        time_guess_end = (
-            time_state.final[0]
-            if isinstance(time_state.final[0], (int, float))
-            else time_state.final[0][1]
-        )
-        time_state.guess = np.linspace(time_guess_start, time_guess_end, N).reshape(-1, 1)
-
-        # Transfer scaling_min/max from Time object if provided
-        if time_scaling_min is not None:
-            time_state.scaling_min = np.array([time_scaling_min])
-        if time_scaling_max is not None:
-            time_state.scaling_max = np.array([time_scaling_max])
-
-        # Add time state to the list
-        states_aug.append(time_state)
-
-        # Add CTCS constraints for time bounds to unsorted
-        constraints.unsorted.append(CTCS(time_state <= time_state.max))
-        constraints.unsorted.append(CTCS(time_state.min <= time_state))
-
-    return states_aug, constraints
-
-
 def augment_dynamics_with_ctcs(
     xdot: Expr,
     states: List[State],
@@ -623,7 +516,26 @@ def augment_dynamics_with_ctcs(
     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])
-    time_dilation.guess = np.ones([N, 1]) * 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)
+    else:
+        # Single node case: use time_final as guess
+        time_dilation.guess = np.ones([N, 1]) * time_final
 
     controls_augmented.append(time_dilation)
 

{openscvx-0.3.2.dev300 → openscvx-0.3.2.dev315}/openscvx/symbolic/builder.py

@@ -35,7 +35,6 @@ import numpy as np
 
 from openscvx.symbolic.augmentation import (
     augment_dynamics_with_ctcs,
-    augment_with_time_state,
     decompose_vector_nodal_constraints,
     separate_constraints,
     sort_ctcs_constraints,
@@ -57,7 +56,6 @@ from openscvx.symbolic.preprocessing import (
     validate_dynamics_dimension,
     validate_guesses,
     validate_shapes,
-    validate_time_parameters,
     validate_variable_names,
 )
 from openscvx.symbolic.problem import SymbolicProblem
@@ -200,31 +198,25 @@ def preprocess_symbolic_problem(
     # Validate that all user-provided variables have guesses
     validate_guesses(states + controls)
 
-    # ==================== PHASE 1: Time Handling & Validation ====================
-
-    # Validate time handling approach and get processed parameters
-    (
-        has_time_state,
-        time_initial,
-        time_final,
-        time_derivative,
-        time_min,
-        time_max,
-    ) = validate_time_parameters(states, time)
-
-    # Augment states with time state if needed (auto-create approach)
-    if not has_time_state:
-        states, constraints = augment_with_time_state(
-            states,
-            constraints,
-            time_initial,
-            time_final,
-            time_min,
-            time_max,
-            N,
-            time_scaling_min=getattr(time, "scaling_min", None),
-            time_scaling_max=getattr(time, "scaling_max", None),
-        )
+    # ==================== PHASE 1: Time Handling ====================
+
+    # Check if time state already in states list
+    time_state = next((s for s in states if s.name == "time"), None)
+
+    if time_state is None:
+        # Add the Time object to states (Time is a State subclass)
+        states = list(states) + [time]
+        time_state = time
+
+    # Fill in default guess if needed (for Time instances)
+    if isinstance(time_state, Time) and time_state.guess is None:
+        time_state.guess = time_state._generate_default_guess(N)
+
+    # Add CTCS constraints for time bounds
+    from openscvx.symbolic.expr import CTCS
+
+    constraints.unsorted.append(CTCS(time_state <= time_state.max))
+    constraints.unsorted.append(CTCS(time_state.min <= time_state))
 
     # Add time derivative to dynamics dict (if not already present)
     # Time derivative is always 1.0 when using Time object