openscvx 0.3.2.dev219__tar.gz → 0.3.2.dev228__tar.gz

{openscvx-0.3.2.dev219/openscvx.egg-info → openscvx-0.3.2.dev228}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev219
+Version: 0.3.2.dev228
 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.dev219 → openscvx-0.3.2.dev228}/examples/abstract/3DoF_pdg.py

@@ -38,14 +38,12 @@ position.max = np.array([3000, 3000, 3000])
 position.min = np.array([-3000, -3000, 0])
 position.initial = np.array([2000, 0, 1500])
 position.final = np.array([0, 0, 0])
-position.guess = np.linspace(position.initial, position.final, n)
 
 velocity = ox.State("velocity", shape=(3,))  # 3D velocity [vx, vy, vz]
 velocity.max = np.array([v_max, v_max, v_max])
 velocity.min = np.array([-v_max, -v_max, -v_max])
 velocity.initial = np.array([80, 30, -75])
 velocity.final = np.array([0, 0, 0])
-velocity.guess = np.linspace(velocity.initial, velocity.final, n)
 
 mass = ox.State("mass", shape=(1,))  # Vehicle mass
 mass.max = np.array([1905])
@@ -54,7 +52,6 @@ mass.initial = np.array([1905])
 mass.final = [("maximize", 1690)]
 mass.scaling_min = np.array([1690])
 # mass.scaling_max = np.array([1700])
-mass.guess = np.linspace(mass.initial, 1690, n).reshape(-1, 1)
 
 # Define control
 thrust = ox.Control("thrust", shape=(3,))  # Thrust force vector [Tx, Ty, Tz]

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/abstract/brachistochrone.py

@@ -38,14 +38,12 @@ position.max = np.array([10.0, 10.0])
 position.min = np.array([0.0, 0.0])
 position.initial = np.array([0.0, 10.0])
 position.final = [10.0, 5.0]
-position.guess = np.linspace(position.initial, position.final, n)
 
 velocity = ox.State("velocity", shape=(1,))  # Scalar speed
 velocity.max = np.array([10.0])
 velocity.min = np.array([0.0])
 velocity.initial = np.array([0.0])
 velocity.final = [("free", 10.0)]
-velocity.guess = np.linspace(0.0, 10.0, n).reshape(-1, 1)
 
 # Define control
 theta = ox.Control("theta", shape=(1,))  # Angle from vertical

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/car/dubins_car.py

@@ -35,14 +35,12 @@ position.min = np.array([-5.0, -5.0])
 position.max = np.array([5.0, 5.0])
 position.initial = np.array([0, -2])
 position.final = np.array([0, 2])
-position.guess = np.linspace(position.initial, position.final, n)
 
 theta = ox.State("theta", shape=(1,))  # Heading angle
 theta.min = np.array([-2 * jnp.pi])
 theta.max = np.array([2 * jnp.pi])
 theta.initial = np.array([0])
 theta.final = [ox.Free(0)]
-theta.guess = np.zeros((n, 1))
 
 # Define control components
 speed = ox.Control("speed", shape=(1,))  # Forward speed

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/car/dubins_car_disjoint.py

@@ -41,7 +41,6 @@ theta.min = np.array([-2 * jnp.pi])
 theta.max = np.array([2 * jnp.pi])
 theta.initial = np.array([0])
 theta.final = [("free", 0)]
-theta.guess = np.zeros((n, 1))
 
 # Define control components
 speed = ox.Control("speed", shape=(1,))  # Forward speed

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/car/dubins_car_stljax.py

@@ -37,14 +37,12 @@ position.min = np.array([-5.0, -5.0])
 position.max = np.array([5.0, 5.0])
 position.initial = np.array([0, -2])
 position.final = np.array([0, 2])
-position.guess = np.linspace(position.initial, position.final, n)
 
 theta = ox.State("theta", shape=(1,))  # Heading angle
 theta.min = np.array([-2 * jnp.pi])
 theta.max = np.array([2 * jnp.pi])
 theta.initial = np.array([0])
 theta.final = [("free", 0)]
-theta.guess = np.zeros((n, 1))
 
 # Define control components
 speed = ox.Control("speed", shape=(1,))  # Forward speed
@@ -63,7 +61,6 @@ time.max = np.array([10])
 time.min = np.array([0.0])
 time.initial = np.array([0.0])
 time.final = [ox.Minimize(total_time)]
