algorithms

Successive convexification algorithms for trajectory optimization.

This module provides implementations of SCvx (Successive Convexification) algorithms for solving non-convex trajectory optimization problems through iterative convex approximation.

Current Implementations

PTR (Penalized Trust Region): The default SCvx algorithm using trust region methods with penalty-based constraint handling. Includes adaptive parameter tuning and virtual control relaxation.

Planned Architecture (ABC-based):

A base class will be introduced to enable pluggable algorithm implementations. This will enable users to implement custom SCvx variants or research algorithms. Future algorithms will implement the SCvxAlgorithm interface:

# algorithms/base.py (planned):
class SCvxAlgorithm(ABC):
    @abstractmethod
    def initialize(self, lowered: LoweredProblem) -> SolverState:
        '''Initialize solver state from a lowered problem.'''
        ...

    @abstractmethod
    def step(self, state: SolverState, solver: ConvexSolver) -> SolverState:
        '''Execute one iteration of the algorithm.'''
        ...

OptimizationResults dataclass

Structured container for optimization results from the Successive Convexification (SCP) solver.

This class provides a type-safe and organized way to store and access optimization results, replacing the previous dictionary-based approach. It includes core optimization data, iteration history for convergence analysis, post-processing results, and flexible storage for plotting and application-specific data.

Attributes:

Name	Type	Description
converged	bool	Whether the optimization successfully converged
t_final	float	Final time of the optimized trajectory
x_guess	ndarray	Optimized state trajectory at discretization nodes, shape (N, n_states)
u_guess	ndarray	Optimized control trajectory at discretization nodes, shape (N, n_controls)
nodes	dict[str, ndarray]	Dictionary mapping state/control names to arrays at optimization nodes. Includes both user-defined and augmented variables.
trajectory	dict[str, ndarray]	Dictionary mapping state/control names to arrays along the propagated trajectory. Added by post_process().
x_history	list[ndarray]	State trajectories from each SCP iteration
u_history	list[ndarray]	Control trajectories from each SCP iteration
discretization_history	list[ndarray]	Time discretization from each iteration
J_tr_history	list[ndarray]	Trust region cost history
J_vb_history	list[ndarray]	Virtual buffer cost history
J_vc_history	list[ndarray]	Virtual control cost history
t_full	Optional[ndarray]	Full time grid for interpolated trajectory
x_full	Optional[ndarray]	Interpolated state trajectory on full time grid
u_full	Optional[ndarray]	Interpolated control trajectory on full time grid
cost	Optional[float]	Total cost of the optimized trajectory
ctcs_violation	Optional[ndarray]	Continuous-time constraint violations
plotting_data	dict[str, Any]	Flexible storage for plotting and application data

Source code in openscvx/algorithms/optimization_results.py

