openscvx 0.1.3__py3-none-any.whl → 0.2.1__py3-none-any.whl

openscvx/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.3'
-__version_tuple__ = version_tuple = (0, 1, 3)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)

openscvx/augmentation/dynamics_augmentation.py

@@ -1,4 +1,5 @@
 from typing import Callable, List, Tuple
+import inspect
 
 import jax
 import jax.numpy as jnp
@@ -26,18 +27,32 @@ def build_augmented_dynamics(
 
 
 def get_augmented_dynamics(
-    dynamics: Callable[[jnp.ndarray, jnp.ndarray], jnp.ndarray],
+    dynamics: Callable[..., jnp.ndarray],
     violations: List[CTCSViolation],
     idx_x_true: slice,
     idx_u_true: slice,
-) -> Callable[[jnp.ndarray, jnp.ndarray, int], jnp.ndarray]:
-    def dynamics_augmented(x: jnp.array, u: jnp.array, node: int) -> jnp.array:
-        x_dot = dynamics(x[idx_x_true], u[idx_u_true])
+) -> Callable[..., jnp.ndarray]:
+    
+    def dynamics_augmented(x: jnp.ndarray, u: jnp.ndarray, node: int, *params) -> jnp.ndarray:
+        x_true = x[idx_x_true]
+        u_true = u[idx_u_true]
+
+        # Determine the arguments of dynamics function
+        func_signature = inspect.signature(dynamics)
+        expected_args = set(func_signature.parameters.keys())
+        # Filter params to only those expected by the dynamics function
+        filtered_params = {
+            f"{name}_": value for name, value in params if f"{name}_" in expected_args
+        }
+
+        if "node" in expected_args:
+            filtered_params["node"] = node
+            
+        x_dot = dynamics(x_true, u_true, **filtered_params)
 
-        # Iterate through the g_func dictionary and stack the output each function
-        # to x_dot
         for v in violations:
-            x_dot = jnp.hstack([x_dot, v.g(x[idx_x_true], u[idx_u_true], node)])
+            g_val = v.g(x_true, u_true, node, *params)
+            x_dot = jnp.hstack([x_dot, g_val])
 
         return x_dot
 

openscvx/config.py

@@ -1,8 +1,9 @@
 import numpy as np
 from dataclasses import dataclass, field
-from typing import Dict, List
+from typing import Dict, List, Optional, Callable
 
-from openscvx.constraints.boundary import BoundaryConstraint
+from openscvx.backend.state import State
+from openscvx.backend.control import Control
 
 
 def get_affine_scaling_matrices(n, minimum, maximum):
@@ -13,222 +14,334 @@ def get_affine_scaling_matrices(n, minimum, maximum):
 
 @dataclass
 class DiscretizationConfig:
-    dis_type: str = "FOH"
-    custom_integrator: bool = True
-    solver: str = "Tsit5"
-    args: Dict = field(default_factory=dict)
-    atol: float = 1e-3
-    rtol: float = 1e-6
-
-    """
-    Configuration class for discretization settings.
-
-    This class defines the parameters required for discretizing system dynamics.
-
-    Main arguments:
-    These are the arguments most commonly used day-to-day.
-
-    Args:
-        dis_type (str): The type of discretization to use (e.g., "FOH" for First-Order Hold). Defaults to "FOH".
-        custom_integrator (bool): This enables our custom fixed-step RK45 algorthim. This tends to be faster then Diffrax but unless your going for speed, its reccomended to stick with Diffrax for robustness and other solver options. Defaults to False.
-        solver (str): Not used if custom_integrator is enabled. Any choice of solver in Diffrax is valid, please refer here, [How to Choose a Solver](https://docs.kidger.site/diffrax/usage/how-to-choose-a-solver/). Defaults to "Tsit5".
-
-    Other arguments:
-    These arguments are less frequently used, and for most purposes you shouldn't need to understand these.
-
-    Args:
-        args (Dict): Additional arguments to pass to the solver which can be found [here](https://docs.kidger.site/diffrax/api/diffeqsolve/). Defaults to an empty dictionary.
-        atol (float): Absolute tolerance for the solver. Defaults to 1e-3.
-        rtol (float): Relative tolerance for the solver. Defaults to 1e-6.
-    """
 