-time.guess = np.linspace(0.0, total_time, n).reshape(-1, 1)
 
 
 # Define list of all states and controls

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/drone/cinema_vp.py

@@ -70,7 +70,6 @@ time.max = np.array([total_time])
 time.min = np.array([0.0])
 time.initial = np.array([0.0])
 time.final = np.array([total_time])
-time.guess = np.linspace(0.0, total_time, n).reshape(-1, 1)
 
 # Define control components
 thrust_force = ox.Control("thrust_force", shape=(3,))  # Thrust forces [fx, fy, fz]

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/drone/dr_double_integrator.py

@@ -38,14 +38,12 @@ position.max = np.array([200.0, 100, 50])
 position.min = np.array([-200.0, -100, 15])
 position.initial = np.array([10.0, 0, 20])
 position.final = [10.0, 0, 20]
-position.guess = np.linspace(position.initial, position.final, n)
 
 velocity = ox.State("velocity", shape=(3,))  # 3D velocity [vx, vy, vz]
 velocity.max = np.array([100, 100, 100])
 velocity.min = np.array([-100, -100, -100])
 velocity.initial = np.array([0, 0, 0])
 velocity.final = [("free", 0), ("free", 0), ("free", 0)]
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
 
 # Define control
 force = ox.Control("force", shape=(3,))  # Control forces [fx, fy, fz]

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/drone/drone_racing.py

@@ -37,28 +37,24 @@ position.max = np.array([200.0, 100, 200])
 position.min = np.array([-200.0, -100, 15])
 position.initial = np.array([10.0, 0, 20])
 position.final = [10.0, 0, 20]
-position.guess = np.linspace(position.initial, position.final, n)
 
 velocity = ox.State("velocity", shape=(3,))  # 3D velocity [vx, vy, vz]
 velocity.max = np.array([100, 100, 100])
 velocity.min = np.array([-100, -100, -100])
 velocity.initial = np.array([0, 0, 0])
 velocity.final = [("free", 0), ("free", 0), ("free", 0)]
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
 
 attitude = ox.State("attitude", shape=(4,))  # Quaternion [qw, qx, qy, qz]
 attitude.max = np.array([1, 1, 1, 1])
 attitude.min = np.array([-1, -1, -1, -1])
 attitude.initial = [("free", 1.0), ("free", 0), ("free", 0), ("free", 0)]
 attitude.final = [("free", 1), ("free", 0), ("free", 0), ("free", 0)]
-attitude.guess = np.tile([1.0, 0.0, 0.0, 0.0], (n, 1))
 
 angular_velocity = ox.State("angular_velocity", shape=(3,))  # Angular velocity [wx, wy, wz]
 angular_velocity.max = np.array([10, 10, 10])
 angular_velocity.min = np.array([-10, -10, -10])
 angular_velocity.initial = [("free", 0), ("free", 0), ("free", 0)]
 angular_velocity.final = [("free", 0), ("free", 0), ("free", 0)]
-angular_velocity.guess = np.zeros((n, 3))
 
 # Define control components
 thrust_force = ox.Control("thrust_force", shape=(3,))  # Thrust forces [fx, fy, fz]

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/drone/obstacle_avoidance.py

@@ -137,12 +137,6 @@ for center, A in zip(obstacle_centers, A_obs):
     obstacle_constraint = ox.ctcs(1.0 <= diff.T @ A_const @ diff)
     constraints.append(obstacle_constraint)
 