@dataclass
class OptimizationResults:
    """
    Structured container for optimization results from the Successive Convexification (SCP) solver.

    This class provides a type-safe and organized way to store and access optimization results,
    replacing the previous dictionary-based approach. It includes core optimization data,
    iteration history for convergence analysis, post-processing results, and flexible
    storage for plotting and application-specific data.

    Attributes:
        converged (bool): Whether the optimization successfully converged
        t_final (float): Final time of the optimized trajectory
        x_guess (np.ndarray): Optimized state trajectory at discretization nodes,
            shape (N, n_states)
        u_guess (np.ndarray): Optimized control trajectory at discretization nodes,
            shape (N, n_controls)

        # Dictionary-based Access
        nodes (dict[str, np.ndarray]): Dictionary mapping state/control names to arrays
            at optimization nodes. Includes both user-defined and augmented variables.
        trajectory (dict[str, np.ndarray]): Dictionary mapping state/control names to arrays
            along the propagated trajectory. Added by post_process().

        # SCP Iteration History (for convergence analysis)
        x_history (list[np.ndarray]): State trajectories from each SCP iteration
        u_history (list[np.ndarray]): Control trajectories from each SCP iteration
        discretization_history (list[np.ndarray]): Time discretization from each iteration
        J_tr_history (list[np.ndarray]): Trust region cost history
        J_vb_history (list[np.ndarray]): Virtual buffer cost history
        J_vc_history (list[np.ndarray]): Virtual control cost history

        # Post-processing Results (added by propagate_trajectory_results)
        t_full (Optional[np.ndarray]): Full time grid for interpolated trajectory
        x_full (Optional[np.ndarray]): Interpolated state trajectory on full time grid
        u_full (Optional[np.ndarray]): Interpolated control trajectory on full time grid
        cost (Optional[float]): Total cost of the optimized trajectory
        ctcs_violation (Optional[np.ndarray]): Continuous-time constraint violations

        # User-defined Data
        plotting_data (dict[str, Any]): Flexible storage for plotting and application data
    """

    # Core optimization results
    converged: bool
    t_final: float

    # Dictionary-based access to states and controls
    nodes: dict[str, np.ndarray] = field(default_factory=dict)
    trajectory: dict[str, np.ndarray] = field(default_factory=dict)

    # Internal metadata for dictionary construction
    _states: list = field(default_factory=list, repr=False)
    _controls: list = field(default_factory=list, repr=False)

    # History of SCP iterations (single source of truth)
    X: list[np.ndarray] = field(default_factory=list)
    U: list[np.ndarray] = field(default_factory=list)
    discretization_history: list[np.ndarray] = field(default_factory=list)
    J_tr_history: list[np.ndarray] = field(default_factory=list)
    J_vb_history: list[np.ndarray] = field(default_factory=list)
    J_vc_history: list[np.ndarray] = field(default_factory=list)

    @property
    def x(self) -> np.ndarray:
        """Optimal state trajectory at discretization nodes.

        Returns the final converged solution from the SCP iteration history.

        Returns:
            State trajectory array, shape (N, n_states)
        """
        return self.X[-1]

    @property
    def u(self) -> np.ndarray:
        """Optimal control trajectory at discretization nodes.

        Returns the final converged solution from the SCP iteration history.

        Returns:
            Control trajectory array, shape (N, n_controls)
        """
        return self.U[-1]

    # Post-processing results (added by propagate_trajectory_results)
    t_full: Optional[np.ndarray] = None
    x_full: Optional[np.ndarray] = None
    u_full: Optional[np.ndarray] = None
    cost: Optional[float] = None
    ctcs_violation: Optional[np.ndarray] = None

    # Additional plotting/application data (added by user)
    plotting_data: dict[str, Any] = field(default_factory=dict)

    def __post_init__(self):
        """Initialize the results object."""
        pass

    def update_plotting_data(self, **kwargs):
        """
        Update the plotting data with additional information.

        Args:
            **kwargs: Key-value pairs to add to plotting_data
        """
        self.plotting_data.update(kwargs)

    def get(self, key: str, default: Any = None) -> Any:
        """
        Get a value from the results, similar to dict.get().

        Args:
            key: The key to look up
            default: Default value if key is not found

        Returns:
            The value associated with the key, or default if not found
        """
        # Check if it's a direct attribute
        if hasattr(self, key):
            return getattr(self, key)

        # Check if it's in plotting_data
        if key in self.plotting_data:
            return self.plotting_data[key]

        return default

    def __getitem__(self, key: str) -> Any:
        """
        Allow dictionary-style access to results.

        Args:
            key: The key to look up

        Returns:
            The value associated with the key

        Raises:
            KeyError: If key is not found
        """
        # Check if it's a direct attribute
        if hasattr(self, key):
            return getattr(self, key)

        # Check if it's in plotting_data
        if key in self.plotting_data:
            return self.plotting_data[key]

        raise KeyError(f"Key '{key}' not found in results")

    def __setitem__(self, key: str, value: Any):
        """
        Allow dictionary-style assignment to results.

        Args:
            key: The key to set
            value: The value to assign
        """
        # Check if it's a direct attribute
        if hasattr(self, key):
            setattr(self, key, value)
        else:
            # Store in plotting_data
            self.plotting_data[key] = value

    def __contains__(self, key: str) -> bool:
        """
        Check if a key exists in the results.

        Args:
            key: The key to check

        Returns:
            True if key exists, False otherwise
        """
        return hasattr(self, key) or key in self.plotting_data

    def update(self, other: dict[str, Any]):
        """
        Update the results with additional data from a dictionary.

        Args:
            other: Dictionary containing additional data
        """
        for key, value in other.items():
            self[key] = value

    def to_dict(self) -> dict[str, Any]:
        """
        Convert the results to a dictionary for backward compatibility.

        Returns:
            Dictionary representation of the results
        """
        result_dict = {}

        # Add all direct attributes
        for attr_name in self.__dataclass_fields__:
            if attr_name != "plotting_data":
                result_dict[attr_name] = getattr(self, attr_name)

        # Add plotting data
        result_dict.update(self.plotting_data)

        return result_dict