+    def __init__(
+        self,
+        dis_type: str = "FOH",
+        custom_integrator: bool = False,
+        solver: str = "Tsit5",
+        args: Dict = None,
+        atol: float = 1e-3,
+        rtol: float = 1e-6,
+    ):
+        """
+        Configuration class for discretization settings.
+
+        This class defines the parameters required for discretizing system dynamics.
+
+        Main arguments:
+        These are the arguments most commonly used day-to-day.
+
+        Args:
+            dis_type (str): The type of discretization to use (e.g., "FOH" for First-Order Hold). Defaults to "FOH".
+            custom_integrator (bool): This enables our custom fixed-step RK45 algorithm. This tends to be faster than Diffrax but unless you're going for speed, it's recommended to stick with Diffrax for robustness and other solver options. Defaults to False.
+            solver (str): Not used if custom_integrator is enabled. Any choice of solver in Diffrax is valid, please refer here, [How to Choose a Solver](https://docs.kidger.site/diffrax/usage/how-to-choose-a-solver/). Defaults to "Tsit5".
+
+        Other arguments:
+        These arguments are less frequently used, and for most purposes you shouldn't need to understand these.
+
+        Args:
+            args (Dict): Additional arguments to pass to the solver which can be found [here](https://docs.kidger.site/diffrax/api/diffeqsolve/). Defaults to an empty dictionary.
+            atol (float): Absolute tolerance for the solver. Defaults to 1e-3.
+            rtol (float): Relative tolerance for the solver. Defaults to 1e-6.
+        """
+        self.dis_type = dis_type
+        self.custom_integrator = custom_integrator
+        self.solver = solver
+        self.args = args if args is not None else {}
+        self.atol = atol
+        self.rtol = rtol
 
 @dataclass
 class DevConfig:
-    profiling: bool = False
-    debug: bool = False
-    printing: bool = True
 
-    """
-    Configuration class for development settings.
+    def __init__(self, profiling: bool = False, debug: bool = False, printing: bool = True):
+        """
+        Configuration class for development settings.
 
-    This class defines the parameters used for development and debugging purposes.
+        This class defines the parameters used for development and debugging purposes.
 
-    Main arguments:
-    These are the arguments most commonly used day-to-day.
-
-    Args:
-        profiling (bool): Whether to enable profiling for performance analysis. Defaults to False.
-        debug (bool): Disables all precompilation so you can place breakpoints and inspect values. Defaults to False.
-    """
+        Main arguments:
+        These are the arguments most commonly used day-to-day.
 
+        Args:
+            profiling (bool): Whether to enable profiling for performance analysis. Defaults to False.
+            debug (bool): Disables all precompilation so you can place breakpoints and inspect values. Defaults to False.
+            printing (bool): Whether to enable printing during development. Defaults to True.
+        """
+        self.profiling = profiling
+        self.debug = debug
+        self.printing = printing
 
 @dataclass
 class ConvexSolverConfig:
-    solver: str = "QOCO"
-    solver_args: dict = field(default_factory=lambda: {"abstol": 1e-6, "reltol": 1e-9})
-    cvxpygen: bool = False
-
-    """
-    Configuration class for convex solver settings.
-
-    This class defines the parameters required for configuring a convex solver.
-
-    These are the arguments most commonly used day-to-day. Generally I have found [QOCO](https://qoco-org.github.io/qoco/index.html) to be the most performant of the CVXPY solvers for these types of problems (I do have a bias as the author is from my group) and can handle up to SOCP's. 
-    [CLARABEL](https://clarabel.org/stable/) is also a great option with feasibility checking and can handle a few more problem types.
-    [CVXPYGen](https://github.com/cvxgrp/cvxpygen) is also great if your problem isn't too large and allows. I have found qocogen to be the most performant of the CVXPYGen solvers. 
-
-    Args:
-        solver (str):  The name of the CVXPY solver to use. A list of options can be found [here](https://www.cvxpy.org/tutorial/solvers/index.html). Defaults to "QOCO".
-        solver_args (dict): Ensure you are using the correct arguments for your solver as they are not all common. Additional arguments to configure the solver, such as tolerances. 
-                            Defaults to {"abstol": 1e-6, "reltol": 1e-9}.
-        cvxpygen (bool): Whether to enable CVXPY code generation for the solver. Defaults to False.
-    """
+    def __init__(
+        self,
+        solver: str = "QOCO",
+        solver_args: dict = {"abstol": 1e-6, "reltol": 1e-9, "enforce_dpp": True},
+        cvxpygen: bool = False,
+        cvxpygen_override: bool = False,
+    ):
+        """
+        Configuration class for convex solver settings.
+
+        This class defines the parameters required for configuring a convex solver.
+
+        These are the arguments most commonly used day-to-day. Generally I have found [QOCO](https://qoco-org.github.io/qoco/index.html)
+        to be the most performant of the CVXPY solvers for these types of problems (I do have a bias as the author is from my group)
+        and can handle up to SOCP's. [CLARABEL](https://clarabel.org/stable/) is also a great option with feasibility checking and
+        can handle a few more problem types. [CVXPYGen](https://github.com/cvxgrp/cvxpygen) is also great if your problem isn't too large.
+        I have found qocogen to be the most performant of the CVXPYGen solvers.
+
+        Args:
+            solver (str): The name of the CVXPY solver to use. A list of options can be found
+                        [here](https://www.cvxpy.org/tutorial/solvers/index.html). Defaults to "QOCO".
+            solver_args (dict, optional): Ensure you are using the correct arguments for your solver as they are not all common.
+                                        Additional arguments to configure the solver, such as tolerances.
+                                        Defaults to {"abstol": 1e-6, "reltol": 1e-9}.
+            cvxpygen (bool): Whether to enable CVXPY code generation for the solver. Defaults to False.
+        """
+        self.solver = solver
+        self.solver_args = solver_args if solver_args is not None else {"abstol": 1e-6, "reltol": 1e-9}
+        self.cvxpygen = cvxpygen
+        self.cvxpygen_override = cvxpygen_override
 
 
 @dataclass
 class PropagationConfig:
-    inter_sample: int = 30
-    dt: float = 0.1
-    solver: str = "Dopri8"
-    args: Dict = field(default_factory=dict)
-    atol: float = 1e-3
-    rtol: float = 1e-6
-
-    """
-    Configuration class for propagation settings.
-
-    This class defines the parameters required for propagating the nonlinear system dynamics using the optimal control sequence.
-
-    Main arguments:
-    These are the arguments most commonly used day-to-day.
-    
-    Args:
-        dt (float): The time step for propagation. Defaults to 0.1.
-        inter_sample (int): How dense the propagation within multishot discretization should be.
-
-    Other arguments:
-    The solver should likley not to be changed as it is a high accuracy 8th order runga kutta method.
-    
-    Args:
-        solver (str): The numerical solver to use for propagation (e.g., "Dopri8"). Defaults to "Dopri8".
-        args (Dict): Additional arguments to pass to the solver. Defaults to an empty dictionary.
-        atol (float): Absolute tolerance for the solver. Defaults to 1e-3.
-        rtol (float): Relative tolerance for the solver. Defaults to 1e-6.
-    """
-
-
-@dataclass
+    def __init__(
+        self,
+        inter_sample: int = 30,
+        dt: float = 0.01,
+        solver: str = "Dopri8",
+        max_tau_len: int = 1000,
+        args: Optional[Dict] = None,
+        atol: float = 1e-3,
+        rtol: float = 1e-6,
+    ):
+        """
+        Configuration class for propagation settings.
+
+        This class defines the parameters required for propagating the nonlinear system dynamics
+        using the optimal control sequence.
+
+        Main arguments:
+        These are the arguments most commonly used day-to-day.
+
+        Other arguments:
+        The solver should likely not be changed as it is a high accuracy 8th-order Runge-Kutta method.
+
+        Args:
+            inter_sample (int): How dense the propagation within multishot discretization should be. Defaults to 30.
+            dt (float): The time step for propagation. Defaults to 0.1.
+            solver (str): The numerical solver to use for propagation (e.g., "Dopri8"). Defaults to "Dopri8".
+            max_tau_len (int): The maximum length of the time vector for propagation. Defaults to 1000.
+            args (Dict, optional): Additional arguments to pass to the solver. Defaults to an empty dictionary.
+            atol (float): Absolute tolerance for the solver. Defaults to 1e-3.
+            rtol (float): Relative tolerance for the solver. Defaults to 1e-6.
+        """
+
+        self.inter_sample = inter_sample
+        self.dt = dt
+        self.solver = solver
+        self.max_tau_len = max_tau_len
+        self.args = args if args is not None else {}
+        self.atol = atol
+        self.rtol = rtol
+
+@dataclass(init=False)
 class SimConfig:
-    x_bar: np.ndarray
-    u_bar: np.ndarray
-    initial_state: BoundaryConstraint
-    initial_state_prop: BoundaryConstraint
-    final_state: np.ndarray
-    max_state: np.ndarray
-    min_state: np.ndarray
-    max_control: np.ndarray
-    min_control: np.ndarray
-    total_time: float
-    idx_x_true: slice
-    idx_x_true_prop: slice
-    idx_u_true: slice
-    idx_t: slice
-    idx_y: slice
-    idx_y_prop: slice
-    idx_s: slice
-    ctcs_node_intervals: list = None
-    constraints_ctcs: List[callable] = field(
-        default_factory=list
-    )  # TODO (norrisg): clean this up, consider moving to dedicated `constraints` dataclass
-    constraints_nodal: List[callable] = field(default_factory=list)
-    n_states: int = None
-    n_states_prop: int = None
-    n_controls: int = None
-    S_x: np.ndarray = None
-    inv_S_x: np.ndarray = None
-    c_x: np.ndarray = None
-    S_u: np.ndarray = None
-    inv_S_u: np.ndarray = None
-    c_u: np.ndarray = None
+    # No class-level field declarations
+    
+    def __init__(
+        self,
+        x: State,
+        x_prop: State,
+        u: Control,
+        total_time: float,
+        idx_x_true: slice,
+        idx_x_true_prop: slice,
+        idx_u_true: slice,
+        idx_t: slice,
+        idx_y: slice,
+        idx_y_prop: slice,
+        idx_s: slice,
+        save_compiled: bool = True,
+        ctcs_node_intervals: Optional[list] = None,
+        constraints_ctcs: Optional[List[Callable]] = None,
+        constraints_nodal: Optional[List[Callable]] = None,
+        n_states: Optional[int] = None,
+        n_states_prop: Optional[int] = None,
+        n_controls: Optional[int] = None,
+        scaling_x_overrides: Optional[list] = None,
+        scaling_u_overrides: Optional[list] = None,
+    ):
+        """
+        Configuration class for simulation settings.
+
+        This class defines the parameters required for simulating a trajectory optimization problem.
+
+        Main arguments:
+        These are the arguments most commonly used day-to-day.
+
+        Args:
+            x (State): State object, must have .min and .max attributes for bounds.
+            x_prop (State): Propagation state object, must have .min and .max attributes for bounds.
+            u (Control): Control object, must have .min and .max attributes for bounds.
+            total_time (float): The total simulation time.
+            idx_x_true (slice): Slice for true state indices.
+            idx_x_true_prop (slice): Slice for true propagation state indices.
+            idx_u_true (slice): Slice for true control indices.
+            idx_t (slice): Slice for time index.
+            idx_y (slice): Slice for constraint violation indices.
+            idx_y_prop (slice): Slice for propagation constraint violation indices.
+            idx_s (slice): Slice for time dilation index.
+            save_compiled (bool): If True, save and reuse compiled solver functions. Defaults to True.
+            ctcs_node_intervals (list, optional): Node intervals for CTCS constraints.
+            constraints_ctcs (list, optional): List of CTCS constraints.
+            constraints_nodal (list, optional): List of nodal constraints.
+            n_states (int, optional): The number of state variables. Defaults to `None` (inferred from x.max).
+            n_states_prop (int, optional): The number of propagation state variables. Defaults to `None` (inferred from x_prop.max).
+            n_controls (int, optional): The number of control variables. Defaults to `None` (inferred from u.max).
+            scaling_x_overrides (list, optional): List of (upper_bound, lower_bound, idx) for custom state scaling. Each can be scalar or array, idx can be int, list, or slice.
+            scaling_u_overrides (list, optional): List of (upper_bound, lower_bound, idx) for custom control scaling. Each can be scalar or array, idx can be int, list, or slice.
+
+        Note:
+            You can specify custom scaling for specific states/controls using scaling_x_overrides and scaling_u_overrides. Any indices not covered by overrides will use the default min/max bounds.
+        """
+        # Assign all arguments to self
+        self.x = x
+        self.x_prop = x_prop
+        self.u = u
+        self.total_time = total_time
+        self.idx_x_true = idx_x_true
+        self.idx_x_true_prop = idx_x_true_prop
+        self.idx_u_true = idx_u_true
+        self.idx_t = idx_t
+        self.idx_y = idx_y
+        self.idx_y_prop = idx_y_prop
+        self.idx_s = idx_s
+        self.save_compiled = save_compiled
+        self.ctcs_node_intervals = ctcs_node_intervals
+        self.constraints_ctcs = constraints_ctcs if constraints_ctcs is not None else []
+        self.constraints_nodal = constraints_nodal if constraints_nodal is not None else []
+        self.n_states = n_states
+        self.n_states_prop = n_states_prop
+        self.n_controls = n_controls
+        self.scaling_x_overrides = scaling_x_overrides
+        self.scaling_u_overrides = scaling_u_overrides
+
+        # Then call post init logic
+        self.__post_init__()
 
     def __post_init__(self):