-# Set initial guesses
-position.guess = np.linspace(position.initial, position.final, n)
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
-attitude.guess = np.tile([1.0, 0.0, 0.0, 0.0], (n, 1))
-angular_velocity.guess = np.zeros((n, 3))
-
 
 time = ox.Time(
     initial=0.0,

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/drone/obstacle_avoidance_nodal.py

@@ -136,12 +136,6 @@ for center, A in zip(obstacle_centers, A_obs):
     obstacle_constraint = 1.0 <= diff.T @ A_const @ diff
     constraints.append(obstacle_constraint)
 
-# Set initial guesses
-position.guess = np.linspace(position.initial, position.final, n)
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
-attitude.guess = np.tile([1.0, 0.0, 0.0, 0.0], (n, 1))
-angular_velocity.guess = np.zeros((n, 3))
-
 time = ox.Time(
     initial=0.0,
     final=("minimize", total_time),

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/drone/obstacle_avoidance_realtime_base.py

@@ -137,13 +137,6 @@ for center, A in zip(obstacle_centers, A_obs):
     obstacle_constraint = ox.ctcs(1.0 <= diff.T @ A_const @ diff)
     constraints.append(obstacle_constraint)
 
-# Set initial guesses
-position.guess = np.linspace(position.initial, position.final, n)
-velocity.guess = np.linspace(velocity.initial, [0, 0, 0], n)
-attitude.guess = np.tile([1.0, 0.0, 0.0, 0.0], (n, 1))
-angular_velocity.guess = np.zeros((n, 3))
-
-
 time = ox.Time(
     initial=0.0,
     final=("minimize", total_time),

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/examples/spacecraft/proxops_cw.py

@@ -54,7 +54,6 @@ position.max = np.array([100.0, 100.0, 100.0])
 position.min = np.array([-100.0, -100.0, -100.0])
 position.initial = np.array([0.0, -100.0, 0.0])  # Start 100m behind target (V-bar position)
 position.final = np.array([0.0, 0.0, 0.0])  # Dock at origin
-position.guess = np.linspace(position.initial, position.final, n_nodes)
 
 # Velocity in CW frame [vx, vy, vz] in m/s
 velocity = ox.State("velocity", shape=(3,))

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/openscvx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2.dev219'
-__version_tuple__ = version_tuple = (0, 3, 2, 'dev219')
+__version__ = version = '0.3.2.dev228'
+__version_tuple__ = version_tuple = (0, 3, 2, 'dev228')
 
-__commit_id__ = commit_id = 'g507eddb5a'
+__commit_id__ = commit_id = 'g44572a46d'

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/openscvx/symbolic/builder.py

@@ -47,11 +47,15 @@ from openscvx.symbolic.expr.state import State
 from openscvx.symbolic.preprocessing import (
     collect_and_assign_slices,
     convert_dynamics_dict_to_expr,
+    fill_default_guesses,
     validate_and_normalize_constraint_nodes,
+    validate_boundary_conditions,
+    validate_bounds,
     validate_constraints_at_root,
     validate_dynamics_dict,
     validate_dynamics_dict_dimensions,
     validate_dynamics_dimension,
+    validate_guesses,
     validate_shapes,
     validate_time_parameters,
     validate_variable_names,
@@ -185,6 +189,17 @@ def preprocess_symbolic_problem(
             print([s.name for s in problem.states_prop])
     """
 
+    # Validate user-provided variables have required attributes
+    validate_boundary_conditions(states)
+    validate_bounds(states + controls)
+
+    # Fill in default guesses for user-provided states
+    # (augmented states get their guesses set by augmentation code)
+    fill_default_guesses(states, N)
+
+    # 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

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/openscvx/symbolic/preprocessing.py

@@ -54,6 +54,7 @@ from openscvx.symbolic.expr import (
     Expr,
     NodalConstraint,
     State,
+    Variable,
     traverse,
 )
 
@@ -755,3 +756,84 @@ def convert_dynamics_dict_to_expr(
     dynamics_concat = Concat(*dynamics_exprs)
 
     return dynamics_converted, dynamics_concat
+
+
+def fill_default_guesses(states: List[State], N: int) -> None:
+    """Fill in default linspace guesses for states with guess=None.
+
+    For states with both initial and final conditions set, generates a linear
+    interpolation from initial to final values.
+
+    This function modifies states in-place.
+
+    Args:
+        states: List of State objects to fill guesses for
+        N: Number of discretization nodes
+    """
+    for state in states:
+        if state.guess is None and state.initial is not None and state.final is not None:
+            # state.initial and state.final are already numpy arrays of values
+            # (the setter handles parsing tuples like ("free", value))
+            state.guess = np.linspace(state.initial, state.final, N)
+
+
+def validate_boundary_conditions(states: List[State]) -> None:
+    """Validate that all states have initial and final boundary conditions set.
+
+    Args:
+        states: List of State objects to validate
+
+    Raises:
+        ValueError: If any state is missing initial or final conditions
+    """
+    for state in states:
+        if state.initial is None:
+            raise ValueError(
+                f"State '{state.name}' is missing initial condition. "
+                f"Please set {state.name}.initial"
+            )
+        if state.final is None:
+            raise ValueError(
+                f"State '{state.name}' is missing final condition. Please set {state.name}.final"
+            )
+
+
+def validate_bounds(variables: List[Variable]) -> None:
+    """Validate that all variables have min and max bounds set.
+
+    Args:
+        variables: List of Variable objects (State or Control) to validate
+
+    Raises:
+        ValueError: If any variable is missing min or max bounds
+    """
+    for var in variables:
+        if var.min is None:
+            raise ValueError(
+                f"Variable '{var.name}' is missing min bound. Please set {var.name}.min"
+            )
+        if var.max is None:
+            raise ValueError(
+                f"Variable '{var.name}' is missing max bound. Please set {var.name}.max"
+            )
+
+
+def validate_guesses(variables: List[Variable]) -> None:
+    """Validate that all variables have initial guesses set.
+
+    Args:
+        variables: List of Variable objects (State or Control) to validate
+
+    Raises:
+        ValueError: If any variable is missing a guess
+    """
+    for var in variables:
+        if var.guess is None:
+            if isinstance(var, Control):
+                raise ValueError(
+                    f"Control '{var.name}' is missing initial guess. "
+                    f"Please set {var.name}.guess (controls require explicit guesses)"
+                )
+            raise ValueError(
+                f"State '{var.name}' is missing initial guess. Please set {var.name}.guess"
+            )

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228/openscvx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.3.2.dev219
+Version: 0.3.2.dev228
 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.dev219 → openscvx-0.3.2.dev228}/tests/symbolic/test_preprocessing.py

@@ -6,11 +6,15 @@ from openscvx.symbolic.expr import Add, Concat, Constant, Control, CrossNodeCons
 from openscvx.symbolic.preprocessing import (
     collect_and_assign_slices,
     convert_dynamics_dict_to_expr,
+    fill_default_guesses,
+    validate_boundary_conditions,
+    validate_bounds,
     validate_constraints_at_root,
     validate_cross_node_constraint,
     validate_dynamics_dict,
     validate_dynamics_dict_dimensions,
     validate_dynamics_dimension,
+    validate_guesses,
     validate_variable_names,
 )
 
@@ -801,3 +805,174 @@ def test_cross_node_constraint_both_sides():
     constraint2 = CrossNodeConstraint(velocity <= position.at(5))
     with pytest.raises(ValueError, match="without .at\\(\\).*vel"):
         validate_cross_node_constraint(constraint2, N)
+
+
+# =============================================================================
+# fill_default_guesses Tests
+# =============================================================================
+
+
+def test_fill_default_guesses_state_linspace():
+    """Test that state guesses are filled with linspace from initial to final."""
+    N = 11  # Use 11 so middle index (5) is exactly at midpoint
+    x = State("x", shape=(3,))
+    x.initial = np.array([0.0, 1.0, 2.0])
+    x.final = np.array([10.0, 11.0, 12.0])
+
+    fill_default_guesses([x], N)
+
+    assert x.guess is not None
+    assert x.guess.shape == (N, 3)
+    # Check first and last rows match initial and final
+    np.testing.assert_array_almost_equal(x.guess[0], [0.0, 1.0, 2.0])
+    np.testing.assert_array_almost_equal(x.guess[-1], [10.0, 11.0, 12.0])
+    # Check it's actually a linspace (middle index should be exactly at midpoint)
+    np.testing.assert_array_almost_equal(x.guess[N // 2], [5.0, 6.0, 7.0])
+
+
+def test_fill_default_guesses_preserves_existing():
+    """Test that existing guesses are not overwritten."""
+    N = 10
+    x = State("x", shape=(2,))
+    x.initial = np.array([0.0, 0.0])
+    x.final = np.array([10.0, 10.0])
+    custom_guess = np.ones((N, 2)) * 99.0
+    x.guess = custom_guess
+
+    fill_default_guesses([x], N)
+
+    # Guess should be unchanged
+    np.testing.assert_array_equal(x.guess, custom_guess)
+
+
+def test_fill_default_guesses_with_free_boundary_conditions():
+    """Test that states with free boundary conditions use the guess values."""
+    N = 10
+    x = State("x", shape=(3,))
+    # Mixed: first fixed, second free, third fixed
+    x.initial = [0.0, ("free", 5.0), 2.0]
+    x.final = [10.0, ("free", 15.0), 12.0]
+
+    fill_default_guesses([x], N)
+
+    assert x.guess is not None
+    assert x.guess.shape == (N, 3)
+    # The setter extracts values from tuples, so initial=[0, 5, 2], final=[10, 15, 12]
+    np.testing.assert_array_almost_equal(x.guess[0], [0.0, 5.0, 2.0])
+    np.testing.assert_array_almost_equal(x.guess[-1], [10.0, 15.0, 12.0])
+
+
+def test_fill_default_guesses_multiple_states():
+    """Test filling guesses for multiple states at once."""
+    N = 5
+    x1 = State("x1", shape=(2,))
+    x1.initial = np.array([0.0, 0.0])
+    x1.final = np.array([4.0, 8.0])
+
+    x2 = State("x2", shape=(1,))
+    x2.initial = np.array([10.0])
+    x2.final = np.array([20.0])
+
+    fill_default_guesses([x1, x2], N)
+
+    # Check x1
+    assert x1.guess.shape == (N, 2)
+    np.testing.assert_array_almost_equal(x1.guess[0], [0.0, 0.0])
+    np.testing.assert_array_almost_equal(x1.guess[-1], [4.0, 8.0])
+
+    # Check x2
+    assert x2.guess.shape == (N, 1)
+    np.testing.assert_array_almost_equal(x2.guess[0], [10.0])
+    np.testing.assert_array_almost_equal(x2.guess[-1], [20.0])
+
+
+# =============================================================================
+# validate_boundary_conditions Tests
+# =============================================================================
+
+
+def test_validate_boundary_conditions_passes():
+    """Test that validation passes when all states have initial and final."""
+    x = State("position", shape=(3,))
+    x.initial = np.zeros(3)
+    x.final = np.ones(3)
+
+    validate_boundary_conditions([x])
+    validate_boundary_conditions([])
+
+
+def test_validate_boundary_conditions_raises_missing():
+    """Test that validation fails fast on first missing attribute."""
+    x = State("position", shape=(2,))
+    # No initial or final set
+
+    with pytest.raises(ValueError, match="'position' is missing initial"):
+        validate_boundary_conditions([x])
+
+    # With initial but no final
+    x.initial = np.zeros(2)
+    with pytest.raises(ValueError, match="'position' is missing final"):
+        validate_boundary_conditions([x])
+
+
+# =============================================================================
+# validate_bounds Tests
+# =============================================================================
+
+
+def test_validate_bounds_passes():
+    """Test that validation passes when all variables have min and max."""
+    x = State("position", shape=(3,))
+    x.min = np.array([-10, -10, -10])
+    x.max = np.array([10, 10, 10])
+
+    u = Control("thrust", shape=(2,))
+    u.min = np.zeros(2)
+    u.max = np.array([100, 100])
+
+    validate_bounds([x, u])
+    validate_bounds([])
+
+
+def test_validate_bounds_raises_missing():
+    """Test that validation fails fast on first missing attribute."""
+    u = Control("thrust", shape=(2,))
+    # No min or max set
+
+    with pytest.raises(ValueError, match="'thrust' is missing min"):
+        validate_bounds([u])
+
+    # With min but no max
+    u.min = np.zeros(2)
+    with pytest.raises(ValueError, match="'thrust' is missing max"):
+        validate_bounds([u])
+
+
+# =============================================================================
+# validate_guesses Tests
+# =============================================================================
+
+
+def test_validate_guesses_passes():
+    """Test that validation passes when all variables have guesses."""
+    N = 10
+    x = State("position", shape=(3,))
+    x.guess = np.zeros((N, 3))
+
+    u = Control("thrust", shape=(2,))
+    u.guess = np.ones((N, 2))
+
+    validate_guesses([x, u])
+    validate_guesses([])
+
+
+def test_validate_guesses_raises_missing():
+    """Test that validation fails fast on first missing guess."""
+    u = Control("thrust", shape=(2,))
+    # No guess set
+
+    with pytest.raises(
+        ValueError,
+        match="Control 'thrust' is missing initial guess.*controls require explicit guesses",
+    ):
+        validate_guesses([u])

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/tests/test_brachistochrone.py

@@ -158,7 +158,6 @@ def test_monolithic():
     x.min = np.array([0.0, 0.0, 0.0])  # Lower bounds
     x.initial = np.array([x0, y0, 0.0])  # [x0, y0, v0]
     x.final = [x1, y1, ("free", 10.0)]  # [x1, y1, v_free]
-    x.guess = np.linspace(x.initial, x.final, n)
 
     # Define control
     u = ox.Control("u", shape=(1,))  # Angle from vertical
@@ -261,14 +260,12 @@ def test_constraint_types(constraint_type):
     position.min = np.array([0.0, 0.0])
     position.initial = np.array([x0, y0])
     position.final = [x1, y1]
-    position.guess = np.linspace(position.initial, position.final, n)
 
     velocity = ox.State("velocity", shape=(1,))  # Scalar speed
     velocity.max = np.array([10.0])
     velocity.min = np.array([0.0])
     velocity.initial = np.array([0.0])
     velocity.final = [("free", 10.0)]
-    velocity.guess = np.linspace(0.0, 10.0, n).reshape(-1, 1)
 
     # Define control
     theta = ox.Control("theta", shape=(1,))  # Angle from vertical
@@ -407,14 +404,12 @@ def test_cross_nodal(test_case):
     position.min = np.array([0.0, 0.0])
     position.initial = np.array([x0, y0])
     position.final = [x1, y1]
-    position.guess = np.linspace(position.initial, position.final, n)
 
     velocity = ox.State("velocity", shape=(1,))  # Scalar speed
     velocity.max = np.array([10.0])
     velocity.min = np.array([0.0])
     velocity.initial = np.array([0.0])
     velocity.final = [("free", 10.0)]
-    velocity.guess = np.linspace(0.0, 10.0, n).reshape(-1, 1)
 
     # Define control
     theta = ox.Control("theta", shape=(1,))  # Angle from vertical
@@ -556,14 +551,12 @@ def test_parameters():
     position.min = np.array([0.0, 0.0])
     position.initial = np.array([x0, y0])
     position.final = [x1, y1]
-    position.guess = np.linspace(position.initial, position.final, n)
 
     velocity = ox.State("velocity", shape=(1,))  # Scalar speed
     velocity.max = np.array([10.0])
     velocity.min = np.array([0.0])
     velocity.initial = np.array([0.0])
     velocity.final = [("free", 10.0)]
-    velocity.guess = np.linspace(0.0, 10.0, n).reshape(-1, 1)
 
     # Define control
     theta = ox.Control("theta", shape=(1,))  # Angle from vertical
@@ -735,14 +728,12 @@ def test_propagation():
     position.min = np.array([0.0, 0.0])
     position.initial = np.array([x0, y0])
     position.final = [x1, y1]
-    position.guess = np.linspace(position.initial, position.final, n)
 
     velocity = ox.State("velocity", shape=(1,))  # Scalar speed
     velocity.max = np.array([10.0])
     velocity.min = np.array([0.0])
     velocity.initial = np.array([0.0])
     velocity.final = [("free", 10.0)]
-    velocity.guess = np.linspace(0.0, 10.0, n).reshape(-1, 1)
 
     # Define control
     theta = ox.Control("theta", shape=(1,))  # Angle from vertical
@@ -755,6 +746,8 @@ def test_propagation():
     controls = [theta]
 
     # Define propagation-only state for tracking total distance traveled
+    # Note: propagation states need explicit guesses since fill_default_guesses
+    # only runs on main optimization states
     distance = ox.State("distance", shape=(1,))
     distance.initial = np.array([0.0])
     distance.min = np.array([0.0])
@@ -1003,14 +996,12 @@ def test_byof(byof_mode):
     position.min = np.array([0.0, 0.0])
     position.initial = np.array([x0, y0])
     position.final = [x1, y1]
-    position.guess = np.linspace(position.initial, position.final, n)
 
     velocity = ox.State("velocity", shape=(1,))
     velocity.max = np.array([10.0])
     velocity.min = np.array([0.0])
     velocity.initial = np.array([0.0])
     velocity.final = [("free", 10.0)]
-    velocity.guess = np.linspace(0.0, 10.0, n).reshape(-1, 1)
 
     # Define control
     theta = ox.Control("theta", shape=(1,))

{openscvx-0.3.2.dev219 → openscvx-0.3.2.dev228}/tests/test_expert.py

@@ -651,10 +651,12 @@ def test_problem_validates_byof_during_construction():
     velocity.min = np.array([0.0])
     velocity.max = np.array([10.0])
     velocity.initial = np.array([0.0])
+    velocity.final = [("free", 5.0)]
 
     theta = ox.Control("theta", shape=(1,))
     theta.min = np.array([0.0])
     theta.max = np.array([np.pi / 2])
+    theta.guess = np.zeros((2, 1))
 
     dynamics = {"position": ox.Concat(velocity[0], velocity[0])}
     time = ox.Time(initial=0.0, final=1.0, min=0.0, max=2.0)