u: np.ndarray property

Optimal control trajectory at discretization nodes.

Returns the final converged solution from the SCP iteration history.

Returns:

Type	Description
ndarray	Control trajectory array, shape (N, n_controls)

x: np.ndarray property

Optimal state trajectory at discretization nodes.

Returns the final converged solution from the SCP iteration history.

Returns:

Type	Description
ndarray	State trajectory array, shape (N, n_states)

get(key: str, default: Any = None) -> Any

Get a value from the results, similar to dict.get().

Parameters:

Name	Type	Description	Default
key	str	The key to look up	required
default	Any	Default value if key is not found	None

Returns:

Type	Description
Any	The value associated with the key, or default if not found

Source code in openscvx/algorithms/optimization_results.py

def get(self, key: str, default: Any = None) -> Any:
    """
    Get a value from the results, similar to dict.get().

    Args:
        key: The key to look up
        default: Default value if key is not found

    Returns:
        The value associated with the key, or default if not found
    """
    # Check if it's a direct attribute
    if hasattr(self, key):
        return getattr(self, key)

    # Check if it's in plotting_data
    if key in self.plotting_data:
        return self.plotting_data[key]

    return default

to_dict() -> dict[str, Any]

Convert the results to a dictionary for backward compatibility.

Returns:

Type	Description
dict[str, Any]	Dictionary representation of the results

Source code in openscvx/algorithms/optimization_results.py

def to_dict(self) -> dict[str, Any]:
    """
    Convert the results to a dictionary for backward compatibility.

    Returns:
        Dictionary representation of the results
    """
    result_dict = {}

    # Add all direct attributes
    for attr_name in self.__dataclass_fields__:
        if attr_name != "plotting_data":
            result_dict[attr_name] = getattr(self, attr_name)

    # Add plotting data
    result_dict.update(self.plotting_data)

    return result_dict

update(other: dict[str, Any])

Update the results with additional data from a dictionary.

Parameters:

Name	Type	Description	Default
other	dict[str, Any]	Dictionary containing additional data	required

Source code in openscvx/algorithms/optimization_results.py

def update(self, other: dict[str, Any]):
    """
    Update the results with additional data from a dictionary.

    Args:
        other: Dictionary containing additional data
    """
    for key, value in other.items():
        self[key] = value

update_plotting_data(**kwargs)

Update the plotting data with additional information.

Parameters:

Name	Type	Description	Default
**kwargs		Key-value pairs to add to plotting_data	{}

Source code in openscvx/algorithms/optimization_results.py

def update_plotting_data(self, **kwargs):
    """
    Update the plotting data with additional information.

    Args:
        **kwargs: Key-value pairs to add to plotting_data
    """
    self.plotting_data.update(kwargs)

SolverState dataclass

Mutable state for SCP iterations.

This dataclass holds all state that changes during the solve process. It stores only the evolving trajectory arrays, not the full State/Control objects which contain immutable configuration metadata.