-        self.n_states = len(self.max_state)
-        self.n_controls = len(self.max_control)
-
-        assert (
-            len(self.initial_state.value) == self.n_states - (self.idx_y.stop - self.idx_y.start)
-        ), f"Initial state must have {self.n_states - (self.idx_y.stop - self.idx_y.start)} elements"
-        assert (
-            len(self.final_state.value) == self.n_states - (self.idx_y.stop - self.idx_y.start)
-        ), f"Final state must have {self.n_states - (self.idx_y.stop - self.idx_y.start)} elements"
-        assert (
-            self.max_state.shape[0] == self.n_states
-        ), f"Max state must have {self.n_states} elements"
-        assert (
-            self.min_state.shape[0] == self.n_states
-        ), f"Min state must have {self.n_states} elements"
-        assert (
-            self.max_control.shape[0] == self.n_controls
-        ), f"Max control must have {self.n_controls} elements"
-        assert (
-            self.min_control.shape[0] == self.n_controls
-        ), f"Min control must have {self.n_controls} elements"
-
-        if self.S_x is None or self.c_x is None:
-            self.S_x, self.c_x = get_affine_scaling_matrices(
-                self.n_states, self.min_state, self.max_state
-            )
-            # Use the fact that S_x is diagonal to compute the inverse
-            self.inv_S_x = np.diag(1 / np.diag(self.S_x))
-        if self.S_u is None or self.c_u is None:
-            self.S_u, self.c_u = get_affine_scaling_matrices(
-                self.n_controls, self.min_control, self.max_control
-            )
-            self.inv_S_u = np.diag(1 / np.diag(self.S_u))
+        self.n_states = len(self.x.max)
+        self.n_controls = len(self.u.max)
+
+        # Helper to apply overrides
+        def apply_overrides(size, overrides, min_arr, max_arr):
+            upper = np.array(max_arr, dtype=float)
+            lower = np.array(min_arr, dtype=float)
+            if overrides is not None:
+                for ub, lb, idx in overrides:
+                    if isinstance(idx, int):
+                        idxs = [idx]
+                    elif isinstance(idx, slice):
+                        idxs = list(range(*idx.indices(size)))
+                    else:
+                        idxs = list(idx)
+                    if np.isscalar(ub):
+                        ub_vals = [ub] * len(idxs)
+                    else:
+                        ub_vals = ub
+                    if np.isscalar(lb):
+                        lb_vals = [lb] * len(idxs)
+                    else:
+                        lb_vals = lb
+                    for i, uval, lval in zip(idxs, ub_vals, lb_vals):
+                        upper[i] = uval
+                        lower[i] = lval
+            return upper, lower
+
+        # State scaling
+        min_x = np.array(self.x.min)
+        max_x = np.array(self.x.max)
+        upper_x, lower_x = apply_overrides(self.n_states, self.scaling_x_overrides, min_x, max_x)
+        S_x, c_x = get_affine_scaling_matrices(self.n_states, lower_x, upper_x)
+        self.S_x = S_x
+        self.c_x = c_x
+        self.inv_S_x = np.diag(1 / np.diag(self.S_x))
+
+        # Control scaling
+        min_u = np.array(self.u.min)
+        max_u = np.array(self.u.max)
+        upper_u, lower_u = apply_overrides(self.n_controls, self.scaling_u_overrides, min_u, max_u)
+        S_u, c_u = get_affine_scaling_matrices(self.n_controls, lower_u, upper_u)
+        self.S_u = S_u
+        self.c_u = c_u
+        self.inv_S_u = np.diag(1 / np.diag(self.S_u))
+
 
 
 @dataclass
 class ScpConfig:
-    n: int = None
-    k_max: int = 200
-    w_tr: float = 1e0
-    lam_vc: float = 1e0
-    ep_tr: float = 1e-4
-    ep_vb: float = 1e-4
-    ep_vc: float = 1e-8
-    lam_cost: float = 0.0
-    lam_vb: float = 0.0
-    uniform_time_grid: bool = False
-    cost_drop: int = -1
-    cost_relax: float = 1.0
-    w_tr_adapt: float = 1.0
-    w_tr_max: float = None
-    w_tr_max_scaling_factor: float = None
-
-    """
-    Configuration class for Sequential Convex Programming (SCP).
-
-    This class defines the parameters used to configure the SCP solver. You will very likely need to modify
-    the weights for your problem. Please refer to my guide [here](https://haynec.github.io/openscvx/hyperparameter_tuning) for more information.
-
-    Attributes:
-        n (int): The number of discretization nodes. Defaults to `None`.
-        k_max (int): The maximum number of SCP iterations. Defaults to 200.
-        w_tr (float): The trust region weight. Defaults to 1.0.
-        lam_vc (float): The penalty weight for virtual control. Defaults to 1.0.
-        ep_tr (float): The trust region convergence tolerance. Defaults to 1e-4.
-        ep_vb (float): The boundary constraint convergence tolerance. Defaults to 1e-4.
-        ep_vc (float): The virtual constraint convergence tolerance. Defaults to 1e-8.
-        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. TODO haynec add a link to the time dilation page. Defaults to `False`.
-        cost_drop (int): The number of iterations to allow for cost stagnation before termination. Defaults to -1 (disabled).
-        cost_relax (float): The relaxation factor for cost reduction. Defaults to 1.0.
-        w_tr_adapt (float): The adaptation factor for the trust region weight. Defaults to 1.0.
-        w_tr_max (float): The maximum allowable trust region weight. Defaults to `None`.
-        w_tr_max_scaling_factor (float): The scaling factor for the maximum trust region weight. Defaults to `None`.
-    """
+
+    def __init__(
+        self,
+        n: Optional[int] = None,
+        k_max: int = 200,
+        w_tr: float = 1.0,
+        lam_vc: float = 1.0,
+        ep_tr: float = 1e-4,
+        ep_vb: float = 1e-4,
+        ep_vc: float = 1e-8,
+        lam_cost: float = 0.0,
+        lam_vb: float = 0.0,
+        uniform_time_grid: bool = False,
+        cost_drop: int = -1,
+        cost_relax: float = 1.0,
+        w_tr_adapt: float = 1.0,
+        w_tr_max: Optional[float] = None,
+        w_tr_max_scaling_factor: Optional[float] = None,
+    ):
+        """
+        Configuration class for Sequential Convex Programming (SCP).
+
+        This class defines the parameters used to configure the SCP solver. You will very likely need to modify
+        the weights for your problem. Please refer to my guide [here](https://haynec.github.io/openscvx/hyperparameter_tuning) for more information.
+
+        Attributes:
+            n (int): The number of discretization nodes. Defaults to `None`.
+            k_max (int): The maximum number of SCP iterations. Defaults to 200.
+            w_tr (float): The trust region weight. Defaults to 1.0.
+            lam_vc (float): The penalty weight for virtual control. Defaults to 1.0.
+            ep_tr (float): The trust region convergence tolerance. Defaults to 1e-4.
+            ep_vb (float): The boundary constraint convergence tolerance. Defaults to 1e-4.
+            ep_vc (float): The virtual constraint convergence tolerance. Defaults to 1e-8.
+            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`.
+            cost_drop (int): The number of iterations to allow for cost stagnation before termination. Defaults to -1 (disabled).
+            cost_relax (float): The relaxation factor for cost reduction. Defaults to 1.0.
+            w_tr_adapt (float): The adaptation factor for the trust region weight. Defaults to 1.0.
+            w_tr_max (float): The maximum allowable trust region weight. Defaults to `None`.
+            w_tr_max_scaling_factor (float): The scaling factor for the maximum trust region weight. Defaults to `None`.
+        """
+        self.n = n
+        self.k_max = k_max
+        self.w_tr = w_tr
+        self.lam_vc = lam_vc
+        self.ep_tr = ep_tr
+        self.ep_vb = ep_vb
+        self.ep_vc = ep_vc
+        self.lam_cost = lam_cost
+        self.lam_vb = lam_vb
+        self.uniform_time_grid = uniform_time_grid
+        self.cost_drop = cost_drop
+        self.cost_relax = cost_relax
+        self.w_tr_adapt = w_tr_adapt
+        self.w_tr_max = w_tr_max
+        self.w_tr_max_scaling_factor = w_tr_max_scaling_factor
 
     def __post_init__(self):
         keys_to_scale = ["w_tr", "lam_vc", "lam_cost", "lam_vb"]
@@ -239,7 +352,6 @@ class ScpConfig:
         if self.w_tr_max_scaling_factor is not None and self.w_tr_max is None:
             self.w_tr_max = self.w_tr_max_scaling_factor * self.w_tr
 
-
 @dataclass
 class Config:
     sim: SimConfig

openscvx/constraints/__init__.py

@@ -1,10 +1,7 @@
-from .boundary import boundary, BoundaryConstraint
 from .ctcs import ctcs, CTCSConstraint
 from .nodal import nodal, NodalConstraint
 
 __all__ = [
-    "boundary",
-    "BoundaryConstraint",
     "ctcs",
     "CTCSConstraint",
     "nodal",