Trajectory arrays are stored in history lists, with the current guess accessed via properties that return the latest entry.

A fresh instance is created for each solve, enabling easy reset functionality.

Attributes:

Name	Type	Description
k	int	Current iteration number (starts at 1)
J_tr	float	Current trust region cost
J_vb	float	Current virtual buffer cost
J_vc	float	Current virtual control cost
w_tr	float	Current trust region weight (may adapt during solve)
lam_cost	float	Current cost weight (may relax during solve)
lam_vc	Union[float, ndarray]	Current virtual control penalty weight
lam_vb	float	Current virtual buffer penalty weight
n_x	int	Number of states (for unpacking V vectors)
n_u	int	Number of controls (for unpacking V vectors)
N	int	Number of trajectory nodes (for unpacking V vectors)
X	List[ndarray]	List of state trajectory iterates
U	List[ndarray]	List of control trajectory iterates
V_history	List[ndarray]	List of discretization history

Source code in openscvx/algorithms/solver_state.py

@dataclass
class SolverState:
    """Mutable state for SCP iterations.

    This dataclass holds all state that changes during the solve process.
    It stores only the evolving trajectory arrays, not the full State/Control
    objects which contain immutable configuration metadata.

    Trajectory arrays are stored in history lists, with the current guess
    accessed via properties that return the latest entry.

    A fresh instance is created for each solve, enabling easy reset functionality.

    Attributes:
        k: Current iteration number (starts at 1)
        J_tr: Current trust region cost
        J_vb: Current virtual buffer cost
        J_vc: Current virtual control cost
        w_tr: Current trust region weight (may adapt during solve)
        lam_cost: Current cost weight (may relax during solve)
        lam_vc: Current virtual control penalty weight
        lam_vb: Current virtual buffer penalty weight
        n_x: Number of states (for unpacking V vectors)
        n_u: Number of controls (for unpacking V vectors)
        N: Number of trajectory nodes (for unpacking V vectors)
        X: List of state trajectory iterates
        U: List of control trajectory iterates
        V_history: List of discretization history
    """

    k: int
    J_tr: float
    J_vb: float
    J_vc: float
    w_tr: float
    lam_cost: float
    lam_vc: Union[float, np.ndarray]
    lam_vb: float
    n_x: int
    n_u: int
    N: int
    X: List[np.ndarray] = field(default_factory=list)
    U: List[np.ndarray] = field(default_factory=list)
    V_history: List[np.ndarray] = field(default_factory=list)

    @property
    def x(self) -> np.ndarray:
        """Get current state trajectory array.

        Returns:
            Current state trajectory guess (latest entry in history), shape (N, n_states)
        """
        return self.X[-1]

    @property
    def u(self) -> np.ndarray:
        """Get current control trajectory array.

        Returns:
            Current control trajectory guess (latest entry in history), shape (N, n_controls)
        """
        return self.U[-1]

    @property
    def x_prop(self) -> np.ndarray:
        """Extract propagated state trajectory from latest V.

        Returns:
            Propagated state trajectory x_prop with shape (N-1, n_x), or None if no V_history

        Example:
            After running an iteration, access the propagated states::

                problem.step()
                x_prop = problem.state.x_prop  # Shape (N-1, n_x)
        """
        if not self.V_history:
            return None

        # V_history contains Vmulti from discretization
        # Shape: (flattened_size, n_timesteps) where flattened_size = (N-1) * i4
        V = self.V_history[-1]

        # Take final timestep and reshape to (N-1, i4)
        i4 = self.n_x + self.n_x * self.n_x + 2 * self.n_x * self.n_u
        V_final = V[:, -1].reshape(-1, i4)

        # Extract propagated state (first n_x elements of each row)
        return V_final[:, : self.n_x]

    @property
    def A_d(self) -> np.ndarray:
        """Extract discretized state transition matrix from latest V.

        Returns:
            Discretized state Jacobian A_d with shape (N-1, n_x, n_x), or None if no V_history

        Example:
            After running an iteration, access linearization matrices::

                problem.step()
                A_d = problem.state.A_d  # Shape (N-1, n_x, n_x)
        """
        if not self.V_history:
            return None

        # Extract indices for unpacking V vector
        i1 = self.n_x
        i2 = i1 + self.n_x * self.n_x

        # V_history contains Vmulti from discretization
        # Shape: (flattened_size, n_timesteps) where flattened_size = (N-1) * i4
        V = self.V_history[-1]

        # Take final timestep and reshape to (N-1, i4)
        i4 = self.n_x + self.n_x * self.n_x + 2 * self.n_x * self.n_u
        V_final = V[:, -1].reshape(-1, i4)

        # Extract and reshape A_d matrix
        return V_final[:, i1:i2].reshape(self.N - 1, self.n_x, self.n_x)

    @property
    def B_d(self) -> np.ndarray:
        """Extract discretized control influence matrix (current node) from latest V.

        Returns:
            Discretized control Jacobian B_d with shape (N-1, n_x, n_u), or None if no V_history

        Example:
            After running an iteration, access linearization matrices::

                problem.step()
                B_d = problem.state.B_d  # Shape (N-1, n_x, n_u)
        """
        if not self.V_history:
            return None

        # Extract indices for unpacking V vector
        i1 = self.n_x
        i2 = i1 + self.n_x * self.n_x
        i3 = i2 + self.n_x * self.n_u

        # V_history contains Vmulti from discretization
        V = self.V_history[-1]

        # Take final timestep and reshape to (N-1, i4)
        i4 = self.n_x + self.n_x * self.n_x + 2 * self.n_x * self.n_u
        V_final = V[:, -1].reshape(-1, i4)

        # Extract and reshape B_d matrix
        return V_final[:, i2:i3].reshape(self.N - 1, self.n_x, self.n_u)

    @property
    def C_d(self) -> np.ndarray:
        """Extract discretized control influence matrix (next node) from latest V.

        Returns:
            Discretized control Jacobian C_d with shape (N-1, n_x, n_u), or None if no V_history

        Example:
            After running an iteration, access linearization matrices::

                problem.step()
                C_d = problem.state.C_d  # Shape (N-1, n_x, n_u)
        """
        if not self.V_history:
            return None

        # Extract indices for unpacking V vector
        i2 = self.n_x + self.n_x * self.n_x
        i3 = i2 + self.n_x * self.n_u
        i4 = i3 + self.n_x * self.n_u

        # V_history contains Vmulti from discretization
        V = self.V_history[-1]

        # Take final timestep and reshape to (N-1, i4)
        V_final = V[:, -1].reshape(-1, i4)

        # Extract and reshape C_d matrix
        return V_final[:, i3:i4].reshape(self.N - 1, self.n_x, self.n_u)

    @classmethod
    def from_settings(cls, settings: "Config") -> "SolverState":
        """Create initial solver state from configuration.

        Copies only the trajectory arrays from settings, leaving all metadata
        (bounds, boundary conditions, etc.) in the original settings object.

        Args:
            settings: Configuration object containing initial guesses and SCP parameters

        Returns:
            Fresh SolverState initialized from settings with copied arrays
        """
        return cls(
            k=1,
            J_tr=1e2,
            J_vb=1e2,
            J_vc=1e2,
            w_tr=settings.scp.w_tr,
            lam_cost=settings.scp.lam_cost,
            lam_vc=settings.scp.lam_vc,
            lam_vb=settings.scp.lam_vb,
            n_x=settings.sim.n_states,
            n_u=settings.sim.n_controls,
            N=settings.scp.n,
            X=[settings.sim.x.guess.copy()],
            U=[settings.sim.u.guess.copy()],
            V_history=[],
        )

A_d: np.ndarray property

Extract discretized state transition matrix from latest V.

Returns:

Type	Description
ndarray	Discretized state Jacobian A_d with shape (N-1, n_x, n_x), or None if no V_history

Example

After running an iteration, access linearization matrices::

problem.step()
A_d = problem.state.A_d  # Shape (N-1, n_x, n_x)

B_d: np.ndarray property

Extract discretized control influence matrix (current node) from latest V.

Returns:

Type	Description
ndarray	Discretized control Jacobian B_d with shape (N-1, n_x, n_u), or None if no V_history

Example

After running an iteration, access linearization matrices::

problem.step()
B_d = problem.state.B_d  # Shape (N-1, n_x, n_u)

C_d: np.ndarray property

Extract discretized control influence matrix (next node) from latest V.

Returns:

Type	Description
ndarray	Discretized control Jacobian C_d with shape (N-1, n_x, n_u), or None if no V_history

Example

After running an iteration, access linearization matrices::

problem.step()
C_d = problem.state.C_d  # Shape (N-1, n_x, n_u)

u: np.ndarray property

Get current control trajectory array.

Returns:

Type	Description
ndarray	Current control trajectory guess (latest entry in history), shape (N, n_controls)

x: np.ndarray property

Get current state trajectory array.

Returns:

Type	Description
ndarray	Current state trajectory guess (latest entry in history), shape (N, n_states)

x_prop: np.ndarray property

Extract propagated state trajectory from latest V.

Returns:

Type	Description
ndarray	Propagated state trajectory x_prop with shape (N-1, n_x), or None if no V_history

Example

After running an iteration, access the propagated states::

problem.step()
x_prop = problem.state.x_prop  # Shape (N-1, n_x)

from_settings(settings: Config) -> SolverState classmethod

Create initial solver state from configuration.

Copies only the trajectory arrays from settings, leaving all metadata (bounds, boundary conditions, etc.) in the original settings object.

Parameters:

Name	Type	Description	Default
settings	Config	Configuration object containing initial guesses and SCP parameters	required

Returns:

Type	Description
SolverState	Fresh SolverState initialized from settings with copied arrays

Source code in openscvx/algorithms/solver_state.py

@classmethod
def from_settings(cls, settings: "Config") -> "SolverState":
    """Create initial solver state from configuration.

    Copies only the trajectory arrays from settings, leaving all metadata
    (bounds, boundary conditions, etc.) in the original settings object.

    Args:
        settings: Configuration object containing initial guesses and SCP parameters

    Returns:
        Fresh SolverState initialized from settings with copied arrays
    """
    return cls(
        k=1,
        J_tr=1e2,
        J_vb=1e2,
        J_vc=1e2,
        w_tr=settings.scp.w_tr,
        lam_cost=settings.scp.lam_cost,
        lam_vc=settings.scp.lam_vc,
        lam_vb=settings.scp.lam_vb,
        n_x=settings.sim.n_states,
        n_u=settings.sim.n_controls,
        N=settings.scp.n,
        X=[settings.sim.x.guess.copy()],
        U=[settings.sim.u.guess.copy()],
        V_history=[],
    )

PTR_step(params, settings: Config, state: SolverState, prob: cp.Problem, discretization_solver: callable, cpg_solve, emitter_function, jax_constraints: LoweredJaxConstraints) -> bool

Performs a single SCP iteration.

Parameters:

Name	Type	Description	Default
params		Problem parameters	required
settings	Config	Configuration object	required
state	SolverState	Solver state (mutated in place)	required
prob	Problem	CVXPy problem	required
discretization_solver	callable	Discretization solver function	required
cpg_solve		CVXPyGen solver (if enabled)	required
emitter_function		Function to emit iteration data	required
jax_constraints	LoweredJaxConstraints	JAX-lowered non-convex constraints	required

Returns:

Name	Type	Description
bool	bool	True if converged, False otherwise

Source code in openscvx/algorithms/ptr.py

def PTR_step(
    params,
    settings: Config,
    state: SolverState,
    prob: cp.Problem,
    discretization_solver: callable,
    cpg_solve,
    emitter_function,
    jax_constraints: "LoweredJaxConstraints",
) -> bool:
    """Performs a single SCP iteration.

    Args:
        params: Problem parameters
        settings: Configuration object
        state: Solver state (mutated in place)
        prob: CVXPy problem
        discretization_solver: Discretization solver function
        cpg_solve: CVXPyGen solver (if enabled)
        emitter_function: Function to emit iteration data
        jax_constraints: JAX-lowered non-convex constraints

    Returns:
        bool: True if converged, False otherwise
    """
    # Run the subproblem
    (
        x_sol,
        u_sol,
        cost,
        J_total,
        J_vb_vec,
        J_vc_vec,
        J_tr_vec,
        prob_stat,
        V_multi_shoot,
        subprop_time,
        dis_time,
    ) = PTR_subproblem(
        params.items(),
        cpg_solve,
        state,
        discretization_solver,
        prob,
        settings,
        jax_constraints,
    )

    # Update state in place by appending to history
    # The x_guess/u_guess properties will automatically return the latest entry
    state.V_history.append(V_multi_shoot)
    state.X.append(x_sol)
    state.U.append(u_sol)

    state.J_tr = np.sum(np.array(J_tr_vec))
    state.J_vb = np.sum(np.array(J_vb_vec))
    state.J_vc = np.sum(np.array(J_vc_vec))

    # Update weights in state
    update_scp_weights(state, settings, state.k)

    # Emit data
    emitter_function(
        {
            "iter": state.k,
            "dis_time": dis_time * 1000.0,
            "subprop_time": subprop_time * 1000.0,
            "J_total": J_total,
            "J_tr": state.J_tr,
            "J_vb": state.J_vb,
            "J_vc": state.J_vc,
            "cost": cost[-1],
            "prob_stat": prob_stat,
        }
    )

    # Increment iteration counter
    state.k += 1

    # Return convergence status
    return (
        (state.J_tr < settings.scp.ep_tr)
        and (state.J_vb < settings.scp.ep_vb)
        and (state.J_vc < settings.scp.ep_vc)
    )

format_result(problem, state: SolverState, converged: bool) -> OptimizationResults

Formats the solver state as an OptimizationResults object.

Directly passes trajectory arrays from solver state to results - no object construction needed. Results store pure arrays, settings store metadata.

Parameters:

Name	Type	Description	Default
problem		The Problem instance (for symbolic metadata and settings).	required
state	SolverState	The SolverState to extract results from.	required
converged	bool	Whether the optimization converged.	required

Returns:

Type	Description
OptimizationResults	OptimizationResults containing the solution data.

Source code in openscvx/algorithms/ptr.py

def format_result(problem, state: "SolverState", converged: bool) -> OptimizationResults:
    """Formats the solver state as an OptimizationResults object.

    Directly passes trajectory arrays from solver state to results - no object
    construction needed. Results store pure arrays, settings store metadata.

    Args:
        problem: The Problem instance (for symbolic metadata and settings).
        state: The SolverState to extract results from.
        converged: Whether the optimization converged.

    Returns:
        OptimizationResults containing the solution data.
    """
    # Build nodes dictionary with all states and controls
    nodes_dict = {}

    # Add all states (user-defined and augmented)
    for sym_state in problem.symbolic.states:
        nodes_dict[sym_state.name] = state.x[:, sym_state._slice]

    # Add all controls (user-defined and augmented)
    for control in problem.symbolic.controls:
        nodes_dict[control.name] = state.u[:, control._slice]

    return OptimizationResults(
        converged=converged,
        t_final=state.x[:, problem.settings.sim.time_slice][-1],
        nodes=nodes_dict,
        trajectory={},  # Populated by post_process
        _states=problem.symbolic.states_prop,  # Use propagation states for trajectory dict
        _controls=problem.symbolic.controls,
        X=state.X,  # Single source of truth - x and u are properties
        U=state.U,
        discretization_history=state.V_history,
        J_tr_history=state.J_tr,
        J_vb_history=state.J_vb,
        J_vc_history=state.J_vc,
    )